1\input texinfo @c -*- mode: texinfo; coding: utf-8 -*- 2@comment %**start of header (This is for running Texinfo on a region.) 3@c smallbook 4@setfilename ../../info/calc.info 5@c [title] 6@settitle GNU Emacs Calc Manual 7@include docstyle.texi 8@setchapternewpage odd 9@comment %**end of header (This is for running Texinfo on a region.) 10 11@include emacsver.texi 12 13@c The following macros are used for conditional output for single lines. 14@c @texline foo 15@c 'foo' will appear only in TeX output 16@c @infoline foo 17@c 'foo' will appear only in non-TeX output 18 19@c @expr{expr} will typeset an expression; 20@c $x$ in TeX, @samp{x} otherwise. 21 22@iftex 23@macro texline 24@end macro 25@alias infoline=comment 26@alias expr=math 27@alias tfn=code 28@alias mathit=expr 29@alias summarykey=key 30@macro cpi{} 31@math{@pi{}} 32@end macro 33@macro cpiover{den} 34@math{@pi/\den\} 35@end macro 36@end iftex 37 38@ifnottex 39@alias texline=comment 40@macro infoline{stuff} 41\stuff\ 42@end macro 43@alias expr=samp 44@alias tfn=t 45@alias mathit=i 46@macro summarykey{ky} 47\ky\ 48@end macro 49@macro cpi{} 50@expr{pi} 51@end macro 52@macro cpiover{den} 53@expr{pi/\den\} 54@end macro 55@end ifnottex 56 57 58@tex 59% Suggested by Karl Berry <karl@@freefriends.org> 60\gdef\!{\mskip-\thinmuskip} 61@end tex 62 63@c Fix some other things specifically for this manual. 64@iftex 65@finalout 66@mathcode`@:=`@: @c Make Calc fractions come out right in math mode 67@tex 68\gdef\coloneq{\mathrel{\mathord:\mathord=}} 69 70\gdef\beforedisplay{\vskip-10pt} 71\gdef\afterdisplay{\vskip-5pt} 72\gdef\beforedisplayh{\vskip-25pt} 73\gdef\afterdisplayh{\vskip-10pt} 74@end tex 75@newdimen@kyvpos @kyvpos=0pt 76@newdimen@kyhpos @kyhpos=0pt 77@newcount@calcclubpenalty @calcclubpenalty=1000 78@ignore 79@newcount@calcpageno 80@newtoks@calcoldeverypar @calcoldeverypar=@everypar 81@everypar={@calceverypar@the@calcoldeverypar} 82@ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi 83@catcode`@\=0 \catcode`\@=11 84\r@ggedbottomtrue 85\catcode`\@=0 @catcode`@\=@active 86@end ignore 87@end iftex 88 89@copying 90@ifinfo 91This file documents Calc, the GNU Emacs calculator. 92@end ifinfo 93@ifnotinfo 94This file documents Calc, the GNU Emacs calculator, included with 95GNU Emacs @value{EMACSVER}. 96@end ifnotinfo 97 98Copyright @copyright{} 1990--1991, 2001--2021 Free Software Foundation, 99Inc. 100 101@quotation 102Permission is granted to copy, distribute and/or modify this document 103under the terms of the GNU Free Documentation License, Version 1.3 or 104any later version published by the Free Software Foundation; with the 105Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the 106Front-Cover Texts being ``A GNU Manual,'' and with the Back-Cover 107Texts as in (a) below. A copy of the license is included in the section 108entitled ``GNU Free Documentation License.'' 109 110(a) The FSF's Back-Cover Text is: ``You have the freedom to copy and 111modify this GNU manual.'' 112@end quotation 113@end copying 114 115@dircategory Emacs misc features 116@direntry 117* Calc: (calc). Advanced desk calculator and mathematical tool. 118@end direntry 119 120@titlepage 121@sp 6 122@center @titlefont{Calc Manual} 123@sp 4 124@center GNU Emacs Calc 125@c [volume] 126@sp 5 127@center Dave Gillespie 128@center daveg@@synaptics.com 129@page 130 131@vskip 0pt plus 1filll 132@insertcopying 133@end titlepage 134 135 136@summarycontents 137 138@c [end] 139 140@contents 141 142@c [begin] 143@ifnottex 144@node Top, Getting Started, (dir), (dir) 145@top The GNU Emacs Calculator 146 147@noindent 148@dfn{Calc} is an advanced desk calculator and mathematical tool 149written by Dave Gillespie that runs as part of the GNU Emacs environment. 150 151This manual, also written (mostly) by Dave Gillespie, is divided into 152three major parts: ``Getting Started,'' the ``Calc Tutorial,'' and the 153``Calc Reference.'' The Tutorial introduces all the major aspects of 154Calculator use in an easy, hands-on way. The remainder of the manual is 155a complete reference to the features of the Calculator. 156@end ifnottex 157 158@ifinfo 159For help in the Emacs Info system (which you are using to read this 160file), type @kbd{?}. (You can also type @kbd{h} to run through a 161longer Info tutorial.) 162@end ifinfo 163 164@insertcopying 165 166@menu 167* Getting Started:: General description and overview. 168@ifinfo 169* Interactive Tutorial:: 170@end ifinfo 171* Tutorial:: A step-by-step introduction for beginners. 172 173* Introduction:: Introduction to the Calc reference manual. 174* Data Types:: Types of objects manipulated by Calc. 175* Stack and Trail:: Manipulating the stack and trail buffers. 176* Mode Settings:: Adjusting display format and other modes. 177* Arithmetic:: Basic arithmetic functions. 178* Scientific Functions:: Transcendentals and other scientific functions. 179* Matrix Functions:: Operations on vectors and matrices. 180* Algebra:: Manipulating expressions algebraically. 181* Units:: Operations on numbers with units. 182* Store and Recall:: Storing and recalling variables. 183* Graphics:: Commands for making graphs of data. 184* Kill and Yank:: Moving data into and out of Calc. 185* Keypad Mode:: Operating Calc from a keypad. 186* Embedded Mode:: Working with formulas embedded in a file. 187* Programming:: Calc as a programmable calculator. 188 189* Copying:: How you can copy and share Calc. 190* GNU Free Documentation License:: The license for this documentation. 191* Customizing Calc:: Customizing Calc. 192* Reporting Bugs:: How to report bugs and make suggestions. 193 194* Summary:: Summary of Calc commands and functions. 195 196* Key Index:: The standard Calc key sequences. 197* Command Index:: The interactive Calc commands. 198* Function Index:: Functions (in algebraic formulas). 199* Concept Index:: General concepts. 200* Variable Index:: Variables used by Calc (both user and internal). 201* Lisp Function Index:: Internal Lisp math functions. 202@end menu 203 204@ifinfo 205@node Getting Started, Interactive Tutorial, Top, Top 206@end ifinfo 207@ifnotinfo 208@node Getting Started, Tutorial, Top, Top 209@end ifnotinfo 210@chapter Getting Started 211@noindent 212This chapter provides a general overview of Calc, the GNU Emacs 213Calculator: What it is, how to start it and how to exit from it, 214and what are the various ways that it can be used. 215 216@menu 217* What is Calc:: 218* About This Manual:: 219* Notations Used in This Manual:: 220* Demonstration of Calc:: 221* Using Calc:: 222* History and Acknowledgments:: 223@end menu 224 225@node What is Calc, About This Manual, Getting Started, Getting Started 226@section What is Calc? 227 228@noindent 229@dfn{Calc} is an advanced calculator and mathematical tool that runs as 230part of the GNU Emacs environment. Very roughly based on the HP-28/48 231series of calculators, its many features include: 232 233@itemize @bullet 234@item 235Choice of algebraic or RPN (stack-based) entry of calculations. 236 237@item 238Arbitrary precision integers and floating-point numbers. 239 240@item 241Arithmetic on rational numbers, complex numbers (rectangular and polar), 242error forms with standard deviations, open and closed intervals, vectors 243and matrices, dates and times, infinities, sets, quantities with units, 244and algebraic formulas. 245 246@item 247Mathematical operations such as logarithms and trigonometric functions. 248 249@item 250Programmer's features (bitwise operations, non-decimal numbers). 251 252@item 253Financial functions such as future value and internal rate of return. 254 255@item 256Number theoretical features such as prime factorization and arithmetic 257modulo @var{m} for any @var{m}. 258 259@item 260Algebraic manipulation features, including symbolic calculus. 261 262@item 263Moving data to and from regular editing buffers. 264 265@item 266Embedded mode for manipulating Calc formulas and data directly 267inside any editing buffer. 268 269@item 270Graphics using GNUPLOT, a versatile (and free) plotting program. 271 272@item 273Easy programming using keyboard macros, algebraic formulas, 274algebraic rewrite rules, or extended Emacs Lisp. 275@end itemize 276 277Calc tries to include a little something for everyone; as a result it is 278large and might be intimidating to the first-time user. If you plan to 279use Calc only as a traditional desk calculator, all you really need to 280read is the ``Getting Started'' chapter of this manual and possibly the 281first few sections of the tutorial. As you become more comfortable with 282the program you can learn its additional features. Calc does not 283have the scope and depth of a fully-functional symbolic math package, 284but Calc has the advantages of convenience, portability, and freedom. 285 286@node About This Manual, Notations Used in This Manual, What is Calc, Getting Started 287@section About This Manual 288 289@noindent 290This document serves as a complete description of the GNU Emacs 291Calculator. It works both as an introduction for novices and as 292a reference for experienced users. While it helps to have some 293experience with GNU Emacs in order to get the most out of Calc, 294this manual ought to be readable even if you don't know or use Emacs 295regularly. 296 297This manual is divided into three major parts: the ``Getting 298Started'' chapter you are reading now, the Calc tutorial, and the Calc 299reference manual. 300@c [when-split] 301@c This manual has been printed in two volumes, the @dfn{Tutorial} and the 302@c @dfn{Reference}. Both volumes include a copy of the ``Getting Started'' 303@c chapter. 304 305If you are in a hurry to use Calc, there is a brief ``demonstration'' 306below which illustrates the major features of Calc in just a couple of 307pages. If you don't have time to go through the full tutorial, this 308will show you everything you need to know to begin. 309@xref{Demonstration of Calc}. 310 311The tutorial chapter walks you through the various parts of Calc 312with lots of hands-on examples and explanations. If you are new 313to Calc and you have some time, try going through at least the 314beginning of the tutorial. The tutorial includes about 70 exercises 315with answers. These exercises give you some guided practice with 316Calc, as well as pointing out some interesting and unusual ways 317to use its features. 318 319The reference section discusses Calc in complete depth. You can read 320the reference from start to finish if you want to learn every aspect 321of Calc. Or, you can look in the table of contents or the Concept 322Index to find the parts of the manual that discuss the things you 323need to know. 324 325@c @cindex Marginal notes 326Every Calc keyboard command is listed in the Calc Summary, and also 327in the Key Index. Algebraic functions, @kbd{M-x} commands, and 328variables also have their own indices. 329@c @texline Each 330@c @infoline In the printed manual, each 331@c paragraph that is referenced in the Key or Function Index is marked 332@c in the margin with its index entry. 333 334@c [fix-ref Help Commands] 335You can access this manual on-line at any time within Calc by pressing 336the @kbd{h i} key sequence. Outside of the Calc window, you can press 337@kbd{C-x * i} to read the manual on-line. From within Calc the command 338@kbd{h t} will jump directly to the Tutorial; from outside of Calc the 339command @kbd{C-x * t} will jump to the Tutorial and start Calc if 340necessary. Pressing @kbd{h s} or @kbd{C-x * s} will take you directly 341to the Calc Summary. Within Calc, you can also go to the part of the 342manual describing any Calc key, function, or variable using 343@w{@kbd{h k}}, @kbd{h f}, or @kbd{h v}, respectively. @xref{Help Commands}. 344 345@ifnottex 346The Calc manual can be printed, but because the manual is so large, you 347should only make a printed copy if you really need it. To print the 348manual, you will need the @TeX{} typesetting program (this is a free 349program by Donald Knuth at Stanford University) as well as the 350@file{texindex} program and @file{texinfo.tex} file, both of which can 351be obtained from the FSF as part of the @code{texinfo} package. 352To print the Calc manual in one huge tome, you will need the 353Emacs source, which contains the source code to this manual, 354@file{calc.texi}. Change to the @file{doc/misc} subdirectory of the 355Emacs source distribution, which contains source code for this manual, 356and type @kbd{make calc.pdf}. (Don't worry if you get some ``overfull 357box'' warnings while @TeX{} runs.) The result will be this entire 358manual as a pdf file. 359@end ifnottex 360@c Printed copies of this manual are also available from the Free Software 361@c Foundation. 362 363@node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started 364@section Notations Used in This Manual 365 366@noindent 367This section describes the various notations that are used 368throughout the Calc manual. 369 370In keystroke sequences, uppercase letters mean you must hold down 371the shift key while typing the letter. Keys pressed with Control 372held down are shown as @kbd{C-x}. Keys pressed with Meta held down 373are shown as @kbd{M-x}. Other notations are @key{RET} for the 374Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key, 375@key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key. 376The @key{DEL} key is called Backspace on some keyboards, it is 377whatever key you would use to correct a simple typing error when 378regularly using Emacs. 379 380(If you don't have the @key{LFD} or @key{TAB} keys on your keyboard, 381the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively. 382If you don't have a Meta key, look for Alt or Extend Char. You can 383also press @key{ESC} or @kbd{C-[} first to get the same effect, so 384that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.) 385 386Sometimes the @key{RET} key is not shown when it is ``obvious'' 387that you must press @key{RET} to proceed. For example, the @key{RET} 388is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}. 389 390Commands are generally shown like this: @kbd{p} (@code{calc-precision}) 391or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is 392normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence, 393but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}. 394 395Commands that correspond to functions in algebraic notation 396are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means 397the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that 398the corresponding function in an algebraic-style formula would 399be @samp{cos(@var{x})}. 400 401A few commands don't have key equivalents: @code{calc-sincos} 402[@code{sincos}]. 403 404@node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started 405@section A Demonstration of Calc 406 407@noindent 408@cindex Demonstration of Calc 409This section will show some typical small problems being solved with 410Calc. The focus is more on demonstration than explanation, but 411everything you see here will be covered more thoroughly in the 412Tutorial. 413 414To begin, start Emacs if necessary (usually the command @code{emacs} 415does this), and type @kbd{C-x * c} to start the 416Calculator. (You can also use @kbd{M-x calc} if this doesn't work. 417@xref{Starting Calc}, for various ways of starting the Calculator.) 418 419Be sure to type all the sample input exactly, especially noting the 420difference between lower-case and upper-case letters. Remember, 421@key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab, 422Delete, and Space keys. 423 424@strong{RPN calculation.} In RPN, you type the input number(s) first, 425then the command to operate on the numbers. 426 427@noindent 428Type @kbd{2 @key{RET} 3 + Q} to compute 429@texline @math{\sqrt{2+3} = 2.2360679775}. 430@infoline the square root of 2+3, which is 2.2360679775. 431 432@noindent 433Type @kbd{P 2 ^} to compute 434@texline @math{\pi^2 = 9.86960440109}. 435@infoline the value of @cpi{} squared, 9.86960440109. 436 437@noindent 438Type @key{TAB} to exchange the order of these two results. 439 440@noindent 441Type @kbd{- I H S} to subtract these results and compute the Inverse 442Hyperbolic sine of the difference, 2.72996136574. 443 444@noindent 445Type @key{DEL} to erase this result. 446 447@strong{Algebraic calculation.} You can also enter calculations using 448conventional ``algebraic'' notation. To enter an algebraic formula, 449use the apostrophe key. 450 451@noindent 452Type @kbd{' sqrt(2+3) @key{RET}} to compute 453@texline @math{\sqrt{2+3}}. 454@infoline the square root of 2+3. 455 456@noindent 457Type @kbd{' pi^2 @key{RET}} to enter 458@texline @math{\pi^2}. 459@infoline @cpi{} squared. 460To evaluate this symbolic formula as a number, type @kbd{=}. 461 462@noindent 463Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent 464result from the most-recent and compute the Inverse Hyperbolic sine. 465 466@strong{Keypad mode.} If you are using the X window system, press 467@w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to 468the next section.) 469 470@noindent 471Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT} 472``buttons'' using your left mouse button. 473 474@noindent 475Click on @key{PI}, @key{2}, and @tfn{y^x}. 476 477@noindent 478Click on @key{INV}, then @key{ENTER} to swap the two results. 479 480@noindent 481Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}. 482 483@noindent 484Click on @key{<-} to erase the result, then click @key{OFF} to turn 485the Keypad Calculator off. 486 487@strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc. 488Now select the following numbers as an Emacs region: ``Mark'' the 489front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there, 490then move to the other end of the list. (Either get this list from 491the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just 492type these numbers into a scratch file.) Now type @kbd{C-x * g} to 493``grab'' these numbers into Calc. 494 495@example 496@group 4971.23 1.97 4981.6 2 4991.19 1.08 500@end group 501@end example 502 503@noindent 504The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.'' 505Type @w{@kbd{V R +}} to compute the sum of these numbers. 506 507@noindent 508Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute 509the product of the numbers. 510 511@noindent 512You can also grab data as a rectangular matrix. Place the cursor on 513the upper-leftmost @samp{1} and set the mark, then move to just after 514the lower-right @samp{8} and press @kbd{C-x * r}. 515 516@noindent 517Type @kbd{v t} to transpose this 518@texline @math{3\times2} 519@infoline 3x2 520matrix into a 521@texline @math{2\times3} 522@infoline 2x3 523matrix. Type @w{@kbd{v u}} to unpack the rows into two separate 524vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums 525of the two original columns. (There is also a special 526grab-and-sum-columns command, @kbd{C-x * :}.) 527 528@strong{Units conversion.} Units are entered algebraically. 529Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour. 530Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}. 531 532@strong{Date arithmetic.} Type @kbd{t N} to get the current date and 533time. Type @kbd{90 +} to find the date 90 days from now. Type 534@kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how 535many weeks have passed since then. 536 537@strong{Algebra.} Algebraic entries can also include formulas 538or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}} 539to enter a pair of equations involving three variables. 540(Note the leading apostrophe in this example; also, note that the space 541in @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve 542these equations for the variables @expr{x} and @expr{y}. 543 544@noindent 545Type @kbd{d B} to view the solutions in more readable notation. 546Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T} 547to view them in the notation for the @TeX{} typesetting system, 548and @kbd{d L} to view them in the notation for the @LaTeX{} typesetting 549system. Type @kbd{d N} to return to normal notation. 550 551@noindent 552Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas. 553(That's the letter @kbd{l}, not the numeral @kbd{1}.) 554 555@ifnotinfo 556@strong{Help functions.} You can read about any command in the on-line 557manual. Type @kbd{C-x * c} to return to Calc after each of these 558commands: @kbd{h k t N} to read about the @kbd{t N} command, 559@kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and 560@kbd{h s} to read the Calc summary. 561@end ifnotinfo 562@ifinfo 563@strong{Help functions.} You can read about any command in the on-line 564manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to 565return here after each of these commands: @w{@kbd{h k t N}} to read 566about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the 567@code{sqrt} function, and @kbd{h s} to read the Calc summary. 568@end ifinfo 569 570Press @key{DEL} repeatedly to remove any leftover results from the stack. 571To exit from Calc, press @kbd{q} or @kbd{C-x * c} again. 572 573@node Using Calc, History and Acknowledgments, Demonstration of Calc, Getting Started 574@section Using Calc 575 576@noindent 577Calc has several user interfaces that are specialized for 578different kinds of tasks. As well as Calc's standard interface, 579there are Quick mode, Keypad mode, and Embedded mode. 580 581@menu 582* Starting Calc:: 583* The Standard Interface:: 584* Quick Mode Overview:: 585* Keypad Mode Overview:: 586* Standalone Operation:: 587* Embedded Mode Overview:: 588* Other C-x * Commands:: 589@end menu 590 591@node Starting Calc, The Standard Interface, Using Calc, Using Calc 592@subsection Starting Calc 593 594@noindent 595On most systems, you can type @kbd{C-x *} to start the Calculator. 596The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch}, 597which can be rebound if convenient (@pxref{Customizing Calc}). 598 599When you press @kbd{C-x *}, Emacs waits for you to press a second key to 600complete the command. In this case, you will follow @kbd{C-x *} with a 601letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says 602which Calc interface you want to use. 603 604To get Calc's standard interface, type @kbd{C-x * c}. To get 605Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief 606list of the available options, and type a second @kbd{?} to get 607a complete list. 608 609To ease typing, @kbd{C-x * *} also works to start Calc. It starts the 610same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last 611used, selecting the @kbd{C-x * c} interface by default. 612 613If @kbd{C-x *} doesn't work for you, you can always type explicit 614commands like @kbd{M-x calc} (for the standard user interface) or 615@w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x} 616(that's Meta with the letter @kbd{x}), then, at the prompt, 617type the full command (like @kbd{calc-keypad}) and press Return. 618 619The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start 620the Calculator also turn it off if it is already on. 621 622@node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc 623@subsection The Standard Calc Interface 624 625@noindent 626@cindex Standard user interface 627Calc's standard interface acts like a traditional RPN calculator, 628operated by the normal Emacs keyboard. When you type @kbd{C-x * c} 629to start the Calculator, the Emacs screen splits into two windows 630with the file you were editing on top and Calc on the bottom. 631 632@smallexample 633@group 634 635... 636--**-Emacs: myfile (Fundamental)----All---------------------- 637--- Emacs Calculator Mode --- |Emacs Calculator Trail 6382: 17.3 | 17.3 6391: -5 | 3 640 . | 2 641 | 4 642 | * 8 643 | ->-5 644 | 645--%*-Calc: 12 Deg (Calculator)----All----- --%*- *Calc Trail* 646@end group 647@end smallexample 648 649In this figure, the mode-line for @file{myfile} has moved up and the 650``Calculator'' window has appeared below it. As you can see, Calc 651actually makes two windows side-by-side. The lefthand one is 652called the @dfn{stack window} and the righthand one is called the 653@dfn{trail window.} The stack holds the numbers involved in the 654calculation you are currently performing. The trail holds a complete 655record of all calculations you have done. In a desk calculator with 656a printer, the trail corresponds to the paper tape that records what 657you do. 658 659In this case, the trail shows that four numbers (17.3, 3, 2, and 4) 660were first entered into the Calculator, then the 2 and 4 were 661multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}. 662(The @samp{>} symbol shows that this was the most recent calculation.) 663The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack. 664 665Most Calculator commands deal explicitly with the stack only, but 666there is a set of commands that allow you to search back through 667the trail and retrieve any previous result. 668 669Calc commands use the digits, letters, and punctuation keys. 670Shifted (i.e., upper-case) letters are different from lowercase 671letters. Some letters are @dfn{prefix} keys that begin two-letter 672commands. For example, @kbd{e} means ``enter exponent'' and shifted 673@kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix 674the letter ``e'' takes on very different meanings: @kbd{d e} means 675``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.'' 676 677There is nothing stopping you from switching out of the Calc 678window and back into your editing window, say by using the Emacs 679@w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is 680inside a regular window, Emacs acts just like normal. When the 681cursor is in the Calc stack or trail windows, keys are interpreted 682as Calc commands. 683 684When you quit by pressing @kbd{C-x * c} a second time, the Calculator 685windows go away but the actual Stack and Trail are not gone, just 686hidden. When you press @kbd{C-x * c} once again you will get the 687same stack and trail contents you had when you last used the 688Calculator. 689 690The Calculator does not remember its state between Emacs sessions. 691Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you 692a fresh stack and trail. There is a command (@kbd{m m}) that lets 693you save your favorite mode settings between sessions, though. 694One of the things it saves is which user interface (standard or 695Keypad) you last used; otherwise, a freshly started Emacs will 696always treat @kbd{C-x * *} the same as @kbd{C-x * c}. 697 698The @kbd{q} key is another equivalent way to turn the Calculator off. 699 700If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a 701full-screen version of Calc (@code{full-calc}) in which the stack and 702trail windows are still side-by-side but are now as tall as the whole 703Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit, 704the file you were editing before reappears. The @kbd{C-x * b} key 705switches back and forth between ``big'' full-screen mode and the 706normal partial-screen mode. 707 708Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c} 709except that the Calc window is not selected. The buffer you were 710editing before remains selected instead. If you are in a Calc window, 711then @kbd{C-x * o} will switch you out of it, being careful not to 712switch you to the Calc Trail window. So @kbd{C-x * o} is a handy 713way to switch out of Calc momentarily to edit your file; you can then 714type @kbd{C-x * c} to switch back into Calc when you are done. 715 716@node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc 717@subsection Quick Mode (Overview) 718 719@noindent 720@dfn{Quick mode} is a quick way to use Calc when you don't need the 721full complexity of the stack and trail. To use it, type @kbd{C-x * q} 722(@code{quick-calc}) in any regular editing buffer. 723 724Quick mode is very simple: It prompts you to type any formula in 725standard algebraic notation (like @samp{4 - 2/3}) and then displays 726the result at the bottom of the Emacs screen (@mathit{3.33333333333} 727in this case). You are then back in the same editing buffer you 728were in before, ready to continue editing or to type @kbd{C-x * q} 729again to do another quick calculation. The result of the calculation 730will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command 731at this point will yank the result into your editing buffer. 732 733Calc mode settings affect Quick mode, too, though you will have to 734go into regular Calc (with @kbd{C-x * c}) to change the mode settings. 735 736@c [fix-ref Quick Calculator mode] 737@xref{Quick Calculator}, for further information. 738 739@node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc 740@subsection Keypad Mode (Overview) 741 742@noindent 743@dfn{Keypad mode} is a mouse-based interface to the Calculator. 744It is designed for use with terminals that support a mouse. If you 745don't have a mouse, you will have to operate Keypad mode with your 746arrow keys (which is probably more trouble than it's worth). 747 748Type @kbd{C-x * k} to turn Keypad mode on or off. Once again you 749get two new windows, this time on the righthand side of the screen 750instead of at the bottom. The upper window is the familiar Calc 751Stack; the lower window is a picture of a typical calculator keypad. 752 753@tex 754\dimen0=\pagetotal% 755\advance \dimen0 by 24\baselineskip% 756\ifdim \dimen0>\pagegoal \vfill\eject \fi% 757\medskip 758@end tex 759@smallexample 760@group 761|--- Emacs Calculator Mode --- 762|2: 17.3 763|1: -5 764| . 765|--%*-Calc: 12 Deg (Calcul 766|----+----+--Calc---+----+----1 767|FLR |CEIL|RND |TRNC|CLN2|FLT | 768|----+----+----+----+----+----| 769| LN |EXP | |ABS |IDIV|MOD | 770|----+----+----+----+----+----| 771|SIN |COS |TAN |SQRT|y^x |1/x | 772|----+----+----+----+----+----| 773| ENTER |+/- |EEX |UNDO| <- | 774|-----+---+-+--+--+-+---++----| 775| INV | 7 | 8 | 9 | / | 776|-----+-----+-----+-----+-----| 777| HYP | 4 | 5 | 6 | * | 778|-----+-----+-----+-----+-----| 779|EXEC | 1 | 2 | 3 | - | 780|-----+-----+-----+-----+-----| 781| OFF | 0 | . | PI | + | 782|-----+-----+-----+-----+-----+ 783@end group 784@end smallexample 785 786Keypad mode is much easier for beginners to learn, because there 787is no need to memorize lots of obscure key sequences. But not all 788commands in regular Calc are available on the Keypad. You can 789always switch the cursor into the Calc stack window to use 790standard Calc commands if you need. Serious Calc users, though, 791often find they prefer the standard interface over Keypad mode. 792 793To operate the Calculator, just click on the ``buttons'' of the 794keypad using your left mouse button. To enter the two numbers 795shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to 796add them together you would then click @kbd{+} (to get 12.3 on 797the stack). 798 799If you click the right mouse button, the top three rows of the 800keypad change to show other sets of commands, such as advanced 801math functions, vector operations, and operations on binary 802numbers. 803 804Because Keypad mode doesn't use the regular keyboard, Calc leaves 805the cursor in your original editing buffer. You can type in 806this buffer in the usual way while also clicking on the Calculator 807keypad. One advantage of Keypad mode is that you don't need an 808explicit command to switch between editing and calculating. 809 810If you press @kbd{C-x * b} first, you get a full-screen Keypad mode 811(@code{full-calc-keypad}) with three windows: The keypad in the lower 812left, the stack in the lower right, and the trail on top. 813 814@c [fix-ref Keypad Mode] 815@xref{Keypad Mode}, for further information. 816 817@node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc 818@subsection Standalone Operation 819 820@noindent 821@cindex Standalone Operation 822If you are not in Emacs at the moment but you wish to use Calc, 823you must start Emacs first. If all you want is to run Calc, you 824can give the commands: 825 826@example 827emacs -f full-calc 828@end example 829 830@noindent 831or 832 833@example 834emacs -f full-calc-keypad 835@end example 836 837@noindent 838which run a full-screen Calculator (as if by @kbd{C-x * b C-x * c}) or 839a full-screen X-based Calculator (as if by @kbd{C-x * b C-x * k}). 840In standalone operation, quitting the Calculator (by pressing 841@kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs 842itself. 843 844@node Embedded Mode Overview, Other C-x * Commands, Standalone Operation, Using Calc 845@subsection Embedded Mode (Overview) 846 847@noindent 848@dfn{Embedded mode} is a way to use Calc directly from inside an 849editing buffer. Suppose you have a formula written as part of a 850document like this: 851 852@smallexample 853@group 854The derivative of 855 856 ln(ln(x)) 857 858is 859@end group 860@end smallexample 861 862@noindent 863and you wish to have Calc compute and format the derivative for 864you and store this derivative in the buffer automatically. To 865do this with Embedded mode, first copy the formula down to where 866you want the result to be, leaving a blank line before and after the 867formula: 868 869@smallexample 870@group 871The derivative of 872 873 ln(ln(x)) 874 875is 876 877 ln(ln(x)) 878@end group 879@end smallexample 880 881Now, move the cursor onto this new formula and press @kbd{C-x * e}. 882Calc will read the formula (using the surrounding blank lines to tell 883how much text to read), then push this formula (invisibly) onto the Calc 884stack. The cursor will stay on the formula in the editing buffer, but 885the line with the formula will now appear as it would on the Calc stack 886(in this case, it will be left-aligned) and the buffer's mode line will 887change to look like the Calc mode line (with mode indicators like 888@samp{12 Deg} and so on). Even though you are still in your editing 889buffer, the keyboard now acts like the Calc keyboard, and any new result 890you get is copied from the stack back into the buffer. To take the 891derivative, you would type @kbd{a d x @key{RET}}. 892 893@smallexample 894@group 895The derivative of 896 897 ln(ln(x)) 898 899is 900 9011 / x ln(x) 902@end group 903@end smallexample 904 905(Note that by default, Calc gives division lower precedence than multiplication, 906so that @samp{1 / x ln(x)} is equivalent to @samp{1 / (x ln(x))}.) 907 908To make this look nicer, you might want to press @kbd{d =} to center 909the formula, and even @kbd{d B} to use Big display mode. 910 911@smallexample 912@group 913The derivative of 914 915 ln(ln(x)) 916 917is 918% [calc-mode: justify: center] 919% [calc-mode: language: big] 920 921 1 922 ------- 923 x ln(x) 924@end group 925@end smallexample 926 927Calc has added annotations to the file to help it remember the modes 928that were used for this formula. They are formatted like comments 929in the @TeX{} typesetting language, just in case you are using @TeX{} or 930@LaTeX{}. (In this example @TeX{} is not being used, so you might want 931to move these comments up to the top of the file or otherwise put them 932out of the way.) 933 934As an extra flourish, we can add an equation number using a 935righthand label: Type @kbd{d @} (1) @key{RET}}. 936 937@smallexample 938@group 939% [calc-mode: justify: center] 940% [calc-mode: language: big] 941% [calc-mode: right-label: " (1)"] 942 943 1 944 ------- (1) 945 ln(x) x 946@end group 947@end smallexample 948 949To leave Embedded mode, type @kbd{C-x * e} again. The mode line 950and keyboard will revert to the way they were before. 951 952The related command @kbd{C-x * w} operates on a single word, which 953generally means a single number, inside text. It searches for an 954expression which ``looks'' like a number containing the point. 955Here's an example of its use (before you try this, remove the Calc 956annotations or use a new buffer so that the extra settings in the 957annotations don't take effect): 958 959@smallexample 960A slope of one-third corresponds to an angle of 1 degrees. 961@end smallexample 962 963Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable 964Embedded mode on that number. Now type @kbd{3 /} (to get one-third), 965and @kbd{I T} (the Inverse Tangent converts a slope into an angle), 966then @w{@kbd{C-x * w}} again to exit Embedded mode. 967 968@smallexample 969A slope of one-third corresponds to an angle of 18.4349488229 degrees. 970@end smallexample 971 972@c [fix-ref Embedded Mode] 973@xref{Embedded Mode}, for full details. 974 975@node Other C-x * Commands, , Embedded Mode Overview, Using Calc 976@subsection Other @kbd{C-x *} Commands 977 978@noindent 979Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r}, 980which ``grab'' data from a selected region of a buffer into the 981Calculator. The region is defined in the usual Emacs way, by 982a ``mark'' placed at one end of the region, and the Emacs 983cursor or ``point'' placed at the other. 984 985The @kbd{C-x * g} command reads the region in the usual left-to-right, 986top-to-bottom order. The result is packaged into a Calc vector 987of numbers and placed on the stack. Calc (in its standard 988user interface) is then started. Type @kbd{v u} if you want 989to unpack this vector into separate numbers on the stack. Also, 990@kbd{C-u C-x * g} interprets the region as a single number or 991formula. 992 993The @kbd{C-x * r} command reads a rectangle, with the point and 994mark defining opposite corners of the rectangle. The result 995is a matrix of numbers on the Calculator stack. 996 997Complementary to these is @kbd{C-x * y}, which ``yanks'' the 998value at the top of the Calc stack back into an editing buffer. 999If you type @w{@kbd{C-x * y}} while in such a buffer, the value is 1000yanked at the current position. If you type @kbd{C-x * y} while 1001in the Calc buffer, Calc makes an educated guess as to which 1002editing buffer you want to use. The Calc window does not have 1003to be visible in order to use this command, as long as there 1004is something on the Calc stack. 1005 1006Here, for reference, is the complete list of @kbd{C-x *} commands. 1007The shift, control, and meta keys are ignored for the keystroke 1008following @kbd{C-x *}. 1009 1010@noindent 1011Commands for turning Calc on and off: 1012 1013@table @kbd 1014@item * 1015Turn Calc on or off, employing the same user interface as last time. 1016 1017@item =, +, -, /, \, &, # 1018Alternatives for @kbd{*}. 1019 1020@item C 1021Turn Calc on or off using its standard bottom-of-the-screen 1022interface. If Calc is already turned on but the cursor is not 1023in the Calc window, move the cursor into the window. 1024 1025@item O 1026Same as @kbd{C}, but don't select the new Calc window. If 1027Calc is already turned on and the cursor is in the Calc window, 1028move it out of that window. 1029 1030@item B 1031Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen. 1032 1033@item Q 1034Use Quick mode for a single short calculation. 1035 1036@item K 1037Turn Calc Keypad mode on or off. 1038 1039@item E 1040Turn Calc Embedded mode on or off at the current formula. 1041 1042@item J 1043Turn Calc Embedded mode on or off, select the interesting part. 1044 1045@item W 1046Turn Calc Embedded mode on or off at the current word (number). 1047 1048@item Z 1049Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command. 1050 1051@item X 1052Quit Calc; turn off standard, Keypad, or Embedded mode if on. 1053(This is like @kbd{q} or @key{OFF} inside of Calc.) 1054@end table 1055@iftex 1056@sp 2 1057@end iftex 1058 1059@noindent 1060Commands for moving data into and out of the Calculator: 1061 1062@table @kbd 1063@item G 1064Grab the region into the Calculator as a vector. 1065 1066@item R 1067Grab the rectangular region into the Calculator as a matrix. 1068 1069@item : 1070Grab the rectangular region and compute the sums of its columns. 1071 1072@item _ 1073Grab the rectangular region and compute the sums of its rows. 1074 1075@item Y 1076Yank a value from the Calculator into the current editing buffer. 1077@end table 1078@iftex 1079@sp 2 1080@end iftex 1081 1082@noindent 1083Commands for use with Embedded mode: 1084 1085@table @kbd 1086@item A 1087``Activate'' the current buffer. Locate all formulas that 1088contain @samp{:=} or @samp{=>} symbols and record their locations 1089so that they can be updated automatically as variables are changed. 1090 1091@item D 1092Duplicate the current formula immediately below and select 1093the duplicate. 1094 1095@item F 1096Insert a new formula at the current point. 1097 1098@item N 1099Move the cursor to the next active formula in the buffer. 1100 1101@item P 1102Move the cursor to the previous active formula in the buffer. 1103 1104@item U 1105Update (i.e., as if by the @kbd{=} key) the formula at the current point. 1106 1107@item ` 1108Edit (as if by @code{calc-edit}) the formula at the current point. 1109@end table 1110@iftex 1111@sp 2 1112@end iftex 1113 1114@noindent 1115Miscellaneous commands: 1116 1117@table @kbd 1118@item I 1119Run the Emacs Info system to read the Calc manual. 1120(This is the same as @kbd{h i} inside of Calc.) 1121 1122@item T 1123Run the Emacs Info system to read the Calc Tutorial. 1124 1125@item S 1126Run the Emacs Info system to read the Calc Summary. 1127 1128@item L 1129Load Calc entirely into memory. (Normally the various parts 1130are loaded only as they are needed.) 1131 1132@item M 1133Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}}) 1134and record them as the current keyboard macro. 1135 1136@item 0 1137(This is the ``zero'' digit key.) Reset the Calculator to 1138its initial state: Empty stack, and initial mode settings. 1139@end table 1140 1141@node History and Acknowledgments, , Using Calc, Getting Started 1142@section History and Acknowledgments 1143 1144@noindent 1145Calc was originally started as a two-week project to occupy a lull 1146in the author's schedule. Basically, a friend asked if I remembered 1147the value of 1148@texline @math{2^{32}}. 1149@infoline @expr{2^32}. 1150I didn't offhand, but I said, ``that's easy, just call up an 1151@code{xcalc}.'' @code{Xcalc} duly reported that the answer to our 1152question was @samp{4.294967e+09}---with no way to see the full ten 1153digits even though we knew they were there in the program's memory! I 1154was so annoyed, I vowed to write a calculator of my own, once and for 1155all. 1156 1157I chose Emacs Lisp, a) because I had always been curious about it 1158and b) because, being only a text editor extension language after 1159all, Emacs Lisp would surely reach its limits long before the project 1160got too far out of hand. 1161 1162To make a long story short, Emacs Lisp turned out to be a distressingly 1163solid implementation of Lisp, and the humble task of calculating 1164turned out to be more open-ended than one might have expected. 1165 1166Emacs Lisp didn't have built-in floating point math (now it does), so 1167this had to be simulated in software. In fact, Emacs integers would 1168only comfortably fit six decimal digits or so (at the time)---not 1169enough for a decent calculator. So I had to write my own 1170high-precision integer code as well, and once I had this I figured 1171that arbitrary-size integers were just as easy as large integers. 1172Arbitrary floating-point precision was the logical next step. Also, 1173since the large integer arithmetic was there anyway it seemed only 1174fair to give the user direct access to it, which in turn made it 1175practical to support fractions as well as floats. All these features 1176inspired me to look around for other data types that might be worth 1177having. 1178 1179Around this time, my friend Rick Koshi showed me his nifty new HP-28 1180calculator. It allowed the user to manipulate formulas as well as 1181numerical quantities, and it could also operate on matrices. I 1182decided that these would be good for Calc to have, too. And once 1183things had gone this far, I figured I might as well take a look at 1184serious algebra systems for further ideas. Since these systems did 1185far more than I could ever hope to implement, I decided to focus on 1186rewrite rules and other programming features so that users could 1187implement what they needed for themselves. 1188 1189Rick complained that matrices were hard to read, so I put in code to 1190format them in a 2D style. Once these routines were in place, Big mode 1191was obligatory. Gee, what other language modes would be useful? 1192 1193Scott Hemphill and Allen Knutson, two friends with a strong mathematical 1194bent, contributed ideas and algorithms for a number of Calc features 1195including modulo forms, primality testing, and float-to-fraction conversion. 1196 1197Units were added at the eager insistence of Mass Sivilotti. Later, 1198Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable 1199expert assistance with the units table. As far as I can remember, the 1200idea of using algebraic formulas and variables to represent units dates 1201back to an ancient article in Byte magazine about muMath, an early 1202algebra system for microcomputers. 1203 1204Many people have contributed to Calc by reporting bugs and suggesting 1205features, large and small. A few deserve special mention: Tim Peters, 1206who helped develop the ideas that led to the selection commands, rewrite 1207rules, and many other algebra features; François 1208Pinard, who contributed an early prototype of the Calc Summary appendix 1209as well as providing valuable suggestions in many other areas of Calc; 1210Carl Witty, whose eagle eyes discovered many typographical and factual 1211errors in the Calc manual; Tim Kay, who drove the development of 1212Embedded mode; Ove Ewerlid, who made many suggestions relating to the 1213algebra commands and contributed some code for polynomial operations; 1214Randal Schwartz, who suggested the @code{calc-eval} function; Juha 1215Sarlin, who first worked out how to split Calc into quickly-loading 1216parts; Bob Weiner, who helped immensely with the Lucid Emacs port; and 1217Robert J. Chassell, who suggested the Calc Tutorial and exercises as 1218well as many other things. 1219 1220@cindex Bibliography 1221@cindex Knuth, Art of Computer Programming 1222@cindex Numerical Recipes 1223@c Should these be expanded into more complete references? 1224Among the books used in the development of Calc were Knuth's @emph{Art 1225of Computer Programming} (especially volume II, @emph{Seminumerical 1226Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky, 1227and Vetterling; Bevington's @emph{Data Reduction and Error Analysis 1228for the Physical Sciences}; @emph{Concrete Mathematics} by Graham, 1229Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the 1230@emph{CRC Standard Math Tables} (William H. Beyer, ed.); and 1231Abramowitz and Stegun's venerable @emph{Handbook of Mathematical 1232Functions}. Also, of course, Calc could not have been written without 1233the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and 1234Dan LaLiberte. 1235 1236Final thanks go to Richard Stallman, without whose fine implementations 1237of the Emacs editor, language, and environment, Calc would have been 1238finished in two weeks. 1239 1240@c [tutorial] 1241 1242@ifinfo 1243@c This node is accessed by the 'C-x * t' command. 1244@node Interactive Tutorial, Tutorial, Getting Started, Top 1245@chapter Tutorial 1246 1247@noindent 1248Some brief instructions on using the Emacs Info system for this tutorial: 1249 1250Press the space bar and Delete keys to go forward and backward in a 1251section by screenfuls (or use the regular Emacs scrolling commands 1252for this). 1253 1254Press @kbd{n} or @kbd{p} to go to the Next or Previous section. 1255If the section has a @dfn{menu}, press a digit key like @kbd{1} 1256or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to 1257go back up from a sub-section to the menu it is part of. 1258 1259Exercises in the tutorial all have cross-references to the 1260appropriate page of the ``answers'' section. Press @kbd{f}, then 1261the exercise number, to see the answer to an exercise. After 1262you have followed a cross-reference, you can press the letter 1263@kbd{l} to return to where you were before. 1264 1265You can press @kbd{?} at any time for a brief summary of Info commands. 1266 1267Press the number @kbd{1} now to enter the first section of the Tutorial. 1268 1269@menu 1270* Tutorial:: 1271@end menu 1272 1273@node Tutorial, Introduction, Interactive Tutorial, Top 1274@end ifinfo 1275@ifnotinfo 1276@node Tutorial, Introduction, Getting Started, Top 1277@end ifnotinfo 1278@chapter Tutorial 1279 1280@noindent 1281This chapter explains how to use Calc and its many features, in 1282a step-by-step, tutorial way. You are encouraged to run Calc and 1283work along with the examples as you read (@pxref{Starting Calc}). 1284If you are already familiar with advanced calculators, you may wish 1285@c [not-split] 1286to skip on to the rest of this manual. 1287@c [when-split] 1288@c to skip on to volume II of this manual, the @dfn{Calc Reference}. 1289 1290@c [fix-ref Embedded Mode] 1291This tutorial describes the standard user interface of Calc only. 1292The Quick mode and Keypad mode interfaces are fairly 1293self-explanatory. @xref{Embedded Mode}, for a description of 1294the Embedded mode interface. 1295 1296The easiest way to read this tutorial on-line is to have two windows on 1297your Emacs screen, one with Calc and one with the Info system. Press 1298@kbd{C-x * t} to set this up; the on-line tutorial will be opened in the 1299current window and Calc will be started in another window. From the 1300Info window, the command @kbd{C-x * c} can be used to switch to the Calc 1301window and @kbd{C-x * o} can be used to switch back to the Info window. 1302(If you have a printed copy of the manual you can use that instead; in 1303that case you only need to press @kbd{C-x * c} to start Calc.) 1304 1305This tutorial is designed to be done in sequence. But the rest of this 1306manual does not assume you have gone through the tutorial. The tutorial 1307does not cover everything in the Calculator, but it touches on most 1308general areas. 1309 1310@ifnottex 1311You may wish to print out a copy of the Calc Summary and keep notes on 1312it as you learn Calc. @xref{About This Manual}, to see how to make a 1313printed summary. @xref{Summary}. 1314@end ifnottex 1315@iftex 1316The Calc Summary at the end of the reference manual includes some blank 1317space for your own use. You may wish to keep notes there as you learn 1318Calc. 1319@end iftex 1320 1321@menu 1322* Basic Tutorial:: 1323* Arithmetic Tutorial:: 1324* Vector/Matrix Tutorial:: 1325* Types Tutorial:: 1326* Algebra Tutorial:: 1327* Programming Tutorial:: 1328 1329* Answers to Exercises:: 1330@end menu 1331 1332@node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial 1333@section Basic Tutorial 1334 1335@noindent 1336In this section, we learn how RPN and algebraic-style calculations 1337work, how to undo and redo an operation done by mistake, and how 1338to control various modes of the Calculator. 1339 1340@menu 1341* RPN Tutorial:: Basic operations with the stack. 1342* Algebraic Tutorial:: Algebraic entry; variables. 1343* Undo Tutorial:: If you make a mistake: Undo and the trail. 1344* Modes Tutorial:: Common mode-setting commands. 1345@end menu 1346 1347@node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial 1348@subsection RPN Calculations and the Stack 1349 1350@cindex RPN notation 1351@noindent 1352@ifnottex 1353Calc normally uses RPN notation. You may be familiar with the RPN 1354system from Hewlett-Packard calculators, FORTH, or PostScript. 1355(Reverse Polish Notation, RPN, is named after the Polish mathematician 1356Jan Lukasiewicz.) 1357@end ifnottex 1358@tex 1359Calc normally uses RPN notation. You may be familiar with the RPN 1360system from Hewlett-Packard calculators, FORTH, or PostScript. 1361(Reverse Polish Notation, RPN, is named after the Polish mathematician 1362Jan \L ukasiewicz.) 1363@end tex 1364 1365The central component of an RPN calculator is the @dfn{stack}. A 1366calculator stack is like a stack of dishes. New dishes (numbers) are 1367added at the top of the stack, and numbers are normally only removed 1368from the top of the stack. 1369 1370@cindex Operators 1371@cindex Operands 1372In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands} 1373and the @expr{+} is the @dfn{operator}. In an RPN calculator you always 1374enter the operands first, then the operator. Each time you type a 1375number, Calc adds or @dfn{pushes} it onto the top of the Stack. 1376When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate 1377number of operands from the stack and pushes back the result. 1378 1379Thus we could add the numbers 2 and 3 in an RPN calculator by typing: 1380@kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to 1381the @key{ENTER} key on traditional RPN calculators.) Try this now if 1382you wish; type @kbd{C-x * c} to switch into the Calc window (you can type 1383@kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window). 1384The first four keystrokes ``push'' the numbers 2 and 3 onto the stack. 1385The @kbd{+} key ``pops'' the top two numbers from the stack, adds them, 1386and pushes the result (5) back onto the stack. Here's how the stack 1387will look at various points throughout the calculation: 1388 1389@smallexample 1390@group 1391 . 1: 2 2: 2 1: 5 . 1392 . 1: 3 . 1393 . 1394 1395 C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL} 1396@end group 1397@end smallexample 1398 1399The @samp{.} symbol is a marker that represents the top of the stack. 1400Note that the ``top'' of the stack is really shown at the bottom of 1401the Stack window. This may seem backwards, but it turns out to be 1402less distracting in regular use. 1403 1404@cindex Stack levels 1405@cindex Levels of stack 1406The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level 1407numbers}. Old RPN calculators always had four stack levels called 1408@expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow 1409as large as you like, so it uses numbers instead of letters. Some 1410stack-manipulation commands accept a numeric argument that says 1411which stack level to work on. Normal commands like @kbd{+} always 1412work on the top few levels of the stack. 1413 1414@c [fix-ref Truncating the Stack] 1415The Stack buffer is just an Emacs buffer, and you can move around in 1416it using the regular Emacs motion commands. But no matter where the 1417cursor is, even if you have scrolled the @samp{.} marker out of 1418view, most Calc commands always move the cursor back down to level 1 1419before doing anything. It is possible to move the @samp{.} marker 1420upwards through the stack, temporarily ``hiding'' some numbers from 1421commands like @kbd{+}. This is called @dfn{stack truncation} and 1422we will not cover it in this tutorial; @pxref{Truncating the Stack}, 1423if you are interested. 1424 1425You don't really need the second @key{RET} in @kbd{2 @key{RET} 3 1426@key{RET} +}. That's because if you type any operator name or 1427other non-numeric key when you are entering a number, the Calculator 1428automatically enters that number and then does the requested command. 1429Thus @kbd{2 @key{RET} 3 +} will work just as well. 1430 1431Examples in this tutorial will often omit @key{RET} even when the 1432stack displays shown would only happen if you did press @key{RET}: 1433 1434@smallexample 1435@group 14361: 2 2: 2 1: 5 1437 . 1: 3 . 1438 . 1439 1440 2 @key{RET} 3 + 1441@end group 1442@end smallexample 1443 1444@noindent 1445Here, after pressing @kbd{3} the stack would really show @samp{1: 2} 1446with @samp{Calc:@: 3} in the minibuffer. In these situations, you can 1447press the optional @key{RET} to see the stack as the figure shows. 1448 1449(@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises 1450at various points. Try them if you wish. Answers to all the exercises 1451are located at the end of the Tutorial chapter. Each exercise will 1452include a cross-reference to its particular answer. If you are 1453reading with the Emacs Info system, press @kbd{f} and the 1454exercise number to go to the answer, then the letter @kbd{l} to 1455return to where you were.) 1456 1457@noindent 1458Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2 1459@key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for 1460multiplication.) Figure it out by hand, then try it with Calc to see 1461if you're right. @xref{RPN Answer 1, 1}. (@bullet{}) 1462 1463(@bullet{}) @strong{Exercise 2.} Compute 1464@texline @math{(2\times4) + (7\times9.5) + {5\over4}} 1465@infoline @expr{2*4 + 7*9.5 + 5/4} 1466using the stack. @xref{RPN Answer 2, 2}. (@bullet{}) 1467 1468The @key{DEL} key is called Backspace on some keyboards. It is 1469whatever key you would use to correct a simple typing error when 1470regularly using Emacs. The @key{DEL} key pops and throws away the 1471top value on the stack. (You can still get that value back from 1472the Trail if you should need it later on.) There are many places 1473in this tutorial where we assume you have used @key{DEL} to erase the 1474results of the previous example at the beginning of a new example. 1475In the few places where it is really important to use @key{DEL} to 1476clear away old results, the text will remind you to do so. 1477 1478(It won't hurt to let things accumulate on the stack, except that 1479whenever you give a display-mode-changing command Calc will have to 1480spend a long time reformatting such a large stack.) 1481 1482Since the @kbd{-} key is also an operator (it subtracts the top two 1483stack elements), how does one enter a negative number? Calc uses 1484the @kbd{_} (underscore) key to act like the minus sign in a number. 1485So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key 1486will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine. 1487 1488You can also press @kbd{n}, which means ``change sign.'' It changes 1489the number at the top of the stack (or the number being entered) 1490from positive to negative or vice-versa: @kbd{5 n @key{RET}}. 1491 1492@cindex Duplicating a stack entry 1493If you press @key{RET} when you're not entering a number, the effect 1494is to duplicate the top number on the stack. Consider this calculation: 1495 1496@smallexample 1497@group 14981: 3 2: 3 1: 9 2: 9 1: 81 1499 . 1: 3 . 1: 9 . 1500 . . 1501 1502 3 @key{RET} @key{RET} * @key{RET} * 1503@end group 1504@end smallexample 1505 1506@noindent 1507(Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^}, 1508to raise 3 to the fourth power.) 1509 1510The space-bar key (denoted @key{SPC} here) performs the same function 1511as @key{RET}; you could replace all three occurrences of @key{RET} in 1512the above example with @key{SPC} and the effect would be the same. 1513 1514@cindex Exchanging stack entries 1515Another stack manipulation key is @key{TAB}. This exchanges the top 1516two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +} 1517to get 5, and then you realize what you really wanted to compute 1518was @expr{20 / (2+3)}. 1519 1520@smallexample 1521@group 15221: 5 2: 5 2: 20 1: 4 1523 . 1: 20 1: 5 . 1524 . . 1525 1526 2 @key{RET} 3 + 20 @key{TAB} / 1527@end group 1528@end smallexample 1529 1530@noindent 1531Planning ahead, the calculation would have gone like this: 1532 1533@smallexample 1534@group 15351: 20 2: 20 3: 20 2: 20 1: 4 1536 . 1: 2 2: 2 1: 5 . 1537 . 1: 3 . 1538 . 1539 1540 20 @key{RET} 2 @key{RET} 3 + / 1541@end group 1542@end smallexample 1543 1544A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type 1545@key{TAB}). It rotates the top three elements of the stack upward, 1546bringing the object in level 3 to the top. 1547 1548@smallexample 1549@group 15501: 10 2: 10 3: 10 3: 20 3: 30 1551 . 1: 20 2: 20 2: 30 2: 10 1552 . 1: 30 1: 10 1: 20 1553 . . . 1554 1555 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB} 1556@end group 1557@end smallexample 1558 1559(@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are 1560on the stack. Figure out how to add one to the number in level 2 1561without affecting the rest of the stack. Also figure out how to add 1562one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{}) 1563 1564Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two 1565arguments from the stack and push a result. Operations like @kbd{n} and 1566@kbd{Q} (square root) pop a single number and push the result. You can 1567think of them as simply operating on the top element of the stack. 1568 1569@smallexample 1570@group 15711: 3 1: 9 2: 9 1: 25 1: 5 1572 . . 1: 16 . . 1573 . 1574 1575 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q 1576@end group 1577@end smallexample 1578 1579@noindent 1580(Note that capital @kbd{Q} means to hold down the Shift key while 1581typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.) 1582 1583@cindex Pythagorean Theorem 1584Here we've used the Pythagorean Theorem to determine the hypotenuse of a 1585right triangle. Calc actually has a built-in command for that called 1586@kbd{f h}, but let's suppose we can't remember the necessary keystrokes. 1587We can still enter it by its full name using @kbd{M-x} notation: 1588 1589@smallexample 1590@group 15911: 3 2: 3 1: 5 1592 . 1: 4 . 1593 . 1594 1595 3 @key{RET} 4 @key{RET} M-x calc-hypot 1596@end group 1597@end smallexample 1598 1599All Calculator commands begin with the word @samp{calc-}. Since it 1600gets tiring to type this, Calc provides an @kbd{x} key which is just 1601like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-} 1602prefix for you: 1603 1604@smallexample 1605@group 16061: 3 2: 3 1: 5 1607 . 1: 4 . 1608 . 1609 1610 3 @key{RET} 4 @key{RET} x hypot 1611@end group 1612@end smallexample 1613 1614What happens if you take the square root of a negative number? 1615 1616@smallexample 1617@group 16181: 4 1: -4 1: (0, 2) 1619 . . . 1620 1621 4 @key{RET} n Q 1622@end group 1623@end smallexample 1624 1625@noindent 1626The notation @expr{(a, b)} represents a complex number. 1627Complex numbers are more traditionally written @expr{a + b i}; 1628Calc can display in this format, too, but for now we'll stick to the 1629@expr{(a, b)} notation. 1630 1631If you don't know how complex numbers work, you can safely ignore this 1632feature. Complex numbers only arise from operations that would be 1633errors in a calculator that didn't have complex numbers. (For example, 1634taking the square root or logarithm of a negative number produces a 1635complex result.) 1636 1637Complex numbers are entered in the notation shown. The @kbd{(} and 1638@kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.'' 1639 1640@smallexample 1641@group 16421: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3) 1643 . 1: 2 . 3 . 1644 . . 1645 1646 ( 2 , 3 ) 1647@end group 1648@end smallexample 1649 1650You can perform calculations while entering parts of incomplete objects. 1651However, an incomplete object cannot actually participate in a calculation: 1652 1653@smallexample 1654@group 16551: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ... 1656 . 1: 2 2: 2 5 5 1657 . 1: 3 . . 1658 . 1659 (error) 1660 ( 2 @key{RET} 3 + + 1661@end group 1662@end smallexample 1663 1664@noindent 1665Adding 5 to an incomplete object makes no sense, so the last command 1666produces an error message and leaves the stack the same. 1667 1668Incomplete objects can't participate in arithmetic, but they can be 1669moved around by the regular stack commands. 1670 1671@smallexample 1672@group 16732: 2 3: 2 3: 3 1: ( ... 1: (2, 3) 16741: 3 2: 3 2: ( ... 2 . 1675 . 1: ( ... 1: 2 3 1676 . . . 1677 16782 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} ) 1679@end group 1680@end smallexample 1681 1682@noindent 1683Note that the @kbd{,} (comma) key did not have to be used here. 1684When you press @kbd{)} all the stack entries between the incomplete 1685entry and the top are collected, so there's never really a reason 1686to use the comma. It's up to you. 1687 1688(@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)}, 1689your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened? 1690(Joe thought of a clever way to correct his mistake in only two 1691keystrokes, but it didn't quite work. Try it to find out why.) 1692@xref{RPN Answer 4, 4}. (@bullet{}) 1693 1694Vectors are entered the same way as complex numbers, but with square 1695brackets in place of parentheses. We'll meet vectors again later in 1696the tutorial. 1697 1698Any Emacs command can be given a @dfn{numeric prefix argument} by 1699typing a series of @key{META}-digits beforehand. If @key{META} is 1700awkward for you, you can instead type @kbd{C-u} followed by the 1701necessary digits. Numeric prefix arguments can be negative, as in 1702@kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric 1703prefix arguments in a variety of ways. For example, a numeric prefix 1704on the @kbd{+} operator adds any number of stack entries at once: 1705 1706@smallexample 1707@group 17081: 10 2: 10 3: 10 3: 10 1: 60 1709 . 1: 20 2: 20 2: 20 . 1710 . 1: 30 1: 30 1711 . . 1712 1713 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 + 1714@end group 1715@end smallexample 1716 1717For stack manipulation commands like @key{RET}, a positive numeric 1718prefix argument operates on the top @var{n} stack entries at once. A 1719negative argument operates on the entry in level @var{n} only. An 1720argument of zero operates on the entire stack. In this example, we copy 1721the second-to-top element of the stack: 1722 1723@smallexample 1724@group 17251: 10 2: 10 3: 10 3: 10 4: 10 1726 . 1: 20 2: 20 2: 20 3: 20 1727 . 1: 30 1: 30 2: 30 1728 . . 1: 20 1729 . 1730 1731 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET} 1732@end group 1733@end smallexample 1734 1735@cindex Clearing the stack 1736@cindex Emptying the stack 1737Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack. 1738(The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the 1739entire stack.) 1740 1741@node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial 1742@subsection Algebraic-Style Calculations 1743 1744@noindent 1745If you are not used to RPN notation, you may prefer to operate the 1746Calculator in Algebraic mode, which is closer to the way 1747non-RPN calculators work. In Algebraic mode, you enter formulas 1748in traditional @expr{2+3} notation. 1749 1750@strong{Notice:} Calc gives @samp{/} lower precedence than @samp{*}, so 1751that @samp{a/b*c} is interpreted as @samp{a/(b*c)}; this is not 1752standard across all computer languages. See below for details. 1753 1754You don't really need any special ``mode'' to enter algebraic formulas. 1755You can enter a formula at any time by pressing the apostrophe (@kbd{'}) 1756key. Answer the prompt with the desired formula, then press @key{RET}. 1757The formula is evaluated and the result is pushed onto the RPN stack. 1758If you don't want to think in RPN at all, you can enter your whole 1759computation as a formula, read the result from the stack, then press 1760@key{DEL} to delete it from the stack. 1761 1762Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}. 1763The result should be the number 9. 1764 1765Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*}, 1766@samp{/}, and @samp{^}. You can use parentheses to make the order 1767of evaluation clear. In the absence of parentheses, @samp{^} is 1768evaluated first, then @samp{*}, then @samp{/}, then finally 1769@samp{+} and @samp{-}. For example, the expression 1770 1771@example 17722 + 3*4*5 / 6*7^8 - 9 1773@end example 1774 1775@noindent 1776is equivalent to 1777 1778@example 17792 + ((3*4*5) / (6*(7^8))) - 9 1780@end example 1781 1782@noindent 1783or, in large mathematical notation, 1784 1785@ifnottex 1786@example 1787@group 1788 3 * 4 * 5 17892 + --------- - 9 1790 8 1791 6 * 7 1792@end group 1793@end example 1794@end ifnottex 1795@tex 1796\beforedisplay 1797$$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$ 1798\afterdisplay 1799@end tex 1800 1801@noindent 1802The result of this expression will be the number @mathit{-6.99999826533}. 1803 1804Calc's order of evaluation is the same as for most computer languages, 1805except that @samp{*} binds more strongly than @samp{/}, as the above 1806example shows. As in normal mathematical notation, the @samp{*} symbol 1807can often be omitted: @samp{2 a} is the same as @samp{2*a}. 1808 1809Operators at the same level are evaluated from left to right, except 1810that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is 1811equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent 1812to @samp{2^(3^4)} (a very large integer; try it!). 1813 1814If you tire of typing the apostrophe all the time, there is 1815Algebraic mode, where Calc automatically senses 1816when you are about to type an algebraic expression. To enter this 1817mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator 1818should appear in the Calc window's mode line.) 1819 1820Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}. 1821 1822In Algebraic mode, when you press any key that would normally begin 1823entering a number (such as a digit, a decimal point, or the @kbd{_} 1824key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins 1825an algebraic entry. 1826 1827Functions which do not have operator symbols like @samp{+} and @samp{*} 1828must be entered in formulas using function-call notation. For example, 1829the function name corresponding to the square-root key @kbd{Q} is 1830@code{sqrt}. To compute a square root in a formula, you would use 1831the notation @samp{sqrt(@var{x})}. 1832 1833Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should 1834be @expr{0.16227766017}. 1835 1836Note that if the formula begins with a function name, you need to use 1837the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin} 1838out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite 1839command, and the @kbd{csin} will be taken as the name of the rewrite 1840rule to use! 1841 1842Some people prefer to enter complex numbers and vectors in algebraic 1843form because they find RPN entry with incomplete objects to be too 1844distracting, even though they otherwise use Calc as an RPN calculator. 1845 1846Still in Algebraic mode, type: 1847 1848@smallexample 1849@group 18501: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1) 1851 . 1: (1, -2) . 1: 1 . 1852 . . 1853 1854 (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} + 1855@end group 1856@end smallexample 1857 1858Algebraic mode allows us to enter complex numbers without pressing 1859an apostrophe first, but it also means we need to press @key{RET} 1860after every entry, even for a simple number like @expr{1}. 1861 1862(You can type @kbd{C-u m a} to enable a special Incomplete Algebraic 1863mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even 1864though regular numeric keys still use RPN numeric entry. There is also 1865Total Algebraic mode, started by typing @kbd{m t}, in which all 1866normal keys begin algebraic entry. You must then use the @key{META} key 1867to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic 1868mode, @kbd{M-q} to quit, etc.) 1869 1870If you're still in Algebraic mode, press @kbd{m a} again to turn it off. 1871 1872Actual non-RPN calculators use a mixture of algebraic and RPN styles. 1873In general, operators of two numbers (like @kbd{+} and @kbd{*}) 1874use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q}) 1875use RPN form. Also, a non-RPN calculator allows you to see the 1876intermediate results of a calculation as you go along. You can 1877accomplish this in Calc by performing your calculation as a series 1878of algebraic entries, using the @kbd{$} sign to tie them together. 1879In an algebraic formula, @kbd{$} represents the number on the top 1880of the stack. Here, we perform the calculation 1881@texline @math{\sqrt{2\times4+1}}, 1882@infoline @expr{sqrt(2*4+1)}, 1883which on a traditional calculator would be done by pressing 1884@kbd{2 * 4 + 1 =} and then the square-root key. 1885 1886@smallexample 1887@group 18881: 8 1: 9 1: 3 1889 . . . 1890 1891 ' 2*4 @key{RET} $+1 @key{RET} Q 1892@end group 1893@end smallexample 1894 1895@noindent 1896Notice that we didn't need to press an apostrophe for the @kbd{$+1}, 1897because the dollar sign always begins an algebraic entry. 1898 1899(@bullet{}) @strong{Exercise 1.} How could you get the same effect as 1900pressing @kbd{Q} but using an algebraic entry instead? How about 1901if the @kbd{Q} key on your keyboard were broken? 1902@xref{Algebraic Answer 1, 1}. (@bullet{}) 1903 1904The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack 1905entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}. 1906 1907Algebraic formulas can include @dfn{variables}. To store in a 1908variable, press @kbd{s s}, then type the variable name, then press 1909@key{RET}. (There are actually two flavors of store command: 1910@kbd{s s} stores a number in a variable but also leaves the number 1911on the stack, while @w{@kbd{s t}} removes a number from the stack and 1912stores it in the variable.) A variable name should consist of one 1913or more letters or digits, beginning with a letter. 1914 1915@smallexample 1916@group 19171: 17 . 1: a + a^2 1: 306 1918 . . . 1919 1920 17 s t a @key{RET} ' a+a^2 @key{RET} = 1921@end group 1922@end smallexample 1923 1924@noindent 1925The @kbd{=} key @dfn{evaluates} a formula by replacing all its 1926variables by the values that were stored in them. 1927 1928For RPN calculations, you can recall a variable's value on the 1929stack either by entering its name as a formula and pressing @kbd{=}, 1930or by using the @kbd{s r} command. 1931 1932@smallexample 1933@group 19341: 17 2: 17 3: 17 2: 17 1: 306 1935 . 1: 17 2: 17 1: 289 . 1936 . 1: 2 . 1937 . 1938 1939 s r a @key{RET} ' a @key{RET} = 2 ^ + 1940@end group 1941@end smallexample 1942 1943If you press a single digit for a variable name (as in @kbd{s t 3}, you 1944get one of ten @dfn{quick variables} @code{q0} through @code{q9}. 1945They are ``quick'' simply because you don't have to type the letter 1946@code{q} or the @key{RET} after their names. In fact, you can type 1947simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for 1948@kbd{t 3} and @w{@kbd{r 3}}. 1949 1950Any variables in an algebraic formula for which you have not stored 1951values are left alone, even when you evaluate the formula. 1952 1953@smallexample 1954@group 19551: 2 a + 2 b 1: 2 b + 34 1956 . . 1957 1958 ' 2a+2b @key{RET} = 1959@end group 1960@end smallexample 1961 1962Calls to function names which are undefined in Calc are also left 1963alone, as are calls for which the value is undefined. 1964 1965@smallexample 1966@group 19671: log10(0) + log10(x) + log10(5, 6) + foo(3) + 2 1968 . 1969 1970 ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET} 1971@end group 1972@end smallexample 1973 1974@noindent 1975In this example, the first call to @code{log10} works, but the other 1976calls are not evaluated. In the second call, the logarithm is 1977undefined for that value of the argument; in the third, the argument 1978is symbolic, and in the fourth, there are too many arguments. In the 1979fifth case, there is no function called @code{foo}. You will see a 1980``Wrong number of arguments'' message referring to @samp{log10(5,6)}. 1981Press the @kbd{w} (``why'') key to see any other messages that may 1982have arisen from the last calculation. In this case you will get 1983``logarithm of zero,'' then ``number expected: @code{x}''. Calc 1984automatically displays the first message only if the message is 1985sufficiently important; for example, Calc considers ``wrong number 1986of arguments'' and ``logarithm of zero'' to be important enough to 1987report automatically, while a message like ``number expected: @code{x}'' 1988will only show up if you explicitly press the @kbd{w} key. 1989 1990(@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y}, 1991stored 5 in @code{x}, pressed @kbd{=}, and got the expected result, 1992@samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)}, 1993expecting @samp{10 (1+y)}, but it didn't work. Why not? 1994@xref{Algebraic Answer 2, 2}. (@bullet{}) 1995 1996(@bullet{}) @strong{Exercise 3.} What result would you expect 1997@kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}? 1998@xref{Algebraic Answer 3, 3}. (@bullet{}) 1999 2000One interesting way to work with variables is to use the 2001@dfn{evaluates-to} (@samp{=>}) operator. It works like this: 2002Enter a formula algebraically in the usual way, but follow 2003the formula with an @samp{=>} symbol. (There is also an @kbd{s =} 2004command which builds an @samp{=>} formula using the stack.) On 2005the stack, you will see two copies of the formula with an @samp{=>} 2006between them. The lefthand formula is exactly like you typed it; 2007the righthand formula has been evaluated as if by typing @kbd{=}. 2008 2009@smallexample 2010@group 20112: 2 + 3 => 5 2: 2 + 3 => 5 20121: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b 2013 . . 2014 2015' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET} 2016@end group 2017@end smallexample 2018 2019@noindent 2020Notice that the instant we stored a new value in @code{a}, all 2021@samp{=>} operators already on the stack that referred to @expr{a} 2022were updated to use the new value. With @samp{=>}, you can push a 2023set of formulas on the stack, then change the variables experimentally 2024to see the effects on the formulas' values. 2025 2026You can also ``unstore'' a variable when you are through with it: 2027 2028@smallexample 2029@group 20302: 2 + 3 => 5 20311: 2 a + 2 b => 2 a + 2 b 2032 . 2033 2034 s u a @key{RET} 2035@end group 2036@end smallexample 2037 2038We will encounter formulas involving variables and functions again 2039when we discuss the algebra and calculus features of the Calculator. 2040 2041@node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial 2042@subsection Undo and Redo 2043 2044@noindent 2045If you make a mistake, you can usually correct it by pressing shift-@kbd{U}, 2046the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit 2047and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off 2048with a clean slate. Now: 2049 2050@smallexample 2051@group 20521: 2 2: 2 1: 8 2: 2 1: 6 2053 . 1: 3 . 1: 3 . 2054 . . 2055 2056 2 @key{RET} 3 ^ U * 2057@end group 2058@end smallexample 2059 2060You can undo any number of times. Calc keeps a complete record of 2061all you have done since you last opened the Calc window. After the 2062above example, you could type: 2063 2064@smallexample 2065@group 20661: 6 2: 2 1: 2 . . 2067 . 1: 3 . 2068 . 2069 (error) 2070 U U U U 2071@end group 2072@end smallexample 2073 2074You can also type @kbd{D} to ``redo'' a command that you have undone 2075mistakenly. 2076 2077@smallexample 2078@group 2079 . 1: 2 2: 2 1: 6 1: 6 2080 . 1: 3 . . 2081 . 2082 (error) 2083 D D D D 2084@end group 2085@end smallexample 2086 2087@noindent 2088It was not possible to redo past the @expr{6}, since that was placed there 2089by something other than an undo command. 2090 2091@cindex Time travel 2092You can think of undo and redo as a sort of ``time machine.'' Press 2093@kbd{U} to go backward in time, @kbd{D} to go forward. If you go 2094backward and do something (like @kbd{*}) then, as any science fiction 2095reader knows, you have changed your future and you cannot go forward 2096again. Thus, the inability to redo past the @expr{6} even though there 2097was an earlier undo command. 2098 2099You can always recall an earlier result using the Trail. We've ignored 2100the trail so far, but it has been faithfully recording everything we 2101did since we loaded the Calculator. If the Trail is not displayed, 2102press @kbd{t d} now to turn it on. 2103 2104Let's try grabbing an earlier result. The @expr{8} we computed was 2105undone by a @kbd{U} command, and was lost even to Redo when we pressed 2106@kbd{*}, but it's still there in the trail. There should be a little 2107@samp{>} arrow (the @dfn{trail pointer}) resting on the last trail 2108entry. If there isn't, press @kbd{t ]} to reset the trail pointer. 2109Now, press @w{@kbd{t p}} to move the arrow onto the line containing 2110@expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the 2111stack. 2112 2113If you press @kbd{t ]} again, you will see that even our Yank command 2114went into the trail. 2115 2116Let's go further back in time. Earlier in the tutorial we computed 2117a huge integer using the formula @samp{2^3^4}. We don't remember 2118what it was, but the first digits were ``241''. Press @kbd{t r} 2119(which stands for trail-search-reverse), then type @kbd{241}. 2120The trail cursor will jump back to the next previous occurrence of 2121the string ``241'' in the trail. This is just a regular Emacs 2122incremental search; you can now press @kbd{C-s} or @kbd{C-r} to 2123continue the search forwards or backwards as you like. 2124 2125To finish the search, press @key{RET}. This halts the incremental 2126search and leaves the trail pointer at the thing we found. Now we 2127can type @kbd{t y} to yank that number onto the stack. If we hadn't 2128remembered the ``241'', we could simply have searched for @kbd{2^3^4}, 2129then pressed @kbd{@key{RET} t n} to halt and then move to the next item. 2130 2131You may have noticed that all the trail-related commands begin with 2132the letter @kbd{t}. (The store-and-recall commands, on the other hand, 2133all began with @kbd{s}.) Calc has so many commands that there aren't 2134enough keys for all of them, so various commands are grouped into 2135two-letter sequences where the first letter is called the @dfn{prefix} 2136key. If you type a prefix key by accident, you can press @kbd{C-g} 2137to cancel it. (In fact, you can press @kbd{C-g} to cancel almost 2138anything in Emacs.) To get help on a prefix key, press that key 2139followed by @kbd{?}. Some prefixes have several lines of help, 2140so you need to press @kbd{?} repeatedly to see them all. 2141You can also type @kbd{h h} to see all the help at once. 2142 2143Try pressing @kbd{t ?} now. You will see a line of the form, 2144 2145@smallexample 2146trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t- 2147@end smallexample 2148 2149@noindent 2150The word ``trail'' indicates that the @kbd{t} prefix key contains 2151trail-related commands. Each entry on the line shows one command, 2152with a single capital letter showing which letter you press to get 2153that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and 2154@kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?} 2155again to see more @kbd{t}-prefix commands. Notice that the commands 2156are roughly divided (by semicolons) into related groups. 2157 2158When you are in the help display for a prefix key, the prefix is 2159still active. If you press another key, like @kbd{y} for example, 2160it will be interpreted as a @kbd{t y} command. If all you wanted 2161was to look at the help messages, press @kbd{C-g} afterwards to cancel 2162the prefix. 2163 2164One more way to correct an error is by editing the stack entries. 2165The actual Stack buffer is marked read-only and must not be edited 2166directly, but you can press @kbd{`} (grave accent) 2167to edit a stack entry. 2168 2169Try entering @samp{3.141439} now. If this is supposed to represent 2170@cpi{}, it's got several errors. Press @kbd{`} to edit this number. 2171Now use the normal Emacs cursor motion and editing keys to change 2172the second 4 to a 5, and to transpose the 3 and the 9. When you 2173press @key{RET}, the number on the stack will be replaced by your 2174new number. This works for formulas, vectors, and all other types 2175of values you can put on the stack. The @kbd{`} key also works 2176during entry of a number or algebraic formula. 2177 2178@node Modes Tutorial, , Undo Tutorial, Basic Tutorial 2179@subsection Mode-Setting Commands 2180 2181@noindent 2182Calc has many types of @dfn{modes} that affect the way it interprets 2183your commands or the way it displays data. We have already seen one 2184mode, namely Algebraic mode. There are many others, too; we'll 2185try some of the most common ones here. 2186 2187Perhaps the most fundamental mode in Calc is the current @dfn{precision}. 2188Notice the @samp{12} on the Calc window's mode line: 2189 2190@smallexample 2191--%*-Calc: 12 Deg (Calculator)----All------ 2192@end smallexample 2193 2194@noindent 2195Most of the symbols there are Emacs things you don't need to worry 2196about, but the @samp{12} and the @samp{Deg} are mode indicators. 2197The @samp{12} means that calculations should always be carried to 219812 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /}, 2199we get @expr{0.142857142857} with exactly 12 digits, not counting 2200leading and trailing zeros. 2201 2202You can set the precision to anything you like by pressing @kbd{p}, 2203then entering a suitable number. Try pressing @kbd{p 30 @key{RET}}, 2204then doing @kbd{1 @key{RET} 7 /} again: 2205 2206@smallexample 2207@group 22081: 0.142857142857 22092: 0.142857142857142857142857142857 2210 . 2211@end group 2212@end smallexample 2213 2214Although the precision can be set arbitrarily high, Calc always 2215has to have @emph{some} value for the current precision. After 2216all, the true value @expr{1/7} is an infinitely repeating decimal; 2217Calc has to stop somewhere. 2218 2219Of course, calculations are slower the more digits you request. 2220Press @w{@kbd{p 12}} now to set the precision back down to the default. 2221 2222Calculations always use the current precision. For example, even 2223though we have a 30-digit value for @expr{1/7} on the stack, if 2224we use it in a calculation in 12-digit mode it will be rounded 2225down to 12 digits before it is used. Try it; press @key{RET} to 2226duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET} 2227key didn't round the number, because it doesn't do any calculation. 2228But the instant we pressed @kbd{+}, the number was rounded down. 2229 2230@smallexample 2231@group 22321: 0.142857142857 22332: 0.142857142857142857142857142857 22343: 1.14285714286 2235 . 2236@end group 2237@end smallexample 2238 2239@noindent 2240In fact, since we added a digit on the left, we had to lose one 2241digit on the right from even the 12-digit value of @expr{1/7}. 2242 2243How did we get more than 12 digits when we computed @samp{2^3^4}? The 2244answer is that Calc makes a distinction between @dfn{integers} and 2245@dfn{floating-point} numbers, or @dfn{floats}. An integer is a number 2246that does not contain a decimal point. There is no such thing as an 2247``infinitely repeating fraction integer,'' so Calc doesn't have to limit 2248itself. If you asked for @samp{2^10000} (don't try this!), you would 2249have to wait a long time but you would eventually get an exact answer. 2250If you ask for @samp{2.^10000}, you will quickly get an answer which is 2251correct only to 12 places. The decimal point tells Calc that it should 2252use floating-point arithmetic to get the answer, not exact integer 2253arithmetic. 2254 2255You can use the @kbd{F} (@code{calc-floor}) command to convert a 2256floating-point value to an integer, and @kbd{c f} (@code{calc-float}) 2257to convert an integer to floating-point form. 2258 2259Let's try entering that last calculation: 2260 2261@smallexample 2262@group 22631: 2. 2: 2. 1: 1.99506311689e3010 2264 . 1: 10000 . 2265 . 2266 2267 2.0 @key{RET} 10000 @key{RET} ^ 2268@end group 2269@end smallexample 2270 2271@noindent 2272@cindex Scientific notation, entry of 2273Notice the letter @samp{e} in there. It represents ``times ten to the 2274power of,'' and is used by Calc automatically whenever writing the 2275number out fully would introduce more extra zeros than you probably 2276want to see. You can enter numbers in this notation, too. 2277 2278@smallexample 2279@group 22801: 2. 2: 2. 1: 1.99506311678e3010 2281 . 1: 10000. . 2282 . 2283 2284 2.0 @key{RET} 1e4 @key{RET} ^ 2285@end group 2286@end smallexample 2287 2288@cindex Round-off errors 2289@noindent 2290Hey, the answer is different! Look closely at the middle columns 2291of the two examples. In the first, the stack contained the 2292exact integer @expr{10000}, but in the second it contained 2293a floating-point value with a decimal point. When you raise a 2294number to an integer power, Calc uses repeated squaring and 2295multiplication to get the answer. When you use a floating-point 2296power, Calc uses logarithms and exponentials. As you can see, 2297a slight error crept in during one of these methods. Which 2298one should we trust? Let's raise the precision a bit and find 2299out: 2300 2301@smallexample 2302@group 2303 . 1: 2. 2: 2. 1: 1.995063116880828e3010 2304 . 1: 10000. . 2305 . 2306 2307 p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET} 2308@end group 2309@end smallexample 2310 2311@noindent 2312@cindex Guard digits 2313Presumably, it doesn't matter whether we do this higher-precision 2314calculation using an integer or floating-point power, since we 2315have added enough ``guard digits'' to trust the first 12 digits 2316no matter what. And the verdict is@dots{} Integer powers were more 2317accurate; in fact, the result was only off by one unit in the 2318last place. 2319 2320@cindex Guard digits 2321Calc does many of its internal calculations to a slightly higher 2322precision, but it doesn't always bump the precision up enough. 2323In each case, Calc added about two digits of precision during 2324its calculation and then rounded back down to 12 digits 2325afterward. In one case, it was enough; in the other, it 2326wasn't. If you really need @var{x} digits of precision, it 2327never hurts to do the calculation with a few extra guard digits. 2328 2329What if we want guard digits but don't want to look at them? 2330We can set the @dfn{float format}. Calc supports four major 2331formats for floating-point numbers, called @dfn{normal}, 2332@dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering 2333notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f}, 2334@kbd{d s}, and @kbd{d e}, respectively. In each case, you can 2335supply a numeric prefix argument which says how many digits 2336should be displayed. As an example, let's put a few numbers 2337onto the stack and try some different display modes. First, 2338use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four 2339numbers shown here: 2340 2341@smallexample 2342@group 23434: 12345 4: 12345 4: 12345 4: 12345 4: 12345 23443: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000 23452: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450 23461: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345 2347 . . . . . 2348 2349 d n M-3 d n d s M-3 d s M-3 d f 2350@end group 2351@end smallexample 2352 2353@noindent 2354Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down 2355to three significant digits, but then when we typed @kbd{d s} all 2356five significant figures reappeared. The float format does not 2357affect how numbers are stored, it only affects how they are 2358displayed. Only the current precision governs the actual rounding 2359of numbers in the Calculator's memory. 2360 2361Engineering notation, not shown here, is like scientific notation 2362except the exponent (the power-of-ten part) is always adjusted to be 2363a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result 2364there will be one, two, or three digits before the decimal point. 2365 2366Whenever you change a display-related mode, Calc redraws everything 2367in the stack. This may be slow if there are many things on the stack, 2368so Calc allows you to type shift-@kbd{H} before any mode command to 2369prevent it from updating the stack. Anything Calc displays after the 2370mode-changing command will appear in the new format. 2371 2372@smallexample 2373@group 23744: 12345 4: 12345 4: 12345 4: 12345 4: 12345 23753: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345. 23762: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45 23771: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345 2378 . . . . . 2379 2380 H d s @key{DEL} U @key{TAB} d @key{SPC} d n 2381@end group 2382@end smallexample 2383 2384@noindent 2385Here the @kbd{H d s} command changes to scientific notation but without 2386updating the screen. Deleting the top stack entry and undoing it back 2387causes it to show up in the new format; swapping the top two stack 2388entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the 2389whole stack. The @kbd{d n} command changes back to the normal float 2390format; since it doesn't have an @kbd{H} prefix, it also updates all 2391the stack entries to be in @kbd{d n} format. 2392 2393Notice that the integer @expr{12345} was not affected by any 2394of the float formats. Integers are integers, and are always 2395displayed exactly. 2396 2397@cindex Large numbers, readability 2398Large integers have their own problems. Let's look back at 2399the result of @kbd{2^3^4}. 2400 2401@example 24022417851639229258349412352 2403@end example 2404 2405@noindent 2406Quick---how many digits does this have? Try typing @kbd{d g}: 2407 2408@example 24092,417,851,639,229,258,349,412,352 2410@end example 2411 2412@noindent 2413Now how many digits does this have? It's much easier to tell! 2414We can actually group digits into clumps of any size. Some 2415people prefer @kbd{M-5 d g}: 2416 2417@example 241824178,51639,22925,83494,12352 2419@end example 2420 2421Let's see what happens to floating-point numbers when they are grouped. 2422First, type @kbd{p 25 @key{RET}} to make sure we have enough precision 2423to get ourselves into trouble. Now, type @kbd{1e13 /}: 2424 2425@example 242624,17851,63922.9258349412352 2427@end example 2428 2429@noindent 2430The integer part is grouped but the fractional part isn't. Now try 2431@kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five): 2432 2433@example 243424,17851,63922.92583,49412,352 2435@end example 2436 2437If you find it hard to tell the decimal point from the commas, try 2438changing the grouping character to a space with @kbd{d , @key{SPC}}: 2439 2440@example 244124 17851 63922.92583 49412 352 2442@end example 2443 2444Type @kbd{d , ,} to restore the normal grouping character, then 2445@kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to 2446restore the default precision. 2447 2448Press @kbd{U} enough times to get the original big integer back. 2449(Notice that @kbd{U} does not undo each mode-setting command; if 2450you want to undo a mode-setting command, you have to do it yourself.) 2451Now, type @kbd{d r 16 @key{RET}}: 2452 2453@example 245416#200000000000000000000 2455@end example 2456 2457@noindent 2458The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form. 2459Suddenly it looks pretty simple; this should be no surprise, since we 2460got this number by computing a power of two, and 16 is a power of 2. 2461In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary 2462form: 2463 2464@example 24652#1000000000000000000000000000000000000000000000000000000 @dots{} 2466@end example 2467 2468@noindent 2469We don't have enough space here to show all the zeros! They won't 2470fit on a typical screen, either, so you will have to use horizontal 2471scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the 2472stack window left and right by half its width. Another way to view 2473something large is to press @kbd{`} (grave accent) to edit the top of 2474stack in a separate window. (Press @kbd{C-c C-c} when you are done.) 2475 2476You can enter non-decimal numbers using the @kbd{#} symbol, too. 2477Let's see what the hexadecimal number @samp{5FE} looks like in 2478binary. Type @kbd{16#5FE} (the letters can be typed in upper or 2479lower case; they will always appear in upper case). It will also 2480help to turn grouping on with @kbd{d g}: 2481 2482@example 24832#101,1111,1110 2484@end example 2485 2486Notice that @kbd{d g} groups by fours by default if the display radix 2487is binary or hexadecimal, but by threes if it is decimal, octal, or any 2488other radix. 2489 2490Now let's see that number in decimal; type @kbd{d r 10}: 2491 2492@example 24931,534 2494@end example 2495 2496Numbers are not @emph{stored} with any particular radix attached. They're 2497just numbers; they can be entered in any radix, and are always displayed 2498in whatever radix you've chosen with @kbd{d r}. The current radix applies 2499to integers, fractions, and floats. 2500 2501@cindex Roundoff errors, in non-decimal numbers 2502(@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third 2503as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got 2504@samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied 2505that by three, he got @samp{3#0.222222...} instead of the expected 2506@samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief, 2507saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got 2508@samp{3#0.10000001} (some zeros omitted). What's going on here? 2509@xref{Modes Answer 1, 1}. (@bullet{}) 2510 2511@cindex Scientific notation, in non-decimal numbers 2512(@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal 2513modes in the natural way (the exponent is a power of the radix instead of 2514a power of ten, although the exponent itself is always written in decimal). 2515Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number 2516@samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}. 2517What is wrong with this picture? What could we write instead that would 2518work better? @xref{Modes Answer 2, 2}. (@bullet{}) 2519 2520The @kbd{m} prefix key has another set of modes, relating to the way 2521Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix 2522modes generally affect the way things look, @kbd{m}-prefix modes affect 2523the way they are actually computed. 2524 2525The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice 2526the @samp{Deg} indicator in the mode line. This means that if you use 2527a command that interprets a number as an angle, it will assume the 2528angle is measured in degrees. For example, 2529 2530@smallexample 2531@group 25321: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5 2533 . . . . 2534 2535 45 S 2 ^ c 1 2536@end group 2537@end smallexample 2538 2539@noindent 2540The shift-@kbd{S} command computes the sine of an angle. The sine 2541of 45 degrees is 2542@texline @math{\sqrt{2}/2}; 2543@infoline @expr{sqrt(2)/2}; 2544squaring this yields @expr{2/4 = 0.5}. However, there has been a slight 2545roundoff error because the representation of 2546@texline @math{\sqrt{2}/2} 2547@infoline @expr{sqrt(2)/2} 2548wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers 2549in this case; it temporarily reduces the precision by one digit while it 2550re-rounds the number on the top of the stack. 2551 2552@cindex Roundoff errors, examples 2553(@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine 2554of 45 degrees as shown above, then, hoping to avoid an inexact 2555result, he increased the precision to 16 digits before squaring. 2556What happened? @xref{Modes Answer 3, 3}. (@bullet{}) 2557 2558To do this calculation in radians, we would type @kbd{m r} first. 2559(The indicator changes to @samp{Rad}.) 45 degrees corresponds to 2560@cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once 2561again, this is a shifted capital @kbd{P}. Remember, unshifted 2562@kbd{p} sets the precision.) 2563 2564@smallexample 2565@group 25661: 3.14159265359 1: 0.785398163398 1: 0.707106781187 2567 . . . 2568 2569 P 4 / m r S 2570@end group 2571@end smallexample 2572 2573Likewise, inverse trigonometric functions generate results in 2574either radians or degrees, depending on the current angular mode. 2575 2576@smallexample 2577@group 25781: 0.707106781187 1: 0.785398163398 1: 45. 2579 . . . 2580 2581 .5 Q m r I S m d U I S 2582@end group 2583@end smallexample 2584 2585@noindent 2586Here we compute the Inverse Sine of 2587@texline @math{\sqrt{0.5}}, 2588@infoline @expr{sqrt(0.5)}, 2589first in radians, then in degrees. 2590 2591Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees 2592and vice-versa. 2593 2594@smallexample 2595@group 25961: 45 1: 0.785398163397 1: 45. 2597 . . . 2598 2599 45 c r c d 2600@end group 2601@end smallexample 2602 2603Another interesting mode is @dfn{Fraction mode}. Normally, 2604dividing two integers produces a floating-point result if the 2605quotient can't be expressed as an exact integer. Fraction mode 2606causes integer division to produce a fraction, i.e., a rational 2607number, instead. 2608 2609@smallexample 2610@group 26112: 12 1: 1.33333333333 1: 4:3 26121: 9 . . 2613 . 2614 2615 12 @key{RET} 9 / m f U / m f 2616@end group 2617@end smallexample 2618 2619@noindent 2620In the first case, we get an approximate floating-point result. 2621In the second case, we get an exact fractional result (four-thirds). 2622 2623You can enter a fraction at any time using @kbd{:} notation. 2624(Calc uses @kbd{:} instead of @kbd{/} as the fraction separator 2625because @kbd{/} is already used to divide the top two stack 2626elements.) Calculations involving fractions will always 2627produce exact fractional results; Fraction mode only says 2628what to do when dividing two integers. 2629 2630@cindex Fractions vs. floats 2631@cindex Floats vs. fractions 2632(@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact, 2633why would you ever use floating-point numbers instead? 2634@xref{Modes Answer 4, 4}. (@bullet{}) 2635 2636Typing @kbd{m f} doesn't change any existing values in the stack. 2637In the above example, we had to Undo the division and do it over 2638again when we changed to Fraction mode. But if you use the 2639evaluates-to operator you can get commands like @kbd{m f} to 2640recompute for you. 2641 2642@smallexample 2643@group 26441: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3 2645 . . . 2646 2647 ' 12/9 => @key{RET} p 4 @key{RET} m f 2648@end group 2649@end smallexample 2650 2651@noindent 2652In this example, the righthand side of the @samp{=>} operator 2653on the stack is recomputed when we change the precision, then 2654again when we change to Fraction mode. All @samp{=>} expressions 2655on the stack are recomputed every time you change any mode that 2656might affect their values. 2657 2658@node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial 2659@section Arithmetic Tutorial 2660 2661@noindent 2662In this section, we explore the arithmetic and scientific functions 2663available in the Calculator. 2664 2665The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, 2666and @kbd{^}. Each normally takes two numbers from the top of the stack 2667and pushes back a result. The @kbd{n} and @kbd{&} keys perform 2668change-sign and reciprocal operations, respectively. 2669 2670@smallexample 2671@group 26721: 5 1: 0.2 1: 5. 1: -5. 1: 5. 2673 . . . . . 2674 2675 5 & & n n 2676@end group 2677@end smallexample 2678 2679@cindex Binary operators 2680You can apply a ``binary operator'' like @kbd{+} across any number of 2681stack entries by giving it a numeric prefix. You can also apply it 2682pairwise to several stack elements along with the top one if you use 2683a negative prefix. 2684 2685@smallexample 2686@group 26873: 2 1: 9 3: 2 4: 2 3: 12 26882: 3 . 2: 3 3: 3 2: 13 26891: 4 1: 4 2: 4 1: 14 2690 . . 1: 10 . 2691 . 2692 26932 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 + 2694@end group 2695@end smallexample 2696 2697@cindex Unary operators 2698You can apply a ``unary operator'' like @kbd{&} to the top @var{n} 2699stack entries with a numeric prefix, too. 2700 2701@smallexample 2702@group 27033: 2 3: 0.5 3: 0.5 27042: 3 2: 0.333333333333 2: 3. 27051: 4 1: 0.25 1: 4. 2706 . . . 2707 27082 @key{RET} 3 @key{RET} 4 M-3 & M-2 & 2709@end group 2710@end smallexample 2711 2712Notice that the results here are left in floating-point form. 2713We can convert them back to integers by pressing @kbd{F}, the 2714``floor'' function. This function rounds down to the next lower 2715integer. There is also @kbd{R}, which rounds to the nearest 2716integer. 2717 2718@smallexample 2719@group 27207: 2. 7: 2 7: 2 27216: 2.4 6: 2 6: 2 27225: 2.5 5: 2 5: 3 27234: 2.6 4: 2 4: 3 27243: -2. 3: -2 3: -2 27252: -2.4 2: -3 2: -2 27261: -2.6 1: -3 1: -3 2727 . . . 2728 2729 M-7 F U M-7 R 2730@end group 2731@end smallexample 2732 2733Since dividing-and-flooring (i.e., ``integer quotient'') is such a 2734common operation, Calc provides a special command for that purpose, the 2735backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which 2736computes the remainder that would arise from a @kbd{\} operation, i.e., 2737the ``modulo'' of two numbers. For example, 2738 2739@smallexample 2740@group 27412: 1234 1: 12 2: 1234 1: 34 27421: 100 . 1: 100 . 2743 . . 2744 27451234 @key{RET} 100 \ U % 2746@end group 2747@end smallexample 2748 2749These commands actually work for any real numbers, not just integers. 2750 2751@smallexample 2752@group 27532: 3.1415 1: 3 2: 3.1415 1: 0.1415 27541: 1 . 1: 1 . 2755 . . 2756 27573.1415 @key{RET} 1 \ U % 2758@end group 2759@end smallexample 2760 2761(@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a 2762frill, since you could always do the same thing with @kbd{/ F}. Think 2763of a situation where this is not true---@kbd{/ F} would be inadequate. 2764Now think of a way you could get around the problem if Calc didn't 2765provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{}) 2766 2767We've already seen the @kbd{Q} (square root) and @kbd{S} (sine) 2768commands. Other commands along those lines are @kbd{C} (cosine), 2769@kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural 2770logarithm). These can be modified by the @kbd{I} (inverse) and 2771@kbd{H} (hyperbolic) prefix keys. 2772 2773Let's compute the sine and cosine of an angle, and verify the 2774identity 2775@texline @math{\sin^2x + \cos^2x = 1}. 2776@infoline @expr{sin(x)^2 + cos(x)^2 = 1}. 2777We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}. 2778With the angular mode set to degrees (type @w{@kbd{m d}}), do: 2779 2780@smallexample 2781@group 27822: -64 2: -64 2: -0.89879 2: -0.89879 1: 1. 27831: -64 1: -0.89879 1: -64 1: 0.43837 . 2784 . . . . 2785 2786 64 n @key{RET} @key{RET} S @key{TAB} C f h 2787@end group 2788@end smallexample 2789 2790@noindent 2791(For brevity, we're showing only five digits of the results here. 2792You can of course do these calculations to any precision you like.) 2793 2794Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum 2795of squares, command. 2796 2797Another identity is 2798@texline @math{\displaystyle\tan x = {\sin x \over \cos x}}. 2799@infoline @expr{tan(x) = sin(x) / cos(x)}. 2800@smallexample 2801@group 2802 28032: -0.89879 1: -2.0503 1: -64. 28041: 0.43837 . . 2805 . 2806 2807 U / I T 2808@end group 2809@end smallexample 2810 2811A physical interpretation of this calculation is that if you move 2812@expr{0.89879} units downward and @expr{0.43837} units to the right, 2813your direction of motion is @mathit{-64} degrees from horizontal. Suppose 2814we move in the opposite direction, up and to the left: 2815 2816@smallexample 2817@group 28182: -0.89879 2: 0.89879 1: -2.0503 1: -64. 28191: 0.43837 1: -0.43837 . . 2820 . . 2821 2822 U U M-2 n / I T 2823@end group 2824@end smallexample 2825 2826@noindent 2827How can the angle be the same? The answer is that the @kbd{/} operation 2828loses information about the signs of its inputs. Because the quotient 2829is negative, we know exactly one of the inputs was negative, but we 2830can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which 2831computes the inverse tangent of the quotient of a pair of numbers. 2832Since you feed it the two original numbers, it has enough information 2833to give you a full 360-degree answer. 2834 2835@smallexample 2836@group 28372: 0.89879 1: 116. 3: 116. 2: 116. 1: 180. 28381: -0.43837 . 2: -0.89879 1: -64. . 2839 . 1: 0.43837 . 2840 . 2841 2842 U U f T M-@key{RET} M-2 n f T - 2843@end group 2844@end smallexample 2845 2846@noindent 2847The resulting angles differ by 180 degrees; in other words, they 2848point in opposite directions, just as we would expect. 2849 2850The @key{META}-@key{RET} we used in the third step is the 2851``last-arguments'' command. It is sort of like Undo, except that it 2852restores the arguments of the last command to the stack without removing 2853the command's result. It is useful in situations like this one, 2854where we need to do several operations on the same inputs. We could 2855have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate 2856the top two stack elements right after the @kbd{U U}, then a pair of 2857@kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates. 2858 2859A similar identity is supposed to hold for hyperbolic sines and cosines, 2860except that it is the @emph{difference} 2861@texline @math{\cosh^2x - \sinh^2x} 2862@infoline @expr{cosh(x)^2 - sinh(x)^2} 2863that always equals one. Let's try to verify this identity. 2864 2865@smallexample 2866@group 28672: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54 28681: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54 2869 . . . . . 2870 2871 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^ 2872@end group 2873@end smallexample 2874 2875@noindent 2876@cindex Roundoff errors, examples 2877Something's obviously wrong, because when we subtract these numbers 2878the answer will clearly be zero! But if you think about it, if these 2879numbers @emph{did} differ by one, it would be in the 55th decimal 2880place. The difference we seek has been lost entirely to roundoff 2881error. 2882 2883We could verify this hypothesis by doing the actual calculation with, 2884say, 60 decimal places of precision. This will be slow, but not 2885enormously so. Try it if you wish; sure enough, the answer is 28860.99999, reasonably close to 1. 2887 2888Of course, a more reasonable way to verify the identity is to use 2889a more reasonable value for @expr{x}! 2890 2891@cindex Common logarithm 2892Some Calculator commands use the Hyperbolic prefix for other purposes. 2893The logarithm and exponential functions, for example, work to the base 2894@expr{e} normally but use base-10 instead if you use the Hyperbolic 2895prefix. 2896 2897@smallexample 2898@group 28991: 1000 1: 6.9077 1: 1000 1: 3 2900 . . . . 2901 2902 1000 L U H L 2903@end group 2904@end smallexample 2905 2906@noindent 2907First, we mistakenly compute a natural logarithm. Then we undo 2908and compute a common logarithm instead. 2909 2910The @kbd{B} key computes a general base-@var{b} logarithm for any 2911value of @var{b}. 2912 2913@smallexample 2914@group 29152: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077 29161: 10 . . 1: 2.71828 . 2917 . . 2918 2919 1000 @key{RET} 10 B H E H P B 2920@end group 2921@end smallexample 2922 2923@noindent 2924Here we first use @kbd{B} to compute the base-10 logarithm, then use 2925the ``hyperbolic'' exponential as a cheap hack to recover the number 29261000, then use @kbd{B} again to compute the natural logarithm. Note 2927that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e} 2928onto the stack. 2929 2930You may have noticed that both times we took the base-10 logarithm 2931of 1000, we got an exact integer result. Calc always tries to give 2932an exact rational result for calculations involving rational numbers 2933where possible. But when we used @kbd{H E}, the result was a 2934floating-point number for no apparent reason. In fact, if we had 2935computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an 2936exact integer 1000. But the @kbd{H E} command is rigged to generate 2937a floating-point result all of the time so that @kbd{1000 H E} will 2938not waste time computing a thousand-digit integer when all you 2939probably wanted was @samp{1e1000}. 2940 2941(@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to 2942the @kbd{B} command for which Calc could find an exact rational 2943result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{}) 2944 2945The Calculator also has a set of functions relating to combinatorics 2946and statistics. You may be familiar with the @dfn{factorial} function, 2947which computes the product of all the integers up to a given number. 2948 2949@smallexample 2950@group 29511: 100 1: 93326215443... 1: 100. 1: 9.3326e157 2952 . . . . 2953 2954 100 ! U c f ! 2955@end group 2956@end smallexample 2957 2958@noindent 2959Recall, the @kbd{c f} command converts the integer or fraction at the 2960top of the stack to floating-point format. If you take the factorial 2961of a floating-point number, you get a floating-point result 2962accurate to the current precision. But if you give @kbd{!} an 2963exact integer, you get an exact integer result (158 digits long 2964in this case). 2965 2966If you take the factorial of a non-integer, Calc uses a generalized 2967factorial function defined in terms of Euler's Gamma function 2968@texline @math{\Gamma(n)} 2969@infoline @expr{gamma(n)} 2970(which is itself available as the @kbd{f g} command). 2971 2972@smallexample 2973@group 29743: 4. 3: 24. 1: 5.5 1: 52.342777847 29752: 4.5 2: 52.3427777847 . . 29761: 5. 1: 120. 2977 . . 2978 2979 M-3 ! M-0 @key{DEL} 5.5 f g 2980@end group 2981@end smallexample 2982 2983@noindent 2984Here we verify the identity 2985@texline @math{n! = \Gamma(n+1)}. 2986@infoline @expr{@var{n}!@: = gamma(@var{n}+1)}. 2987 2988The binomial coefficient @var{n}-choose-@var{m} 2989@texline or @math{\displaystyle {n \choose m}} 2990is defined by 2991@texline @math{\displaystyle {n! \over m! \, (n-m)!}} 2992@infoline @expr{n!@: / m!@: (n-m)!} 2993for all reals @expr{n} and @expr{m}. The intermediate results in this 2994formula can become quite large even if the final result is small; the 2995@kbd{k c} command computes a binomial coefficient in a way that avoids 2996large intermediate values. 2997 2998The @kbd{k} prefix key defines several common functions out of 2999combinatorics and number theory. Here we compute the binomial 3000coefficient 30-choose-20, then determine its prime factorization. 3001 3002@smallexample 3003@group 30042: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29] 30051: 20 . . 3006 . 3007 3008 30 @key{RET} 20 k c k f 3009@end group 3010@end smallexample 3011 3012@noindent 3013You can verify these prime factors by using @kbd{V R *} to multiply 3014together the elements of this vector. The result is the original 3015number, 30045015. 3016 3017@cindex Hash tables 3018Suppose a program you are writing needs a hash table with at least 301910000 entries. It's best to use a prime number as the actual size 3020of a hash table. Calc can compute the next prime number after 10000: 3021 3022@smallexample 3023@group 30241: 10000 1: 10007 1: 9973 3025 . . . 3026 3027 10000 k n I k n 3028@end group 3029@end smallexample 3030 3031@noindent 3032Just for kicks we've also computed the next prime @emph{less} than 303310000. 3034 3035@c [fix-ref Financial Functions] 3036@xref{Financial Functions}, for a description of the Calculator 3037commands that deal with business and financial calculations (functions 3038like @code{pv}, @code{rate}, and @code{sln}). 3039 3040@c [fix-ref Binary Number Functions] 3041@xref{Binary Functions}, to read about the commands for operating 3042on binary numbers (like @code{and}, @code{xor}, and @code{lsh}). 3043 3044@node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial 3045@section Vector/Matrix Tutorial 3046 3047@noindent 3048A @dfn{vector} is a list of numbers or other Calc data objects. 3049Calc provides a large set of commands that operate on vectors. Some 3050are familiar operations from vector analysis. Others simply treat 3051a vector as a list of objects. 3052 3053@menu 3054* Vector Analysis Tutorial:: 3055* Matrix Tutorial:: 3056* List Tutorial:: 3057@end menu 3058 3059@node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial 3060@subsection Vector Analysis 3061 3062@noindent 3063If you add two vectors, the result is a vector of the sums of the 3064elements, taken pairwise. 3065 3066@smallexample 3067@group 30681: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3] 3069 . 1: [7, 6, 0] . 3070 . 3071 3072 [1,2,3] s 1 [7 6 0] s 2 + 3073@end group 3074@end smallexample 3075 3076@noindent 3077Note that we can separate the vector elements with either commas or 3078spaces. This is true whether we are using incomplete vectors or 3079algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these 3080vectors so we can easily reuse them later. 3081 3082If you multiply two vectors, the result is the sum of the products 3083of the elements taken pairwise. This is called the @dfn{dot product} 3084of the vectors. 3085 3086@smallexample 3087@group 30882: [1, 2, 3] 1: 19 30891: [7, 6, 0] . 3090 . 3091 3092 r 1 r 2 * 3093@end group 3094@end smallexample 3095 3096@cindex Dot product 3097The dot product of two vectors is equal to the product of their 3098lengths times the cosine of the angle between them. (Here the vector 3099is interpreted as a line from the origin @expr{(0,0,0)} to the 3100specified point in three-dimensional space.) The @kbd{A} 3101(absolute value) command can be used to compute the length of a 3102vector. 3103 3104@smallexample 3105@group 31063: 19 3: 19 1: 0.550782 1: 56.579 31072: [1, 2, 3] 2: 3.741657 . . 31081: [7, 6, 0] 1: 9.219544 3109 . . 3110 3111 M-@key{RET} M-2 A * / I C 3112@end group 3113@end smallexample 3114 3115@noindent 3116First we recall the arguments to the dot product command, then 3117we compute the absolute values of the top two stack entries to 3118obtain the lengths of the vectors, then we divide the dot product 3119by the product of the lengths to get the cosine of the angle. 3120The inverse cosine finds that the angle between the vectors 3121is about 56 degrees. 3122 3123@cindex Cross product 3124@cindex Perpendicular vectors 3125The @dfn{cross product} of two vectors is a vector whose length 3126is the product of the lengths of the inputs times the sine of the 3127angle between them, and whose direction is perpendicular to both 3128input vectors. Unlike the dot product, the cross product is 3129defined only for three-dimensional vectors. Let's double-check 3130our computation of the angle using the cross product. 3131 3132@smallexample 3133@group 31342: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579 31351: [7, 6, 0] 2: [1, 2, 3] . . 3136 . 1: [7, 6, 0] 3137 . 3138 3139 r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S 3140@end group 3141@end smallexample 3142 3143@noindent 3144First we recall the original vectors and compute their cross product, 3145which we also store for later reference. Now we divide the vector 3146by the product of the lengths of the original vectors. The length of 3147this vector should be the sine of the angle; sure enough, it is! 3148 3149@c [fix-ref General Mode Commands] 3150Vector-related commands generally begin with the @kbd{v} prefix key. 3151Some are uppercase letters and some are lowercase. To make it easier 3152to type these commands, the shift-@kbd{V} prefix key acts the same as 3153the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all 3154prefix keys have this property.) 3155 3156If we take the dot product of two perpendicular vectors we expect 3157to get zero, since the cosine of 90 degrees is zero. Let's check 3158that the cross product is indeed perpendicular to both inputs: 3159 3160@smallexample 3161@group 31622: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0 31631: [-18, 21, -8] . 1: [-18, 21, -8] . 3164 . . 3165 3166 r 1 r 3 * @key{DEL} r 2 r 3 * 3167@end group 3168@end smallexample 3169 3170@cindex Normalizing a vector 3171@cindex Unit vectors 3172(@bullet{}) @strong{Exercise 1.} Given a vector on the top of the 3173stack, what keystrokes would you use to @dfn{normalize} the 3174vector, i.e., to reduce its length to one without changing its 3175direction? @xref{Vector Answer 1, 1}. (@bullet{}) 3176 3177(@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be 3178at any of several positions along a ruler. You have a list of 3179those positions in the form of a vector, and another list of the 3180probabilities for the particle to be at the corresponding positions. 3181Find the average position of the particle. 3182@xref{Vector Answer 2, 2}. (@bullet{}) 3183 3184@node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial 3185@subsection Matrices 3186 3187@noindent 3188A @dfn{matrix} is just a vector of vectors, all the same length. 3189This means you can enter a matrix using nested brackets. You can 3190also use the semicolon character to enter a matrix. We'll show 3191both methods here: 3192 3193@smallexample 3194@group 31951: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] 3196 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] 3197 . . 3198 3199 [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET} 3200@end group 3201@end smallexample 3202 3203@noindent 3204We'll be using this matrix again, so type @kbd{s 4} to save it now. 3205 3206Note that semicolons work with incomplete vectors, but they work 3207better in algebraic entry. That's why we use the apostrophe in 3208the second example. 3209 3210When two matrices are multiplied, the lefthand matrix must have 3211the same number of columns as the righthand matrix has rows. 3212Row @expr{i}, column @expr{j} of the result is effectively the 3213dot product of row @expr{i} of the left matrix by column @expr{j} 3214of the right matrix. 3215 3216If we try to duplicate this matrix and multiply it by itself, 3217the dimensions are wrong and the multiplication cannot take place: 3218 3219@smallexample 3220@group 32211: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ] 3222 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] 3223 . 3224 3225 @key{RET} * 3226@end group 3227@end smallexample 3228 3229@noindent 3230Though rather hard to read, this is a formula which shows the product 3231of two matrices. The @samp{*} function, having invalid arguments, has 3232been left in symbolic form. 3233 3234We can multiply the matrices if we @dfn{transpose} one of them first. 3235 3236@smallexample 3237@group 32382: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ] 3239 [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ] 32401: [ [ 1, 4 ] . [ 27, 36, 45 ] ] 3241 [ 2, 5 ] . 3242 [ 3, 6 ] ] 3243 . 3244 3245 U v t * U @key{TAB} * 3246@end group 3247@end smallexample 3248 3249Matrix multiplication is not commutative; indeed, switching the 3250order of the operands can even change the dimensions of the result 3251matrix, as happened here! 3252 3253If you multiply a plain vector by a matrix, it is treated as a 3254single row or column depending on which side of the matrix it is 3255on. The result is a plain vector which should also be interpreted 3256as a row or column as appropriate. 3257 3258@smallexample 3259@group 32602: [ [ 1, 2, 3 ] 1: [14, 32] 3261 [ 4, 5, 6 ] ] . 32621: [1, 2, 3] 3263 . 3264 3265 r 4 r 1 * 3266@end group 3267@end smallexample 3268 3269Multiplying in the other order wouldn't work because the number of 3270rows in the matrix is different from the number of elements in the 3271vector. 3272 3273(@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows 3274of the above 3275@texline @math{2\times3} 3276@infoline 2x3 3277matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns 3278to get @expr{[5, 7, 9]}. 3279@xref{Matrix Answer 1, 1}. (@bullet{}) 3280 3281@cindex Identity matrix 3282An @dfn{identity matrix} is a square matrix with ones along the 3283diagonal and zeros elsewhere. It has the property that multiplication 3284by an identity matrix, on the left or on the right, always produces 3285the original matrix. 3286 3287@smallexample 3288@group 32891: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] 3290 [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] 3291 . 1: [ [ 1, 0, 0 ] . 3292 [ 0, 1, 0 ] 3293 [ 0, 0, 1 ] ] 3294 . 3295 3296 r 4 v i 3 @key{RET} * 3297@end group 3298@end smallexample 3299 3300If a matrix is square, it is often possible to find its @dfn{inverse}, 3301that is, a matrix which, when multiplied by the original matrix, yields 3302an identity matrix. The @kbd{&} (reciprocal) key also computes the 3303inverse of a matrix. 3304 3305@smallexample 3306@group 33071: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ] 3308 [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ] 3309 [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ] 3310 . . 3311 3312 r 4 r 2 | s 5 & 3313@end group 3314@end smallexample 3315 3316@noindent 3317The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and 3318matrices together. Here we have used it to add a new row onto 3319our matrix to make it square. 3320 3321We can multiply these two matrices in either order to get an identity. 3322 3323@smallexample 3324@group 33251: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ] 3326 [ 0., 1., 0. ] [ 0., 1., 0. ] 3327 [ 0., 0., 1. ] ] [ 0., 0., 1. ] ] 3328 . . 3329 3330 M-@key{RET} * U @key{TAB} * 3331@end group 3332@end smallexample 3333 3334@cindex Systems of linear equations 3335@cindex Linear equations, systems of 3336Matrix inverses are related to systems of linear equations in algebra. 3337Suppose we had the following set of equations: 3338 3339@ifnottex 3340@group 3341@example 3342 a + 2b + 3c = 6 3343 4a + 5b + 6c = 2 3344 7a + 6b = 3 3345@end example 3346@end group 3347@end ifnottex 3348@tex 3349\beforedisplayh 3350$$ \openup1\jot \tabskip=0pt plus1fil 3351\halign to\displaywidth{\tabskip=0pt 3352 $\hfil#$&$\hfil{}#{}$& 3353 $\hfil#$&$\hfil{}#{}$& 3354 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr 3355 a&+&2b&+&3c&=6 \cr 3356 4a&+&5b&+&6c&=2 \cr 3357 7a&+&6b& & &=3 \cr} 3358$$ 3359\afterdisplayh 3360@end tex 3361 3362@noindent 3363This can be cast into the matrix equation, 3364 3365@ifnottex 3366@group 3367@example 3368 [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ] 3369 [ 4, 5, 6 ] * [ b ] = [ 2 ] 3370 [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ] 3371@end example 3372@end group 3373@end ifnottex 3374@tex 3375\beforedisplay 3376$$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 } 3377 \times 3378 \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 } 3379$$ 3380\afterdisplay 3381@end tex 3382 3383We can solve this system of equations by multiplying both sides by the 3384inverse of the matrix. Calc can do this all in one step: 3385 3386@smallexample 3387@group 33882: [6, 2, 3] 1: [-12.6, 15.2, -3.93333] 33891: [ [ 1, 2, 3 ] . 3390 [ 4, 5, 6 ] 3391 [ 7, 6, 0 ] ] 3392 . 3393 3394 [6,2,3] r 5 / 3395@end group 3396@end smallexample 3397 3398@noindent 3399The result is the @expr{[a, b, c]} vector that solves the equations. 3400(Dividing by a square matrix is equivalent to multiplying by its 3401inverse.) 3402 3403Let's verify this solution: 3404 3405@smallexample 3406@group 34072: [ [ 1, 2, 3 ] 1: [6., 2., 3.] 3408 [ 4, 5, 6 ] . 3409 [ 7, 6, 0 ] ] 34101: [-12.6, 15.2, -3.93333] 3411 . 3412 3413 r 5 @key{TAB} * 3414@end group 3415@end smallexample 3416 3417@noindent 3418Note that we had to be careful about the order in which we multiplied 3419the matrix and vector. If we multiplied in the other order, Calc would 3420assume the vector was a row vector in order to make the dimensions 3421come out right, and the answer would be incorrect. If you 3422don't feel safe letting Calc take either interpretation of your 3423vectors, use explicit 3424@texline @math{N\times1} 3425@infoline Nx1 3426or 3427@texline @math{1\times N} 3428@infoline 1xN 3429matrices instead. In this case, you would enter the original column 3430vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}. 3431 3432(@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make 3433vectors and matrices that include variables. Solve the following 3434system of equations to get expressions for @expr{x} and @expr{y} 3435in terms of @expr{a} and @expr{b}. 3436 3437@ifnottex 3438@group 3439@example 3440 x + a y = 6 3441 x + b y = 10 3442@end example 3443@end group 3444@end ifnottex 3445@tex 3446\beforedisplay 3447$$ \eqalign{ x &+ a y = 6 \cr 3448 x &+ b y = 10} 3449$$ 3450\afterdisplay 3451@end tex 3452 3453@noindent 3454@xref{Matrix Answer 2, 2}. (@bullet{}) 3455 3456@cindex Least-squares for over-determined systems 3457@cindex Over-determined systems of equations 3458(@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined'' 3459if it has more equations than variables. It is often the case that 3460there are no values for the variables that will satisfy all the 3461equations at once, but it is still useful to find a set of values 3462which ``nearly'' satisfy all the equations. In terms of matrix equations, 3463you can't solve @expr{A X = B} directly because the matrix @expr{A} 3464is not square for an over-determined system. Matrix inversion works 3465only for square matrices. One common trick is to multiply both sides 3466on the left by the transpose of @expr{A}: 3467@ifnottex 3468@samp{trn(A)*A*X = trn(A)*B}. 3469@end ifnottex 3470@tex 3471$A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}. 3472@end tex 3473Now 3474@texline @math{A^T A} 3475@infoline @expr{trn(A)*A} 3476is a square matrix so a solution is possible. It turns out that the 3477@expr{X} vector you compute in this way will be a ``least-squares'' 3478solution, which can be regarded as the ``closest'' solution to the set 3479of equations. Use Calc to solve the following over-determined 3480system: 3481 3482@ifnottex 3483@group 3484@example 3485 a + 2b + 3c = 6 3486 4a + 5b + 6c = 2 3487 7a + 6b = 3 3488 2a + 4b + 6c = 11 3489@end example 3490@end group 3491@end ifnottex 3492@tex 3493\beforedisplayh 3494$$ \openup1\jot \tabskip=0pt plus1fil 3495\halign to\displaywidth{\tabskip=0pt 3496 $\hfil#$&$\hfil{}#{}$& 3497 $\hfil#$&$\hfil{}#{}$& 3498 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr 3499 a&+&2b&+&3c&=6 \cr 3500 4a&+&5b&+&6c&=2 \cr 3501 7a&+&6b& & &=3 \cr 3502 2a&+&4b&+&6c&=11 \cr} 3503$$ 3504\afterdisplayh 3505@end tex 3506 3507@noindent 3508@xref{Matrix Answer 3, 3}. (@bullet{}) 3509 3510@node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial 3511@subsection Vectors as Lists 3512 3513@noindent 3514@cindex Lists 3515Although Calc has a number of features for manipulating vectors and 3516matrices as mathematical objects, you can also treat vectors as 3517simple lists of values. For example, we saw that the @kbd{k f} 3518command returns a vector which is a list of the prime factors of a 3519number. 3520 3521You can pack and unpack stack entries into vectors: 3522 3523@smallexample 3524@group 35253: 10 1: [10, 20, 30] 3: 10 35262: 20 . 2: 20 35271: 30 1: 30 3528 . . 3529 3530 M-3 v p v u 3531@end group 3532@end smallexample 3533 3534You can also build vectors out of consecutive integers, or out 3535of many copies of a given value: 3536 3537@smallexample 3538@group 35391: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4] 3540 . 1: 17 1: [17, 17, 17, 17] 3541 . . 3542 3543 v x 4 @key{RET} 17 v b 4 @key{RET} 3544@end group 3545@end smallexample 3546 3547You can apply an operator to every element of a vector using the 3548@dfn{map} command. 3549 3550@smallexample 3551@group 35521: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68] 3553 . . . 3554 3555 V M * 2 V M ^ V M Q 3556@end group 3557@end smallexample 3558 3559@noindent 3560In the first step, we multiply the vector of integers by the vector 3561of 17's elementwise. In the second step, we raise each element to 3562the power two. (The general rule is that both operands must be 3563vectors of the same length, or else one must be a vector and the 3564other a plain number.) In the final step, we take the square root 3565of each element. 3566 3567(@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two 3568from 3569@texline @math{2^{-4}} 3570@infoline @expr{2^-4} 3571to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{}) 3572 3573You can also @dfn{reduce} a binary operator across a vector. 3574For example, reducing @samp{*} computes the product of all the 3575elements in the vector: 3576 3577@smallexample 3578@group 35791: 123123 1: [3, 7, 11, 13, 41] 1: 123123 3580 . . . 3581 3582 123123 k f V R * 3583@end group 3584@end smallexample 3585 3586@noindent 3587In this example, we decompose 123123 into its prime factors, then 3588multiply those factors together again to yield the original number. 3589 3590We could compute a dot product ``by hand'' using mapping and 3591reduction: 3592 3593@smallexample 3594@group 35952: [1, 2, 3] 1: [7, 12, 0] 1: 19 35961: [7, 6, 0] . . 3597 . 3598 3599 r 1 r 2 V M * V R + 3600@end group 3601@end smallexample 3602 3603@noindent 3604Recalling two vectors from the previous section, we compute the 3605sum of pairwise products of the elements to get the same answer 3606for the dot product as before. 3607 3608A slight variant of vector reduction is the @dfn{accumulate} operation, 3609@kbd{V U}. This produces a vector of the intermediate results from 3610a corresponding reduction. Here we compute a table of factorials: 3611 3612@smallexample 3613@group 36141: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720] 3615 . . 3616 3617 v x 6 @key{RET} V U * 3618@end group 3619@end smallexample 3620 3621Calc allows vectors to grow as large as you like, although it gets 3622rather slow if vectors have more than about a hundred elements. 3623Actually, most of the time is spent formatting these large vectors 3624for display, not calculating on them. Try the following experiment 3625(if your computer is very fast you may need to substitute a larger 3626vector size). 3627 3628@smallexample 3629@group 36301: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ... 3631 . . 3632 3633 v x 500 @key{RET} 1 V M + 3634@end group 3635@end smallexample 3636 3637Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the 3638experiment again. In @kbd{v .} mode, long vectors are displayed 3639``abbreviated'' like this: 3640 3641@smallexample 3642@group 36431: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501] 3644 . . 3645 3646 v x 500 @key{RET} 1 V M + 3647@end group 3648@end smallexample 3649 3650@noindent 3651(where now the @samp{...} is actually part of the Calc display). 3652You will find both operations are now much faster. But notice that 3653even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail. 3654Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the 3655experiment one more time. Operations on long vectors are now quite 3656fast! (But of course if you use @kbd{t .} you will lose the ability 3657to get old vectors back using the @kbd{t y} command.) 3658 3659An easy way to view a full vector when @kbd{v .} mode is active is 3660to press @kbd{`} (grave accent) to edit the vector; editing always works 3661with the full, unabbreviated value. 3662 3663@cindex Least-squares for fitting a straight line 3664@cindex Fitting data to a line 3665@cindex Line, fitting data to 3666@cindex Data, extracting from buffers 3667@cindex Columns of data, extracting 3668As a larger example, let's try to fit a straight line to some data, 3669using the method of least squares. (Calc has a built-in command for 3670least-squares curve fitting, but we'll do it by hand here just to 3671practice working with vectors.) Suppose we have the following list 3672of values in a file we have loaded into Emacs: 3673 3674@smallexample 3675 x y 3676 --- --- 3677 1.34 0.234 3678 1.41 0.298 3679 1.49 0.402 3680 1.56 0.412 3681 1.64 0.466 3682 1.73 0.473 3683 1.82 0.601 3684 1.91 0.519 3685 2.01 0.603 3686 2.11 0.637 3687 2.22 0.645 3688 2.33 0.705 3689 2.45 0.917 3690 2.58 1.009 3691 2.71 0.971 3692 2.85 1.062 3693 3.00 1.148 3694 3.15 1.157 3695 3.32 1.354 3696@end smallexample 3697 3698@noindent 3699If you are reading this tutorial in printed form, you will find it 3700easiest to press @kbd{C-x * i} to enter the on-line Info version of 3701the manual and find this table there. (Press @kbd{g}, then type 3702@kbd{List Tutorial}, to jump straight to this section.) 3703 3704Position the cursor at the upper-left corner of this table, just 3705to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark. 3706(On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.) 3707Now position the cursor to the lower-right, just after the @expr{1.354}. 3708You have now defined this region as an Emacs ``rectangle.'' Still 3709in the Info buffer, type @kbd{C-x * r}. This command 3710(@code{calc-grab-rectangle}) will pop you back into the Calculator, with 3711the contents of the rectangle you specified in the form of a matrix. 3712 3713@smallexample 3714@group 37151: [ [ 1.34, 0.234 ] 3716 [ 1.41, 0.298 ] 3717 @dots{} 3718@end group 3719@end smallexample 3720 3721@noindent 3722(You may wish to use @kbd{v .} mode to abbreviate the display of this 3723large matrix.) 3724 3725We want to treat this as a pair of lists. The first step is to 3726transpose this matrix into a pair of rows. Remember, a matrix is 3727just a vector of vectors. So we can unpack the matrix into a pair 3728of row vectors on the stack. 3729 3730@smallexample 3731@group 37321: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ] 3733 [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ] 3734 . . 3735 3736 v t v u 3737@end group 3738@end smallexample 3739 3740@noindent 3741Let's store these in quick variables 1 and 2, respectively. 3742 3743@smallexample 3744@group 37451: [1.34, 1.41, 1.49, ... ] . 3746 . 3747 3748 t 2 t 1 3749@end group 3750@end smallexample 3751 3752@noindent 3753(Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the 3754stored value from the stack.) 3755 3756In a least squares fit, the slope @expr{m} is given by the formula 3757 3758@ifnottex 3759@example 3760m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2) 3761@end example 3762@end ifnottex 3763@tex 3764\beforedisplay 3765$$ m = {N \sum x y - \sum x \sum y \over 3766 N \sum x^2 - \left( \sum x \right)^2} $$ 3767\afterdisplay 3768@end tex 3769 3770@noindent 3771where 3772@texline @math{\sum x} 3773@infoline @expr{sum(x)} 3774represents the sum of all the values of @expr{x}. While there is an 3775actual @code{sum} function in Calc, it's easier to sum a vector using a 3776simple reduction. First, let's compute the four different sums that 3777this formula uses. 3778 3779@smallexample 3780@group 37811: 41.63 1: 98.0003 3782 . . 3783 3784 r 1 V R + t 3 r 1 2 V M ^ V R + t 4 3785 3786@end group 3787@end smallexample 3788@noindent 3789@smallexample 3790@group 37911: 13.613 1: 33.36554 3792 . . 3793 3794 r 2 V R + t 5 r 1 r 2 V M * V R + t 6 3795@end group 3796@end smallexample 3797 3798@ifnottex 3799@noindent 3800These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)}, 3801respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and 3802@samp{sum(x y)}.) 3803@end ifnottex 3804@tex 3805These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$, 3806respectively. (We could have used \kbd{*} to compute $\sum x^2$ and 3807$\sum x y$.) 3808@end tex 3809 3810Finally, we also need @expr{N}, the number of data points. This is just 3811the length of either of our lists. 3812 3813@smallexample 3814@group 38151: 19 3816 . 3817 3818 r 1 v l t 7 3819@end group 3820@end smallexample 3821 3822@noindent 3823(That's @kbd{v} followed by a lower-case @kbd{l}.) 3824 3825Now we grind through the formula: 3826 3827@smallexample 3828@group 38291: 633.94526 2: 633.94526 1: 67.23607 3830 . 1: 566.70919 . 3831 . 3832 3833 r 7 r 6 * r 3 r 5 * - 3834 3835@end group 3836@end smallexample 3837@noindent 3838@smallexample 3839@group 38402: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679 38411: 1862.0057 2: 1862.0057 1: 128.9488 . 3842 . 1: 1733.0569 . 3843 . 3844 3845 r 7 r 4 * r 3 2 ^ - / t 8 3846@end group 3847@end smallexample 3848 3849That gives us the slope @expr{m}. The y-intercept @expr{b} can now 3850be found with the simple formula, 3851 3852@ifnottex 3853@example 3854b = (sum(y) - m sum(x)) / N 3855@end example 3856@end ifnottex 3857@tex 3858\beforedisplay 3859$$ b = {\sum y - m \sum x \over N} $$ 3860\afterdisplay 3861\vskip10pt 3862@end tex 3863 3864@smallexample 3865@group 38661: 13.613 2: 13.613 1: -8.09358 1: -0.425978 3867 . 1: 21.70658 . . 3868 . 3869 3870 r 5 r 8 r 3 * - r 7 / t 9 3871@end group 3872@end smallexample 3873 3874Let's ``plot'' this straight line approximation, 3875@texline @math{y \approx m x + b}, 3876@infoline @expr{m x + b}, 3877and compare it with the original data. 3878 3879@smallexample 3880@group 38811: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ] 3882 . . 3883 3884 r 1 r 8 * r 9 + s 0 3885@end group 3886@end smallexample 3887 3888@noindent 3889Notice that multiplying a vector by a constant, and adding a constant 3890to a vector, can be done without mapping commands since these are 3891common operations from vector algebra. As far as Calc is concerned, 3892we've just been doing geometry in 19-dimensional space! 3893 3894We can subtract this vector from our original @expr{y} vector to get 3895a feel for the error of our fit. Let's find the maximum error: 3896 3897@smallexample 3898@group 38991: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897 3900 . . . 3901 3902 r 2 - V M A V R X 3903@end group 3904@end smallexample 3905 3906@noindent 3907First we compute a vector of differences, then we take the absolute 3908values of these differences, then we reduce the @code{max} function 3909across the vector. (The @code{max} function is on the two-key sequence 3910@kbd{f x}; because it is so common to use @code{max} in a vector 3911operation, the letters @kbd{X} and @kbd{N} are also accepted for 3912@code{max} and @code{min} in this context. In general, you answer 3913the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that 3914invokes the function you want. You could have typed @kbd{V R f x} or 3915even @kbd{V R x max @key{RET}} if you had preferred.) 3916 3917If your system has the GNUPLOT program, you can see graphs of your 3918data and your straight line to see how well they match. (If you have 3919GNUPLOT 3.0 or higher, the following instructions will work regardless 3920of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems 3921may require additional steps to view the graphs.) 3922 3923Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}'' 3924vectors onto the stack and press @kbd{g f}. This ``fast'' graphing 3925command does everything you need to do for simple, straightforward 3926plotting of data. 3927 3928@smallexample 3929@group 39302: [1.34, 1.41, 1.49, ... ] 39311: [0.234, 0.298, 0.402, ... ] 3932 . 3933 3934 r 1 r 2 g f 3935@end group 3936@end smallexample 3937 3938If all goes well, you will shortly get a new window containing a graph 3939of the data. (If not, contact your GNUPLOT or Calc installer to find 3940out what went wrong.) In the X window system, this will be a separate 3941graphics window. For other kinds of displays, the default is to 3942display the graph in Emacs itself using rough character graphics. 3943Press @kbd{q} when you are done viewing the character graphics. 3944 3945Next, let's add the line we got from our least-squares fit. 3946@ifinfo 3947(If you are reading this tutorial on-line while running Calc, typing 3948@kbd{g a} may cause the tutorial to disappear from its window and be 3949replaced by a buffer named @file{*Gnuplot Commands*}. The tutorial 3950will reappear when you terminate GNUPLOT by typing @kbd{g q}.) 3951@end ifinfo 3952 3953@smallexample 3954@group 39552: [1.34, 1.41, 1.49, ... ] 39561: [0.273, 0.309, 0.351, ... ] 3957 . 3958 3959 @key{DEL} r 0 g a g p 3960@end group 3961@end smallexample 3962 3963It's not very useful to get symbols to mark the data points on this 3964second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q} 3965when you are done to remove the X graphics window and terminate GNUPLOT. 3966 3967(@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do 3968least squares fitting to a general system of equations. Our 19 data 3969points are really 19 equations of the form @expr{y_i = m x_i + b} for 3970different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method 3971to solve for @expr{m} and @expr{b}, duplicating the above result. 3972@xref{List Answer 2, 2}. (@bullet{}) 3973 3974@cindex Geometric mean 3975(@bullet{}) @strong{Exercise 3.} If the input data do not form a 3976rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region}) 3977to grab the data the way Emacs normally works with regions---it reads 3978left-to-right, top-to-bottom, treating line breaks the same as spaces. 3979Use this command to find the geometric mean of the following numbers. 3980(The geometric mean is the @var{n}th root of the product of @var{n} numbers.) 3981 3982@example 39832.3 6 22 15.1 7 3984 15 14 7.5 3985 2.5 3986@end example 3987 3988@noindent 3989The @kbd{C-x * g} command accepts numbers separated by spaces or commas, 3990with or without surrounding vector brackets. 3991@xref{List Answer 3, 3}. (@bullet{}) 3992 3993@ifnottex 3994As another example, a theorem about binomial coefficients tells 3995us that the alternating sum of binomial coefficients 3996@var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so 3997on up to @var{n}-choose-@var{n}, 3998always comes out to zero. Let's verify this 3999for @expr{n=6}. 4000@end ifnottex 4001@tex 4002As another example, a theorem about binomial coefficients tells 4003us that the alternating sum of binomial coefficients 4004${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$ 4005always comes out to zero. Let's verify this 4006for \cite{n=6}. 4007@end tex 4008 4009@smallexample 4010@group 40111: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6] 4012 . . 4013 4014 v x 7 @key{RET} 1 - 4015 4016@end group 4017@end smallexample 4018@noindent 4019@smallexample 4020@group 40211: [1, -6, 15, -20, 15, -6, 1] 1: 0 4022 . . 4023 4024 V M ' (-1)^$ choose(6,$) @key{RET} V R + 4025@end group 4026@end smallexample 4027 4028The @kbd{V M '} command prompts you to enter any algebraic expression 4029to define the function to map over the vector. The symbol @samp{$} 4030inside this expression represents the argument to the function. 4031The Calculator applies this formula to each element of the vector, 4032substituting each element's value for the @samp{$} sign(s) in turn. 4033 4034To define a two-argument function, use @samp{$$} for the first 4035argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is 4036equivalent to @kbd{V M -}. This is analogous to regular algebraic 4037entry, where @samp{$$} would refer to the next-to-top stack entry 4038and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}} 4039would act exactly like @kbd{-}. 4040 4041Notice that the @kbd{V M '} command has recorded two things in the 4042trail: The result, as usual, and also a funny-looking thing marked 4043@samp{oper} that represents the operator function you typed in. 4044The function is enclosed in @samp{< >} brackets, and the argument is 4045denoted by a @samp{#} sign. If there were several arguments, they 4046would be shown as @samp{#1}, @samp{#2}, and so on. (For example, 4047@kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the 4048trail.) This object is a ``nameless function''; you can use nameless 4049@w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like. 4050Nameless function notation has the interesting, occasionally useful 4051property that a nameless function is not actually evaluated until 4052it is used. For example, @kbd{V M ' $+random(2.0)} evaluates 4053@samp{random(2.0)} once and adds that random number to all elements 4054of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the 4055@samp{random(2.0)} separately for each vector element. 4056 4057Another group of operators that are often useful with @kbd{V M} are 4058the relational operators: @kbd{a =}, for example, compares two numbers 4059and gives the result 1 if they are equal, or 0 if not. Similarly, 4060@w{@kbd{a <}} checks for one number being less than another. 4061 4062Other useful vector operations include @kbd{v v}, to reverse a 4063vector end-for-end; @kbd{V S}, to sort the elements of a vector 4064into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract 4065one row or column of a matrix, or (in both cases) to extract one 4066element of a plain vector. With a negative argument, @kbd{v r} 4067and @kbd{v c} instead delete one row, column, or vector element. 4068 4069@cindex Divisor functions 4070(@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function} 4071@tex 4072$\sigma_k(n)$ 4073@end tex 4074is the sum of the @expr{k}th powers of all the divisors of an 4075integer @expr{n}. Figure out a method for computing the divisor 4076function for reasonably small values of @expr{n}. As a test, 4077the 0th and 1st divisor functions of 30 are 8 and 72, respectively. 4078@xref{List Answer 4, 4}. (@bullet{}) 4079 4080@cindex Square-free numbers 4081@cindex Duplicate values in a list 4082(@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a 4083list of prime factors for a number. Sometimes it is important to 4084know that a number is @dfn{square-free}, i.e., that no prime occurs 4085more than once in its list of prime factors. Find a sequence of 4086keystrokes to tell if a number is square-free; your method should 4087leave 1 on the stack if it is, or 0 if it isn't. 4088@xref{List Answer 5, 5}. (@bullet{}) 4089 4090@cindex Triangular lists 4091(@bullet{}) @strong{Exercise 6.} Build a list of lists that looks 4092like the following diagram. (You may wish to use the @kbd{v /} 4093command to enable multi-line display of vectors.) 4094 4095@smallexample 4096@group 40971: [ [1], 4098 [1, 2], 4099 [1, 2, 3], 4100 [1, 2, 3, 4], 4101 [1, 2, 3, 4, 5], 4102 [1, 2, 3, 4, 5, 6] ] 4103@end group 4104@end smallexample 4105 4106@noindent 4107@xref{List Answer 6, 6}. (@bullet{}) 4108 4109(@bullet{}) @strong{Exercise 7.} Build the following list of lists. 4110 4111@smallexample 4112@group 41131: [ [0], 4114 [1, 2], 4115 [3, 4, 5], 4116 [6, 7, 8, 9], 4117 [10, 11, 12, 13, 14], 4118 [15, 16, 17, 18, 19, 20] ] 4119@end group 4120@end smallexample 4121 4122@noindent 4123@xref{List Answer 7, 7}. (@bullet{}) 4124 4125@cindex Maximizing a function over a list of values 4126@c [fix-ref Numerical Solutions] 4127(@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's 4128@texline @math{J_1(x)} 4129@infoline @expr{J1} 4130function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25. 4131Find the value of @expr{x} (from among the above set of values) for 4132which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method, 4133i.e., just reading along the list by hand to find the largest value 4134is not allowed! (There is an @kbd{a X} command which does this kind 4135of thing automatically; @pxref{Numerical Solutions}.) 4136@xref{List Answer 8, 8}. (@bullet{}) 4137 4138@cindex Digits, vectors of 4139(@bullet{}) @strong{Exercise 9.} You are given an integer in the range 4140@texline @math{0 \le N < 10^m} 4141@infoline @expr{0 <= N < 10^m} 4142for @expr{m=12} (i.e., an integer of less than 4143twelve digits). Convert this integer into a vector of @expr{m} 4144digits, each in the range from 0 to 9. In vector-of-digits notation, 4145add one to this integer to produce a vector of @expr{m+1} digits 4146(since there could be a carry out of the most significant digit). 4147Convert this vector back into a regular integer. A good integer 4148to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{}) 4149 4150(@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use 4151@kbd{V R a =} to test if all numbers in a list were equal. What 4152happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{}) 4153 4154(@bullet{}) @strong{Exercise 11.} The area of a circle of radius one 4155is @cpi{}. The area of the 4156@texline @math{2\times2} 4157@infoline 2x2 4158square that encloses that circle is 4. So if we throw @var{n} darts at 4159random points in the square, about @cpiover{4} of them will land inside 4160the circle. This gives us an entertaining way to estimate the value of 4161@cpi{}. The @w{@kbd{k r}} 4162command picks a random number between zero and the value on the stack. 4163We could get a random floating-point number between @mathit{-1} and 1 by typing 4164@w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in 4165this square, then use vector mapping and reduction to count how many 4166points lie inside the unit circle. Hint: Use the @kbd{v b} command. 4167@xref{List Answer 11, 11}. (@bullet{}) 4168 4169@cindex Matchstick problem 4170(@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides 4171another way to calculate @cpi{}. Say you have an infinite field 4172of vertical lines with a spacing of one inch. Toss a one-inch matchstick 4173onto the field. The probability that the matchstick will land crossing 4174a line turns out to be 4175@texline @math{2/\pi}. 4176@infoline @expr{2/pi}. 4177Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun, 4178the probability that the GCD (@w{@kbd{k g}}) of two large integers is 4179one turns out to be 4180@texline @math{6/\pi^2}. 4181@infoline @expr{6/pi^2}. 4182That provides yet another way to estimate @cpi{}.) 4183@xref{List Answer 12, 12}. (@bullet{}) 4184 4185(@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in 4186double-quote marks, @samp{"hello"}, creates a vector of the numerical 4187(ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}). 4188Sometimes it is convenient to compute a @dfn{hash code} of a string, 4189which is just an integer that represents the value of that string. 4190Two equal strings have the same hash code; two different strings 4191@dfn{probably} have different hash codes. (For example, Calc has 4192over 400 function names, but Emacs can quickly find the definition for 4193any given name because it has sorted the functions into ``buckets'' by 4194their hash codes. Sometimes a few names will hash into the same bucket, 4195but it is easier to search among a few names than among all the names.) 4196One popular hash function is computed as follows: First set @expr{h = 0}. 4197Then, for each character from the string in turn, set @expr{h = 3h + c_i} 4198where @expr{c_i} is the character's ASCII code. If we have 511 buckets, 4199we then take the hash code modulo 511 to get the bucket number. Develop a 4200simple command or commands for converting string vectors into hash codes. 4201The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo 4202511 is 121. @xref{List Answer 13, 13}. (@bullet{}) 4203 4204(@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U} 4205commands do nested function evaluations. @kbd{H V U} takes a starting 4206value and a number of steps @var{n} from the stack; it then applies the 4207function you give to the starting value 0, 1, 2, up to @var{n} times 4208and returns a vector of the results. Use this command to create a 4209``random walk'' of 50 steps. Start with the two-dimensional point 4210@expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1 4211in both @expr{x} and @expr{y}; then take another step, and so on. Use the 4212@kbd{g f} command to display this random walk. Now modify your random 4213walk to walk a unit distance, but in a random direction, at each step. 4214(Hint: The @code{sincos} function returns a vector of the cosine and 4215sine of an angle.) @xref{List Answer 14, 14}. (@bullet{}) 4216 4217@node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial 4218@section Types Tutorial 4219 4220@noindent 4221Calc understands a variety of data types as well as simple numbers. 4222In this section, we'll experiment with each of these types in turn. 4223 4224The numbers we've been using so far have mainly been either @dfn{integers} 4225or @dfn{floats}. We saw that floats are usually a good approximation to 4226the mathematical concept of real numbers, but they are only approximations 4227and are susceptible to roundoff error. Calc also supports @dfn{fractions}, 4228which can exactly represent any rational number. 4229 4230@smallexample 4231@group 42321: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414 4233 . 1: 49 . . . 4234 . 4235 4236 10 ! 49 @key{RET} : 2 + & 4237@end group 4238@end smallexample 4239 4240@noindent 4241The @kbd{:} command divides two integers to get a fraction; @kbd{/} 4242would normally divide integers to get a floating-point result. 4243Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:} 4244since the @kbd{:} would otherwise be interpreted as part of a 4245fraction beginning with 49. 4246 4247You can convert between floating-point and fractional format using 4248@kbd{c f} and @kbd{c F}: 4249 4250@smallexample 4251@group 42521: 1.35027217629e-5 1: 7:518414 4253 . . 4254 4255 c f c F 4256@end group 4257@end smallexample 4258 4259The @kbd{c F} command replaces a floating-point number with the 4260``simplest'' fraction whose floating-point representation is the 4261same, to within the current precision. 4262 4263@smallexample 4264@group 42651: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113 4266 . . . . 4267 4268 P c F @key{DEL} p 5 @key{RET} P c F 4269@end group 4270@end smallexample 4271 4272(@bullet{}) @strong{Exercise 1.} A calculation has produced the 4273result 1.26508260337. You suspect it is the square root of the 4274product of @cpi{} and some rational number. Is it? (Be sure 4275to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{}) 4276 4277@dfn{Complex numbers} can be stored in both rectangular and polar form. 4278 4279@smallexample 4280@group 42811: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.) 4282 . . . . . 4283 4284 9 n Q c p 2 * Q 4285@end group 4286@end smallexample 4287 4288@noindent 4289The square root of @mathit{-9} is by default rendered in rectangular form 4290(@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a 4291phase angle of 90 degrees). All the usual arithmetic and scientific 4292operations are defined on both types of complex numbers. 4293 4294Another generalized kind of number is @dfn{infinity}. Infinity 4295isn't really a number, but it can sometimes be treated like one. 4296Calc uses the symbol @code{inf} to represent positive infinity, 4297i.e., a value greater than any real number. Naturally, you can 4298also write @samp{-inf} for minus infinity, a value less than any 4299real number. The word @code{inf} can only be input using 4300algebraic entry. 4301 4302@smallexample 4303@group 43042: inf 2: -inf 2: -inf 2: -inf 1: nan 43051: -17 1: -inf 1: -inf 1: inf . 4306 . . . . 4307 4308' inf @key{RET} 17 n * @key{RET} 72 + A + 4309@end group 4310@end smallexample 4311 4312@noindent 4313Since infinity is infinitely large, multiplying it by any finite 4314number (like @mathit{-17}) has no effect, except that since @mathit{-17} 4315is negative, it changes a plus infinity to a minus infinity. 4316(``A huge positive number, multiplied by @mathit{-17}, yields a huge 4317negative number.'') Adding any finite number to infinity also 4318leaves it unchanged. Taking an absolute value gives us plus 4319infinity again. Finally, we add this plus infinity to the minus 4320infinity we had earlier. If you work it out, you might expect 4321the answer to be @mathit{-72} for this. But the 72 has been completely 4322lost next to the infinities; by the time we compute @w{@samp{inf - inf}} 4323the finite difference between them, if any, is undetectable. 4324So we say the result is @dfn{indeterminate}, which Calc writes 4325with the symbol @code{nan} (for Not A Number). 4326 4327Dividing by zero is normally treated as an error, but you can get 4328Calc to write an answer in terms of infinity by pressing @kbd{m i} 4329to turn on Infinite mode. 4330 4331@smallexample 4332@group 43333: nan 2: nan 2: nan 2: nan 1: nan 43342: 1 1: 1 / 0 1: uinf 1: uinf . 43351: 0 . . . 4336 . 4337 4338 1 @key{RET} 0 / m i U / 17 n * + 4339@end group 4340@end smallexample 4341 4342@noindent 4343Dividing by zero normally is left unevaluated, but after @kbd{m i} 4344it instead gives an infinite result. The answer is actually 4345@code{uinf}, ``undirected infinity.'' If you look at a graph of 4346@expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward 4347plus infinity as you approach zero from above, but toward minus 4348infinity as you approach from below. Since we said only @expr{1 / 0}, 4349Calc knows that the answer is infinite but not in which direction. 4350That's what @code{uinf} means. Notice that multiplying @code{uinf} 4351by a negative number still leaves plain @code{uinf}; there's no 4352point in saying @samp{-uinf} because the sign of @code{uinf} is 4353unknown anyway. Finally, we add @code{uinf} to our @code{nan}, 4354yielding @code{nan} again. It's easy to see that, because 4355@code{nan} means ``totally unknown'' while @code{uinf} means 4356``unknown sign but known to be infinite,'' the more mysterious 4357@code{nan} wins out when it is combined with @code{uinf}, or, for 4358that matter, with anything else. 4359 4360(@bullet{}) @strong{Exercise 2.} Predict what Calc will answer 4361for each of these formulas: @samp{inf / inf}, @samp{exp(inf)}, 4362@samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)}, 4363@samp{abs(uinf)}, @samp{ln(0)}. 4364@xref{Types Answer 2, 2}. (@bullet{}) 4365 4366(@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan}, 4367which stands for an unknown value. Can @code{nan} stand for 4368a complex number? Can it stand for infinity? 4369@xref{Types Answer 3, 3}. (@bullet{}) 4370 4371@dfn{HMS forms} represent a value in terms of hours, minutes, and 4372seconds. 4373 4374@smallexample 4375@group 43761: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2. 4377 . . 1: 1@@ 45' 0." . 4378 . 4379 4380 2@@ 30' @key{RET} 1 + @key{RET} 2 / / 4381@end group 4382@end smallexample 4383 4384HMS forms can also be used to hold angles in degrees, minutes, and 4385seconds. 4386 4387@smallexample 4388@group 43891: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721 4390 . . . . 4391 4392 0.5 I T c h S 4393@end group 4394@end smallexample 4395 4396@noindent 4397First we convert the inverse tangent of 0.5 to degrees-minutes-seconds 4398form, then we take the sine of that angle. Note that the trigonometric 4399functions will accept HMS forms directly as input. 4400 4401@cindex Beatles 4402(@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is 440347 minutes and 26 seconds long, and contains 17 songs. What is the 4404average length of a song on @emph{Abbey Road}? If the Extended Disco 4405Version of @emph{Abbey Road} added 20 seconds to the length of each 4406song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{}) 4407 4408A @dfn{date form} represents a date, or a date and time. Dates must 4409be entered using algebraic entry. Date forms are surrounded by 4410@samp{< >} symbols; most standard formats for dates are recognized. 4411 4412@smallexample 4413@group 44142: <Sun Jan 13, 1991> 1: 2.25 44151: <6:00pm Thu Jan 10, 1991> . 4416 . 4417 4418' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} - 4419@end group 4420@end smallexample 4421 4422@noindent 4423In this example, we enter two dates, then subtract to find the 4424number of days between them. It is also possible to add an 4425HMS form or a number (of days) to a date form to get another 4426date form. 4427 4428@smallexample 4429@group 44301: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991> 4431 . . 4432 4433 t N 2 + 10@@ 5' + 4434@end group 4435@end smallexample 4436 4437@c [fix-ref Date Arithmetic] 4438@noindent 4439The @kbd{t N} (``now'') command pushes the current date and time on the 4440stack; then we add two days, ten hours and five minutes to the date and 4441time. Other date-and-time related commands include @kbd{t J}, which 4442does Julian day conversions, @kbd{t W}, which finds the beginning of 4443the week in which a date form lies, and @kbd{t I}, which increments a 4444date by one or several months. @xref{Date Arithmetic}, for more. 4445 4446(@bullet{}) @strong{Exercise 5.} How many days until the next 4447Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{}) 4448 4449(@bullet{}) @strong{Exercise 6.} How many leap years will there be 4450between now and the year 10001 AD@? @xref{Types Answer 6, 6}. (@bullet{}) 4451 4452@cindex Slope and angle of a line 4453@cindex Angle and slope of a line 4454An @dfn{error form} represents a mean value with an attached standard 4455deviation, or error estimate. Suppose our measurements indicate that 4456a certain telephone pole is about 30 meters away, with an estimated 4457error of 1 meter, and 8 meters tall, with an estimated error of 0.2 4458meters. What is the slope of a line from here to the top of the 4459pole, and what is the equivalent angle in degrees? 4460 4461@smallexample 4462@group 44631: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594 4464 . 1: 30 +/- 1 . . 4465 . 4466 4467 8 p .2 @key{RET} 30 p 1 / I T 4468@end group 4469@end smallexample 4470 4471@noindent 4472This means that the angle is about 15 degrees, and, assuming our 4473original error estimates were valid standard deviations, there is about 4474a 60% chance that the result is correct within 0.59 degrees. 4475 4476@cindex Torus, volume of 4477(@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is 4478@texline @math{2 \pi^2 R r^2} 4479@infoline @w{@expr{2 pi^2 R r^2}} 4480where @expr{R} is the radius of the circle that 4481defines the center of the tube and @expr{r} is the radius of the tube 4482itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to 4483within 5 percent. What is the volume and the relative uncertainty of 4484the volume? @xref{Types Answer 7, 7}. (@bullet{}) 4485 4486An @dfn{interval form} represents a range of values. While an 4487error form is best for making statistical estimates, intervals give 4488you exact bounds on an answer. Suppose we additionally know that 4489our telephone pole is definitely between 28 and 31 meters away, 4490and that it is between 7.7 and 8.1 meters tall. 4491 4492@smallexample 4493@group 44941: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1] 4495 . 1: [28 .. 31] . . 4496 . 4497 4498 [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T 4499@end group 4500@end smallexample 4501 4502@noindent 4503If our bounds were correct, then the angle to the top of the pole 4504is sure to lie in the range shown. 4505 4506The square brackets around these intervals indicate that the endpoints 4507themselves are allowable values. In other words, the distance to the 4508telephone pole is between 28 and 31, @emph{inclusive}. You can also 4509make an interval that is exclusive of its endpoints by writing 4510parentheses instead of square brackets. You can even make an interval 4511which is inclusive (``closed'') on one end and exclusive (``open'') on 4512the other. 4513 4514@smallexample 4515@group 45161: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3) 4517 . . 1: [2 .. 3) . 4518 . 4519 4520 [ 1 .. 10 ) & [ 2 .. 3 ) * 4521@end group 4522@end smallexample 4523 4524@noindent 4525The Calculator automatically keeps track of which end values should 4526be open and which should be closed. You can also make infinite or 4527semi-infinite intervals by using @samp{-inf} or @samp{inf} for one 4528or both endpoints. 4529 4530(@bullet{}) @strong{Exercise 8.} What answer would you expect from 4531@samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What 4532about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes 4533zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}? 4534@xref{Types Answer 8, 8}. (@bullet{}) 4535 4536(@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number 4537are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same 4538answer. Would you expect this still to hold true for interval forms? 4539If not, which of these will result in a larger interval? 4540@xref{Types Answer 9, 9}. (@bullet{}) 4541 4542A @dfn{modulo form} is used for performing arithmetic modulo @var{m}. 4543For example, arithmetic involving time is generally done modulo 12 4544or 24 hours. 4545 4546@smallexample 4547@group 45481: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24 4549 . . . . 4550 4551 17 M 24 @key{RET} 10 + n 5 / 4552@end group 4553@end smallexample 4554 4555@noindent 4556In this last step, Calc has divided by 5 modulo 24; i.e., it has found a 4557new number which, when multiplied by 5 modulo 24, produces the original 4558number, 21. If @var{m} is prime and the divisor is not a multiple of 4559@var{m}, it is always possible to find such a number. For non-prime 4560@var{m} like 24, it is only sometimes possible. 4561 4562@smallexample 4563@group 45641: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16 4565 . . . . 4566 4567 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 % 4568@end group 4569@end smallexample 4570 4571@noindent 4572These two calculations get the same answer, but the first one is 4573much more efficient because it avoids the huge intermediate value 4574that arises in the second one. 4575 4576@cindex Fermat, primality test of 4577(@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat 4578says that 4579@texline @math{x^{n-1} \bmod n = 1} 4580@infoline @expr{x^(n-1) mod n = 1} 4581if @expr{n} is a prime number and @expr{x} is an integer less than 4582@expr{n}. If @expr{n} is @emph{not} a prime number, this will 4583@emph{not} be true for most values of @expr{x}. Thus we can test 4584informally if a number is prime by trying this formula for several 4585values of @expr{x}. Use this test to tell whether the following numbers 4586are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{}) 4587 4588It is possible to use HMS forms as parts of error forms, intervals, 4589modulo forms, or as the phase part of a polar complex number. 4590For example, the @code{calc-time} command pushes the current time 4591of day on the stack as an HMS/modulo form. 4592 4593@smallexample 4594@group 45951: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0" 4596 . . 4597 4598 x time @key{RET} n 4599@end group 4600@end smallexample 4601 4602@noindent 4603This calculation tells me it is six hours and 22 minutes until midnight. 4604 4605(@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year 4606is about 4607@texline @math{\pi \times 10^7} 4608@infoline @w{@expr{pi * 10^7}} 4609seconds. What time will it be that many seconds from right now? 4610@xref{Types Answer 11, 11}. (@bullet{}) 4611 4612(@bullet{}) @strong{Exercise 12.} You are preparing to order packaging 4613for the CD release of the Extended Disco Version of @emph{Abbey Road}. 4614You are told that the songs will actually be anywhere from 20 to 60 4615seconds longer than the originals. One CD can hold about 75 minutes 4616of music. Should you order single or double packages? 4617@xref{Types Answer 12, 12}. (@bullet{}) 4618 4619Another kind of data the Calculator can manipulate is numbers with 4620@dfn{units}. This isn't strictly a new data type; it's simply an 4621application of algebraic expressions, where we use variables with 4622suggestive names like @samp{cm} and @samp{in} to represent units 4623like centimeters and inches. 4624 4625@smallexample 4626@group 46271: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m 4628 . . . . 4629 4630 ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b 4631@end group 4632@end smallexample 4633 4634@noindent 4635We enter the quantity ``2 inches'' (actually an algebraic expression 4636which means two times the variable @samp{in}), then we convert it 4637first to centimeters, then to fathoms, then finally to ``base'' units, 4638which in this case means meters. 4639 4640@smallexample 4641@group 46421: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm 4643 . . . . 4644 4645 ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET} 4646 4647@end group 4648@end smallexample 4649@noindent 4650@smallexample 4651@group 46521: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2 4653 . . . 4654 4655 u s 2 ^ u c cgs 4656@end group 4657@end smallexample 4658 4659@noindent 4660Since units expressions are really just formulas, taking the square 4661root of @samp{acre} is undefined. After all, @code{acre} might be an 4662algebraic variable that you will someday assign a value. We use the 4663``units-simplify'' command to simplify the expression with variables 4664being interpreted as unit names. 4665 4666In the final step, we have converted not to a particular unit, but to a 4667units system. The ``cgs'' system uses centimeters instead of meters 4668as its standard unit of length. 4669 4670There is a wide variety of units defined in the Calculator. 4671 4672@smallexample 4673@group 46741: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c 4675 . . . . 4676 4677 ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET} 4678@end group 4679@end smallexample 4680 4681@noindent 4682We express a speed first in miles per hour, then in kilometers per 4683hour, then again using a slightly more explicit notation, then 4684finally in terms of fractions of the speed of light. 4685 4686Temperature conversions are a bit more tricky. There are two ways to 4687interpret ``20 degrees Fahrenheit''---it could mean an actual 4688temperature, or it could mean a change in temperature. For normal 4689units there is no difference, but temperature units have an offset 4690as well as a scale factor and so there must be two explicit commands 4691for them. 4692 4693@smallexample 4694@group 46951: 20 degF 1: 11.1111 degC 1: -6.666 degC 4696 . . . . 4697 4698 ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} 4699@end group 4700@end smallexample 4701 4702@noindent 4703First we convert a change of 20 degrees Fahrenheit into an equivalent 4704change in degrees Celsius (or Centigrade). Then, we convert the 4705absolute temperature 20 degrees Fahrenheit into Celsius. 4706 4707For simple unit conversions, you can put a plain number on the stack. 4708Then @kbd{u c} and @kbd{u t} will prompt for both old and new units. 4709When you use this method, you're responsible for remembering which 4710numbers are in which units: 4711 4712@smallexample 4713@group 47141: 55 1: 88.5139 1: 8.201407e-8 4715 . . . 4716 4717 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET} 4718@end group 4719@end smallexample 4720 4721To see a complete list of built-in units, type @kbd{u v}. Press 4722@w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking 4723at the units table. 4724 4725(@bullet{}) @strong{Exercise 13.} How many seconds are there really 4726in a year? @xref{Types Answer 13, 13}. (@bullet{}) 4727 4728@cindex Speed of light 4729(@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by 4730the speed of light (and of electricity, which is nearly as fast). 4731Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its 4732cabinet is one meter across. Is speed of light going to be a 4733significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{}) 4734 4735(@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about 4736five yards in an hour. He has obtained a supply of Power Pills; each 4737Power Pill he eats doubles his speed. How many Power Pills can he 4738swallow and still travel legally on most US highways? 4739@xref{Types Answer 15, 15}. (@bullet{}) 4740 4741@node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial 4742@section Algebra and Calculus Tutorial 4743 4744@noindent 4745This section shows how to use Calc's algebra facilities to solve 4746equations, do simple calculus problems, and manipulate algebraic 4747formulas. 4748 4749@menu 4750* Basic Algebra Tutorial:: 4751* Rewrites Tutorial:: 4752@end menu 4753 4754@node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial 4755@subsection Basic Algebra 4756 4757@noindent 4758If you enter a formula in Algebraic mode that refers to variables, 4759the formula itself is pushed onto the stack. You can manipulate 4760formulas as regular data objects. 4761 4762@smallexample 4763@group 47641: 2 x^2 - 6 1: 6 - 2 x^2 1: (3 x^2 + y) (6 - 2 x^2) 4765 . . . 4766 4767 ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} * 4768@end group 4769@end smallexample 4770 4771(@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and 4772@kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})? 4773Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{}) 4774 4775There are also commands for doing common algebraic operations on 4776formulas. Continuing with the formula from the last example, 4777 4778@smallexample 4779@group 47801: 18 x^2 - 6 x^4 + 6 y - 2 y x^2 1: (18 - 2 y) x^2 - 6 x^4 + 6 y 4781 . . 4782 4783 a x a c x @key{RET} 4784@end group 4785@end smallexample 4786 4787@noindent 4788First we ``expand'' using the distributive law, then we ``collect'' 4789terms involving like powers of @expr{x}. 4790 4791Let's find the value of this expression when @expr{x} is 2 and @expr{y} 4792is one-half. 4793 4794@smallexample 4795@group 47961: 17 x^2 - 6 x^4 + 3 1: -25 4797 . . 4798 4799 1:2 s l y @key{RET} 2 s l x @key{RET} 4800@end group 4801@end smallexample 4802 4803@noindent 4804The @kbd{s l} command means ``let''; it takes a number from the top of 4805the stack and temporarily assigns it as the value of the variable 4806you specify. It then evaluates (as if by the @kbd{=} key) the 4807next expression on the stack. After this command, the variable goes 4808back to its original value, if any. 4809 4810(An earlier exercise in this tutorial involved storing a value in the 4811variable @code{x}; if this value is still there, you will have to 4812unstore it with @kbd{s u x @key{RET}} before the above example will work 4813properly.) 4814 4815@cindex Maximum of a function using Calculus 4816Let's find the maximum value of our original expression when @expr{y} 4817is one-half and @expr{x} ranges over all possible values. We can 4818do this by taking the derivative with respect to @expr{x} and examining 4819values of @expr{x} for which the derivative is zero. If the second 4820derivative of the function at that value of @expr{x} is negative, 4821the function has a local maximum there. 4822 4823@smallexample 4824@group 48251: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3 4826 . . 4827 4828 U @key{DEL} s 1 a d x @key{RET} s 2 4829@end group 4830@end smallexample 4831 4832@noindent 4833Well, the derivative is clearly zero when @expr{x} is zero. To find 4834the other root(s), let's divide through by @expr{x} and then solve: 4835 4836@smallexample 4837@group 48381: (34 x - 24 x^3) / x 1: 34 - 24 x^2 4839 . . 4840 4841 ' x @key{RET} / a x 4842 4843@end group 4844@end smallexample 4845@noindent 4846@smallexample 4847@group 48481: 0.70588 x^2 = 1 1: x = 1.19023 4849 . . 4850 4851 0 a = s 3 a S x @key{RET} 4852@end group 4853@end smallexample 4854 4855@noindent 4856Now we compute the second derivative and plug in our values of @expr{x}: 4857 4858@smallexample 4859@group 48601: 1.19023 2: 1.19023 2: 1.19023 4861 . 1: 34 x - 24 x^3 1: 34 - 72 x^2 4862 . . 4863 4864 a . r 2 a d x @key{RET} s 4 4865@end group 4866@end smallexample 4867 4868@noindent 4869(The @kbd{a .} command extracts just the righthand side of an equation. 4870Another method would have been to use @kbd{v u} to unpack the equation 4871@w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}} 4872to delete the @samp{x}.) 4873 4874@smallexample 4875@group 48762: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34 48771: 1.19023 . 1: 0 . 4878 . . 4879 4880 @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET} 4881@end group 4882@end smallexample 4883 4884@noindent 4885The first of these second derivatives is negative, so we know the function 4886has a maximum value at @expr{x = 1.19023}. (The function also has a 4887local @emph{minimum} at @expr{x = 0}.) 4888 4889When we solved for @expr{x}, we got only one value even though 4890@expr{0.70588 x^2 = 1} is a quadratic equation that ought to have 4891two solutions. The reason is that @w{@kbd{a S}} normally returns a 4892single ``principal'' solution. If it needs to come up with an 4893arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}. 4894If it needs an arbitrary integer, it picks zero. We can get a full 4895solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}. 4896 4897@smallexample 4898@group 48991: 0.70588 x^2 = 1 1: x = 1.19023 s1 1: x = -1.19023 4900 . . . 4901 4902 r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET} 4903@end group 4904@end smallexample 4905 4906@noindent 4907Calc has invented the variable @samp{s1} to represent an unknown sign; 4908it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used 4909the ``let'' command to evaluate the expression when the sign is negative. 4910If we plugged this into our second derivative we would get the same, 4911negative, answer, so @expr{x = -1.19023} is also a maximum. 4912 4913To find the actual maximum value, we must plug our two values of @expr{x} 4914into the original formula. 4915 4916@smallexample 4917@group 49182: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3 49191: x = 1.19023 s1 . 4920 . 4921 4922 r 1 r 5 s l @key{RET} 4923@end group 4924@end smallexample 4925 4926@noindent 4927(Here we see another way to use @kbd{s l}; if its input is an equation 4928with a variable on the lefthand side, then @kbd{s l} treats the equation 4929like an assignment to that variable if you don't give a variable name.) 4930 4931It's clear that this will have the same value for either sign of 4932@code{s1}, but let's work it out anyway, just for the exercise: 4933 4934@smallexample 4935@group 49362: [-1, 1] 1: [15.04166, 15.04166] 49371: 24.08333 s1^2 ... . 4938 . 4939 4940 [ 1 n , 1 ] @key{TAB} V M $ @key{RET} 4941@end group 4942@end smallexample 4943 4944@noindent 4945Here we have used a vector mapping operation to evaluate the function 4946at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '} 4947except that it takes the formula from the top of the stack. The 4948formula is interpreted as a function to apply across the vector at the 4949next-to-top stack level. Since a formula on the stack can't contain 4950@samp{$} signs, Calc assumes the variables in the formula stand for 4951different arguments. It prompts you for an @dfn{argument list}, giving 4952the list of all variables in the formula in alphabetical order as the 4953default list. In this case the default is @samp{(s1)}, which is just 4954what we want so we simply press @key{RET} at the prompt. 4955 4956If there had been several different values, we could have used 4957@w{@kbd{V R X}} to find the global maximum. 4958 4959Calc has a built-in @kbd{a P} command that solves an equation using 4960@w{@kbd{H a S}} and returns a vector of all the solutions. It simply 4961automates the job we just did by hand. Applied to our original 4962cubic polynomial, it would produce the vector of solutions 4963@expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command 4964which finds a local maximum of a function. It uses a numerical search 4965method rather than examining the derivatives, and thus requires you 4966to provide some kind of initial guess to show it where to look.) 4967 4968(@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a 4969polynomial (such as the output of an @kbd{a P} command), what 4970sequence of commands would you use to reconstruct the original 4971polynomial? (The answer will be unique to within a constant 4972multiple; choose the solution where the leading coefficient is one.) 4973@xref{Algebra Answer 2, 2}. (@bullet{}) 4974 4975The @kbd{m s} command enables Symbolic mode, in which formulas 4976like @samp{sqrt(5)} that can't be evaluated exactly are left in 4977symbolic form rather than giving a floating-point approximate answer. 4978Fraction mode (@kbd{m f}) is also useful when doing algebra. 4979 4980@smallexample 4981@group 49822: 34 x - 24 x^3 2: 34 x - 24 x^3 49831: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0] 4984 . . 4985 4986 r 2 @key{RET} m s m f a P x @key{RET} 4987@end group 4988@end smallexample 4989 4990One more mode that makes reading formulas easier is Big mode. 4991 4992@smallexample 4993@group 4994 3 49952: 34 x - 24 x 4996 4997 ____ ____ 4998 V 51 V 51 49991: [-----, -----, 0] 5000 6 -6 5001 5002 . 5003 5004 d B 5005@end group 5006@end smallexample 5007 5008Here things like powers, square roots, and quotients and fractions 5009are displayed in a two-dimensional pictorial form. Calc has other 5010language modes as well, such as C mode, FORTRAN mode, @TeX{} mode 5011and @LaTeX{} mode. 5012 5013@smallexample 5014@group 50152: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3 50161: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/ 5017 . . 5018 5019 d C d F 5020 5021@end group 5022@end smallexample 5023@noindent 5024@smallexample 5025@group 50263: 34 x - 24 x^3 50272: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0] 50281: @{2 \over 3@} \sqrt@{5@} 5029 . 5030 5031 d T ' 2 \sqrt@{5@} \over 3 @key{RET} 5032@end group 5033@end smallexample 5034 5035@noindent 5036As you can see, language modes affect both entry and display of 5037formulas. They affect such things as the names used for built-in 5038functions, the set of arithmetic operators and their precedences, 5039and notations for vectors and matrices. 5040 5041Notice that @samp{sqrt(51)} may cause problems with older 5042implementations of C and FORTRAN, which would require something more 5043like @samp{sqrt(51.0)}. It is always wise to check over the formulas 5044produced by the various language modes to make sure they are fully 5045correct. 5046 5047Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You 5048may prefer to remain in Big mode, but all the examples in the tutorial 5049are shown in normal mode.) 5050 5051@cindex Area under a curve 5052What is the area under the portion of this curve from @expr{x = 1} to @expr{2}? 5053This is simply the integral of the function: 5054 5055@smallexample 5056@group 50571: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x 5058 . . 5059 5060 r 1 a i x 5061@end group 5062@end smallexample 5063 5064@noindent 5065We want to evaluate this at our two values for @expr{x} and subtract. 5066One way to do it is again with vector mapping and reduction: 5067 5068@smallexample 5069@group 50702: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666 50711: 5.6666 x^3 ... . . 5072 5073 [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R - 5074@end group 5075@end smallexample 5076 5077(@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y} 5078of 5079@texline @math{x \sin \pi x} 5080@infoline @w{@expr{x sin(pi x)}} 5081(where the sine is calculated in radians). Find the values of the 5082integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3, 50833}. (@bullet{}) 5084 5085Calc's integrator can do many simple integrals symbolically, but many 5086others are beyond its capabilities. Suppose we wish to find the area 5087under the curve 5088@texline @math{\sin x \ln x} 5089@infoline @expr{sin(x) ln(x)} 5090over the same range of @expr{x}. If you entered this formula and typed 5091@kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a 5092long time but would be unable to find a solution. In fact, there is no 5093closed-form solution to this integral. Now what do we do? 5094 5095@cindex Integration, numerical 5096@cindex Numerical integration 5097One approach would be to do the integral numerically. It is not hard 5098to do this by hand using vector mapping and reduction. It is rather 5099slow, though, since the sine and logarithm functions take a long time. 5100We can save some time by reducing the working precision. 5101 5102@smallexample 5103@group 51043: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9] 51052: 1 . 51061: 0.1 5107 . 5108 5109 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x 5110@end group 5111@end smallexample 5112 5113@noindent 5114(Note that we have used the extended version of @kbd{v x}; we could 5115also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.) 5116 5117@smallexample 5118@group 51192: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ] 51201: ln(x) sin(x) . 5121 . 5122 5123 ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET} 5124 5125@end group 5126@end smallexample 5127@noindent 5128@smallexample 5129@group 51301: 3.4195 0.34195 5131 . . 5132 5133 V R + 0.1 * 5134@end group 5135@end smallexample 5136 5137@noindent 5138(If you got wildly different results, did you remember to switch 5139to Radians mode?) 5140 5141Here we have divided the curve into ten segments of equal width; 5142approximating these segments as rectangular boxes (i.e., assuming 5143the curve is nearly flat at that resolution), we compute the areas 5144of the boxes (height times width), then sum the areas. (It is 5145faster to sum first, then multiply by the width, since the width 5146is the same for every box.) 5147 5148The true value of this integral turns out to be about 0.374, so 5149we're not doing too well. Let's try another approach. 5150 5151@smallexample 5152@group 51531: ln(x) sin(x) 1: 0.84147 x + 0.11957 (x - 1)^2 - ... 5154 . . 5155 5156 r 1 a t x=1 @key{RET} 4 @key{RET} 5157@end group 5158@end smallexample 5159 5160@noindent 5161Here we have computed the Taylor series expansion of the function 5162about the point @expr{x=1}. We can now integrate this polynomial 5163approximation, since polynomials are easy to integrate. 5164 5165@smallexample 5166@group 51671: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761 5168 . . . 5169 5170 a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R - 5171@end group 5172@end smallexample 5173 5174@noindent 5175Better! By increasing the precision and/or asking for more terms 5176in the Taylor series, we can get a result as accurate as we like. 5177(Taylor series converge better away from singularities in the 5178function such as the one at @code{ln(0)}, so it would also help to 5179expand the series about the points @expr{x=2} or @expr{x=1.5} instead 5180of @expr{x=1}.) 5181 5182@cindex Simpson's rule 5183@cindex Integration by Simpson's rule 5184(@bullet{}) @strong{Exercise 4.} Our first method approximated the 5185curve by stairsteps of width 0.1; the total area was then the sum 5186of the areas of the rectangles under these stairsteps. Our second 5187method approximated the function by a polynomial, which turned out 5188to be a better approximation than stairsteps. A third method is 5189@dfn{Simpson's rule}, which is like the stairstep method except 5190that the steps are not required to be flat. Simpson's rule boils 5191down to the formula, 5192 5193@ifnottex 5194@example 5195(h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ... 5196 + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h)) 5197@end example 5198@end ifnottex 5199@tex 5200\beforedisplay 5201$$ \displaylines{ 5202 \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots 5203 \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad 5204} $$ 5205\afterdisplay 5206@end tex 5207 5208@noindent 5209where @expr{n} (which must be even) is the number of slices and @expr{h} 5210is the width of each slice. These are 10 and 0.1 in our example. 5211For reference, here is the corresponding formula for the stairstep 5212method: 5213 5214@ifnottex 5215@example 5216h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ... 5217 + f(a+(n-2)*h) + f(a+(n-1)*h)) 5218@end example 5219@end ifnottex 5220@tex 5221\beforedisplay 5222$$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots 5223 + f(a+(n-2)h) + f(a+(n-1)h)) $$ 5224\afterdisplay 5225@end tex 5226 5227Compute the integral from 1 to 2 of 5228@texline @math{\sin x \ln x} 5229@infoline @expr{sin(x) ln(x)} 5230using Simpson's rule with 10 slices. 5231@xref{Algebra Answer 4, 4}. (@bullet{}) 5232 5233Calc has a built-in @kbd{a I} command for doing numerical integration. 5234It uses @dfn{Romberg's method}, which is a more sophisticated cousin 5235of Simpson's rule. In particular, it knows how to keep refining the 5236result until the current precision is satisfied. 5237 5238@c [fix-ref Selecting Sub-Formulas] 5239Aside from the commands we've seen so far, Calc also provides a 5240large set of commands for operating on parts of formulas. You 5241indicate the desired sub-formula by placing the cursor on any part 5242of the formula before giving a @dfn{selection} command. Selections won't 5243be covered in the tutorial; @pxref{Selecting Subformulas}, for 5244details and examples. 5245 5246@c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1) 5247@c to 2^((n-1)*(r-1)). 5248 5249@node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial 5250@subsection Rewrite Rules 5251 5252@noindent 5253No matter how many built-in commands Calc provided for doing algebra, 5254there would always be something you wanted to do that Calc didn't have 5255in its repertoire. So Calc also provides a @dfn{rewrite rule} system 5256that you can use to define your own algebraic manipulations. 5257 5258Suppose we want to simplify this trigonometric formula: 5259 5260@smallexample 5261@group 52621: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2 5263 . 5264 5265 ' 2sec(x)^2/tan(x)^2 - 2/tan(x)^2 @key{RET} s 1 5266@end group 5267@end smallexample 5268 5269@noindent 5270If we were simplifying this by hand, we'd probably combine over the common 5271denominator. The @kbd{a n} algebra command will do this, but we'll do 5272it with a rewrite rule just for practice. 5273 5274Rewrite rules are written with the @samp{:=} symbol. 5275 5276@smallexample 5277@group 52781: (2 sec(x)^2 - 2) / tan(x)^2 5279 . 5280 5281 a r a/x + b/x := (a+b)/x @key{RET} 5282@end group 5283@end smallexample 5284 5285@noindent 5286(The ``assignment operator'' @samp{:=} has several uses in Calc. All 5287by itself the formula @samp{a/x + b/x := (a+b)/x} doesn't do anything, 5288but when it is given to the @kbd{a r} command, that command interprets 5289it as a rewrite rule.) 5290 5291The lefthand side, @samp{a/x + b/x}, is called the @dfn{pattern} of the 5292rewrite rule. Calc searches the formula on the stack for parts that 5293match the pattern. Variables in a rewrite pattern are called 5294@dfn{meta-variables}, and when matching the pattern each meta-variable 5295can match any sub-formula. Here, the meta-variable @samp{a} matched 5296the expression @samp{2 sec(x)^2}, the meta-variable @samp{b} matched 5297the constant @samp{-2} and the meta-variable @samp{x} matched 5298the expression @samp{tan(x)^2}. 5299 5300This rule points out several interesting features of rewrite patterns. 5301First, if a meta-variable appears several times in a pattern, it must 5302match the same thing everywhere. This rule detects common denominators 5303because the same meta-variable @samp{x} is used in both of the 5304denominators. 5305 5306Second, meta-variable names are independent from variables in the 5307target formula. Notice that the meta-variable @samp{x} here matches 5308the subformula @samp{tan(x)^2}; Calc never confuses the two meanings of 5309@samp{x}. 5310 5311And third, rewrite patterns know a little bit about the algebraic 5312properties of formulas. The pattern called for a sum of two quotients; 5313Calc was able to match a difference of two quotients by matching 5314@samp{a = 2 sec(x)^2}, @samp{b = -2}, and @samp{x = tan(x)^2}. 5315 5316When the pattern part of a rewrite rule matches a part of the formula, 5317that part is replaced by the righthand side with all the meta-variables 5318substituted with the things they matched. So the result is 5319@samp{(2 sec(x)^2 - 2) / tan(x)^2}. 5320 5321@c [fix-ref Algebraic Properties of Rewrite Rules] 5322We could just as easily have written @samp{a/x - b/x := (a-b)/x} for 5323the rule. It would have worked just the same in all cases. (If we 5324really wanted the rule to apply only to @samp{+} or only to @samp{-}, 5325we could have used the @code{plain} symbol. @xref{Algebraic Properties 5326of Rewrite Rules}, for some examples of this.) 5327 5328One more rewrite will complete the job. We want to use the identity 5329@samp{tan(x)^2 + 1 = sec(x)^2}, but of course we must first rearrange 5330the identity in a way that matches our formula. The obvious rule 5331would be @samp{@w{2 sec(x)^2 - 2} := 2 tan(x)^2}, but a little thought shows 5332that the rule @samp{sec(x)^2 := 1 + tan(x)^2} will also work. The 5333latter rule has a more general pattern so it will work in many other 5334situations, too. 5335 5336@smallexample 5337@group 53381: 2 5339 . 5340 5341 a r sec(x)^2 := 1 + tan(x)^2 @key{RET} 5342@end group 5343@end smallexample 5344 5345You may ask, what's the point of using the most general rule if you 5346have to type it in every time anyway? The answer is that Calc allows 5347you to store a rewrite rule in a variable, then give the variable 5348name in the @kbd{a r} command. In fact, this is the preferred way to 5349use rewrites. For one, if you need a rule once you'll most likely 5350need it again later. Also, if the rule doesn't work quite right you 5351can simply Undo, edit the variable, and run the rule again without 5352having to retype it. 5353 5354@smallexample 5355@group 5356' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET} 5357' sec(x)^2 := 1 + tan(x)^2 @key{RET} s t secsqr @key{RET} 5358 53591: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2 1: 2 5360 . . 5361 5362 r 1 a r merge @key{RET} a r secsqr @key{RET} 5363@end group 5364@end smallexample 5365 5366To edit a variable, type @kbd{s e} and the variable name, use regular 5367Emacs editing commands as necessary, then type @kbd{C-c C-c} to store 5368the edited value back into the variable. 5369You can also use @w{@kbd{s e}} to create a new variable if you wish. 5370 5371Notice that the first time you use each rule, Calc puts up a ``compiling'' 5372message briefly. The pattern matcher converts rules into a special 5373optimized pattern-matching language rather than using them directly. 5374This allows @kbd{a r} to apply even rather complicated rules very 5375efficiently. If the rule is stored in a variable, Calc compiles it 5376only once and stores the compiled form along with the variable. That's 5377another good reason to store your rules in variables rather than 5378entering them on the fly. 5379 5380(@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic 5381mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}. 5382Using a rewrite rule, simplify this formula by multiplying the top and 5383bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have 5384to be expanded by the distributive law; do this with another 5385rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{}) 5386 5387The @kbd{a r} command can also accept a vector of rewrite rules, or 5388a variable containing a vector of rules. 5389 5390@smallexample 5391@group 53921: [merge, secsqr] 1: [a/x + b/x := (a + b)/x, ... ] 5393 . . 5394 5395 ' [merge,sinsqr] @key{RET} = 5396 5397@end group 5398@end smallexample 5399@noindent 5400@smallexample 5401@group 54021: 2 sec(x)^2 / tan(x)^2 - 2 / tan(x)^2 1: 2 5403 . . 5404 5405 s t trig @key{RET} r 1 a r trig @key{RET} 5406@end group 5407@end smallexample 5408 5409@c [fix-ref Nested Formulas with Rewrite Rules] 5410Calc tries all the rules you give against all parts of the formula, 5411repeating until no further change is possible. (The exact order in 5412which things are tried is rather complex, but for simple rules like 5413the ones we've used here the order doesn't really matter. 5414@xref{Nested Formulas with Rewrite Rules}.) 5415 5416Calc actually repeats only up to 100 times, just in case your rule set 5417has gotten into an infinite loop. You can give a numeric prefix argument 5418to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does 5419only one rewrite at a time. 5420 5421@smallexample 5422@group 54231: (2 sec(x)^2 - 2) / tan(x)^2 1: 2 5424 . . 5425 5426 r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET} 5427@end group 5428@end smallexample 5429 5430You can type @kbd{M-0 a r} if you want no limit at all on the number 5431of rewrites that occur. 5432 5433Rewrite rules can also be @dfn{conditional}. Simply follow the rule 5434with a @samp{::} symbol and the desired condition. For example, 5435 5436@smallexample 5437@group 54381: sin(x + 2 pi) + sin(x + 3 pi) + sin(x + 4 pi) 5439 . 5440 5441 ' sin(x+2pi) + sin(x+3pi) + sin(x+4pi) @key{RET} 5442 5443@end group 5444@end smallexample 5445@noindent 5446@smallexample 5447@group 54481: sin(x + 3 pi) + 2 sin(x) 5449 . 5450 5451 a r sin(a + k pi) := sin(a) :: k % 2 = 0 @key{RET} 5452@end group 5453@end smallexample 5454 5455@noindent 5456(Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2, 5457which will be zero only when @samp{k} is an even integer.) 5458 5459An interesting point is that the variable @samp{pi} was matched 5460literally rather than acting as a meta-variable. 5461This is because it is a special-constant variable. The special 5462constants @samp{e}, @samp{i}, @samp{phi}, and so on also match literally. 5463A common error with rewrite 5464rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting 5465to match any @samp{f} with five arguments but in fact matching 5466only when the fifth argument is literally @samp{e}! 5467 5468@cindex Fibonacci numbers 5469@ignore 5470@starindex 5471@end ignore 5472@tindex fib 5473Rewrite rules provide an interesting way to define your own functions. 5474Suppose we want to define @samp{fib(n)} to produce the @var{n}th 5475Fibonacci number. The first two Fibonacci numbers are each 1; 5476later numbers are formed by summing the two preceding numbers in 5477the sequence. This is easy to express in a set of three rules: 5478 5479@smallexample 5480@group 5481' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib 5482 54831: fib(7) 1: 13 5484 . . 5485 5486 ' fib(7) @key{RET} a r fib @key{RET} 5487@end group 5488@end smallexample 5489 5490One thing that is guaranteed about the order that rewrites are tried 5491is that, for any given subformula, earlier rules in the rule set will 5492be tried for that subformula before later ones. So even though the 5493first and third rules both match @samp{fib(1)}, we know the first will 5494be used preferentially. 5495 5496This rule set has one dangerous bug: Suppose we apply it to the 5497formula @samp{fib(x)}? (Don't actually try this.) The third rule 5498will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}. 5499Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) + 5500fib(x-4)}, and so on, expanding forever. What we really want is to apply 5501the third rule only when @samp{n} is an integer greater than two. Type 5502@w{@kbd{s e fib @key{RET}}}, then edit the third rule to: 5503 5504@smallexample 5505fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 5506@end smallexample 5507 5508@noindent 5509Now: 5510 5511@smallexample 5512@group 55131: fib(6) + fib(x) + fib(0) 1: fib(x) + fib(0) + 8 5514 . . 5515 5516 ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET} 5517@end group 5518@end smallexample 5519 5520@noindent 5521We've created a new function, @code{fib}, and a new command, 5522@w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in 5523this formula.'' To make things easier still, we can tell Calc to 5524apply these rules automatically by storing them in the special 5525variable @code{EvalRules}. 5526 5527@smallexample 5528@group 55291: [fib(1) := ...] . 1: [8, 13] 5530 . . 5531 5532 s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET} 5533@end group 5534@end smallexample 5535 5536It turns out that this rule set has the problem that it does far 5537more work than it needs to when @samp{n} is large. Consider the 5538first few steps of the computation of @samp{fib(6)}: 5539 5540@smallexample 5541@group 5542fib(6) = 5543fib(5) + fib(4) = 5544fib(4) + fib(3) + fib(3) + fib(2) = 5545fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ... 5546@end group 5547@end smallexample 5548 5549@noindent 5550Note that @samp{fib(3)} appears three times here. Unless Calc's 5551algebraic simplifier notices the multiple @samp{fib(3)}s and combines 5552them (and, as it happens, it doesn't), this rule set does lots of 5553needless recomputation. To cure the problem, type @code{s e EvalRules} 5554to edit the rules (or just @kbd{s E}, a shorthand command for editing 5555@code{EvalRules}) and add another condition: 5556 5557@smallexample 5558fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember 5559@end smallexample 5560 5561@noindent 5562If a @samp{:: remember} condition appears anywhere in a rule, then if 5563that rule succeeds Calc will add another rule that describes that match 5564to the front of the rule set. (Remembering works in any rule set, but 5565for technical reasons it is most effective in @code{EvalRules}.) For 5566example, if the rule rewrites @samp{fib(7)} to something that evaluates 5567to 13, then the rule @samp{fib(7) := 13} will be added to the rule set. 5568 5569Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then 5570type @kbd{s E} again to see what has happened to the rule set. 5571 5572With the @code{remember} feature, our rule set can now compute 5573@samp{fib(@var{n})} in just @var{n} steps. In the process it builds 5574up a table of all Fibonacci numbers up to @var{n}. After we have 5575computed the result for a particular @var{n}, we can get it back 5576(and the results for all smaller @var{n}) later in just one step. 5577 5578All Calc operations will run somewhat slower whenever @code{EvalRules} 5579contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to 5580un-store the variable. 5581 5582(@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate 5583a problem to reduce the amount of recursion necessary to solve it. 5584Create a rule that, in about @var{n} simple steps and without recourse 5585to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with 5586@samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the 5587@var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is 5588rather clunky to use, so add a couple more rules to make the ``user 5589interface'' the same as for our first version: enter @samp{fib(@var{n})}, 5590get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{}) 5591 5592There are many more things that rewrites can do. For example, there 5593are @samp{&&&} and @samp{|||} pattern operators that create ``and'' 5594and ``or'' combinations of rules. As one really simple example, we 5595could combine our first two Fibonacci rules thusly: 5596 5597@example 5598[fib(1 ||| 2) := 1, fib(n) := ... ] 5599@end example 5600 5601@noindent 5602That means ``@code{fib} of something matching either 1 or 2 rewrites 5603to 1.'' 5604 5605You can also make meta-variables optional by enclosing them in @code{opt}. 5606For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not 5607@samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x} 5608matches all of these forms, filling in a default of zero for @samp{a} 5609and one for @samp{b}. 5610 5611(@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x} 5612on the stack and tried to use the rule 5613@samp{opt(a) + opt(b) x := f(a, b, x)}. What happened? 5614@xref{Rewrites Answer 3, 3}. (@bullet{}) 5615 5616(@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a}, 5617divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}. 5618Now repeat this step over and over. A famous unproved conjecture 5619is that for any starting @expr{a}, the sequence always eventually 5620reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of 5621rules that convert this into @samp{seq(1, @var{n})} where @var{n} 5622is the number of steps it took the sequence to reach the value 1. 5623Now enhance the rules to accept @samp{seq(@var{a})} as a starting 5624configuration, and to stop with just the number @var{n} by itself. 5625Now make the result be a vector of values in the sequence, from @var{a} 5626to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x} 5627and @var{y}.) For example, rewriting @samp{seq(6)} should yield the 5628vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. 5629@xref{Rewrites Answer 4, 4}. (@bullet{}) 5630 5631(@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function 5632@samp{nterms(@var{x})} that returns the number of terms in the sum 5633@var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes 5634is one or more non-sum terms separated by @samp{+} or @samp{-} signs, 5635so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.) 5636@xref{Rewrites Answer 5, 5}. (@bullet{}) 5637 5638(@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an 5639infinite series that exactly equals the value of that function at 5640values of @expr{x} near zero. 5641 5642@ifnottex 5643@example 5644cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... 5645@end example 5646@end ifnottex 5647@tex 5648\beforedisplay 5649$$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$ 5650\afterdisplay 5651@end tex 5652 5653The @kbd{a t} command produces a @dfn{truncated Taylor series} which 5654is obtained by dropping all the terms higher than, say, @expr{x^2}. 5655Calc represents the truncated Taylor series as a polynomial in @expr{x}. 5656Mathematicians often write a truncated series using a ``big-O'' notation 5657that records what was the lowest term that was truncated. 5658 5659@ifnottex 5660@example 5661cos(x) = 1 - x^2 / 2! + O(x^3) 5662@end example 5663@end ifnottex 5664@tex 5665\beforedisplay 5666$$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$ 5667\afterdisplay 5668@end tex 5669 5670@noindent 5671The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small 5672if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.'' 5673 5674The exercise is to create rewrite rules that simplify sums and products of 5675power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}. 5676For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)} 5677on the stack, we want to be able to type @kbd{*} and get the result 5678@samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are 5679rearranged. (This one is rather tricky; the solution at the end of 5680this chapter uses 6 rewrite rules. Hint: The @samp{constant(x)} 5681condition tests whether @samp{x} is a number.) @xref{Rewrites Answer 56826, 6}. (@bullet{}) 5683 5684Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}. 5685What happens? (Be sure to remove this rule afterward, or you might get 5686a nasty surprise when you use Calc to balance your checkbook!) 5687 5688@xref{Rewrite Rules}, for the whole story on rewrite rules. 5689 5690@node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial 5691@section Programming Tutorial 5692 5693@noindent 5694The Calculator is written entirely in Emacs Lisp, a highly extensible 5695language. If you know Lisp, you can program the Calculator to do 5696anything you like. Rewrite rules also work as a powerful programming 5697system. But Lisp and rewrite rules take a while to master, and often 5698all you want to do is define a new function or repeat a command a few 5699times. Calc has features that allow you to do these things easily. 5700 5701One very limited form of programming is defining your own functions. 5702Calc's @kbd{Z F} command allows you to define a function name and 5703key sequence to correspond to any formula. Programming commands use 5704the shift-@kbd{Z} prefix; the user commands they create use the lower 5705case @kbd{z} prefix. 5706 5707@smallexample 5708@group 57091: x + x^2 / 2 + x^3 / 6 + 1 1: x + x^2 / 2 + x^3 / 6 + 1 5710 . . 5711 5712 ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y 5713@end group 5714@end smallexample 5715 5716This polynomial is a Taylor series approximation to @samp{exp(x)}. 5717The @kbd{Z F} command asks a number of questions. The above answers 5718say that the key sequence for our function should be @kbd{z e}; the 5719@kbd{M-x} equivalent should be @code{calc-myexp}; the name of the 5720function in algebraic formulas should also be @code{myexp}; the 5721default argument list @samp{(x)} is acceptable; and finally @kbd{y} 5722answers the question ``leave it in symbolic form for non-constant 5723arguments?'' 5724 5725@smallexample 5726@group 57271: 1.3495 2: 1.3495 3: 1.3495 5728 . 1: 1.34986 2: 1.34986 5729 . 1: myexp(a + 1) 5730 . 5731 5732 .3 z e .3 E ' a+1 @key{RET} z e 5733@end group 5734@end smallexample 5735 5736@noindent 5737First we call our new @code{exp} approximation with 0.3 as an 5738argument, and compare it with the true @code{exp} function. Then 5739we note that, as requested, if we try to give @kbd{z e} an 5740argument that isn't a plain number, it leaves the @code{myexp} 5741function call in symbolic form. If we had answered @kbd{n} to the 5742final question, @samp{myexp(a + 1)} would have evaluated by plugging 5743in @samp{a + 1} for @samp{x} in the defining formula. 5744 5745@cindex Sine integral Si(x) 5746@ignore 5747@starindex 5748@end ignore 5749@tindex Si 5750(@bullet{}) @strong{Exercise 1.} The ``sine integral'' function 5751@texline @math{{\rm Si}(x)} 5752@infoline @expr{Si(x)} 5753is defined as the integral of @samp{sin(t)/t} for 5754@expr{t = 0} to @expr{x} in radians. (It was invented because this 5755integral has no solution in terms of basic functions; if you give it 5756to Calc's @kbd{a i} command, it will ponder it for a long time and then 5757give up.) We can use the numerical integration command, however, 5758which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)} 5759with any integrand @samp{f(t)}. Define a @kbd{z s} command and 5760@code{Si} function that implement this. You will need to edit the 5761default argument list a bit. As a test, @samp{Si(1)} should return 57620.946083. (If you don't get this answer, you might want to check that 5763Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if 5764you reduce the precision to, say, six digits beforehand.) 5765@xref{Programming Answer 1, 1}. (@bullet{}) 5766 5767The simplest way to do real ``programming'' of Emacs is to define a 5768@dfn{keyboard macro}. A keyboard macro is simply a sequence of 5769keystrokes which Emacs has stored away and can play back on demand. 5770For example, if you find yourself typing @kbd{H a S x @key{RET}} often, 5771you may wish to program a keyboard macro to type this for you. 5772 5773@smallexample 5774@group 57751: y = sqrt(x) 1: x = y^2 5776 . . 5777 5778 ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x ) 5779 57801: y = cos(x) 1: x = s1 arccos(y) + 2 n1 pi 5781 . . 5782 5783 ' y=cos(x) @key{RET} X 5784@end group 5785@end smallexample 5786 5787@noindent 5788When you type @kbd{C-x (}, Emacs begins recording. But it is also 5789still ready to execute your keystrokes, so you're really ``training'' 5790Emacs by walking it through the procedure once. When you type 5791@w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to 5792re-execute the same keystrokes. 5793 5794You can give a name to your macro by typing @kbd{Z K}. 5795 5796@smallexample 5797@group 57981: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y)) 5799 . . 5800 5801 Z K x @key{RET} ' y=x^4 @key{RET} z x 5802@end group 5803@end smallexample 5804 5805@noindent 5806Notice that we use shift-@kbd{Z} to define the command, and lower-case 5807@kbd{z} to call it up. 5808 5809Keyboard macros can call other macros. 5810 5811@smallexample 5812@group 58131: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y 5814 . . . . 5815 5816 ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X 5817@end group 5818@end smallexample 5819 5820(@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate 5821the item in level 3 of the stack, without disturbing the rest of 5822the stack. @xref{Programming Answer 2, 2}. (@bullet{}) 5823 5824(@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute 5825the following functions: 5826 5827@enumerate 5828@item 5829Compute 5830@texline @math{\displaystyle{\sin x \over x}}, 5831@infoline @expr{sin(x) / x}, 5832where @expr{x} is the number on the top of the stack. 5833 5834@item 5835Compute the base-@expr{b} logarithm, just like the @kbd{B} key except 5836the arguments are taken in the opposite order. 5837 5838@item 5839Produce a vector of integers from 1 to the integer on the top of 5840the stack. 5841@end enumerate 5842@noindent 5843@xref{Programming Answer 3, 3}. (@bullet{}) 5844 5845(@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute 5846the average (mean) value of a list of numbers. 5847@xref{Programming Answer 4, 4}. (@bullet{}) 5848 5849In many programs, some of the steps must execute several times. 5850Calc has @dfn{looping} commands that allow this. Loops are useful 5851inside keyboard macros, but actually work at any time. 5852 5853@smallexample 5854@group 58551: x^6 2: x^6 1: 360 x^2 5856 . 1: 4 . 5857 . 5858 5859 ' x^6 @key{RET} 4 Z < a d x @key{RET} Z > 5860@end group 5861@end smallexample 5862 5863@noindent 5864Here we have computed the fourth derivative of @expr{x^6} by 5865enclosing a derivative command in a ``repeat loop'' structure. 5866This structure pops a repeat count from the stack, then 5867executes the body of the loop that many times. 5868 5869If you make a mistake while entering the body of the loop, 5870type @w{@kbd{Z C-g}} to cancel the loop command. 5871 5872@cindex Fibonacci numbers 5873Here's another example: 5874 5875@smallexample 5876@group 58773: 1 2: 10946 58782: 1 1: 17711 58791: 20 . 5880 . 5881 58821 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z > 5883@end group 5884@end smallexample 5885 5886@noindent 5887The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci 5888numbers, respectively. (To see what's going on, try a few repetitions 5889of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD} 5890key if you have one, makes a copy of the number in level 2.) 5891 5892@cindex Golden ratio 5893@cindex Phi, golden ratio 5894A fascinating property of the Fibonacci numbers is that the @expr{n}th 5895Fibonacci number can be found directly by computing 5896@texline @math{\phi^n / \sqrt{5}} 5897@infoline @expr{phi^n / sqrt(5)} 5898and then rounding to the nearest integer, where 5899@texline @math{\phi} (``phi''), 5900@infoline @expr{phi}, 5901the ``golden ratio,'' is 5902@texline @math{(1 + \sqrt{5}) / 2}. 5903@infoline @expr{(1 + sqrt(5)) / 2}. 5904(For convenience, this constant is available from the @code{phi} 5905variable, or the @kbd{I H P} command.) 5906 5907@smallexample 5908@group 59091: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946 5910 . . . . 5911 5912 I H P 21 ^ 5 Q / R 5913@end group 5914@end smallexample 5915 5916@cindex Continued fractions 5917(@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction} 5918representation of 5919@texline @math{\phi} 5920@infoline @expr{phi} 5921is 5922@texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}. 5923@infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}. 5924We can compute an approximate value by carrying this however far 5925and then replacing the innermost 5926@texline @math{1/( \ldots )} 5927@infoline @expr{1/( ...@: )} 5928by 1. Approximate 5929@texline @math{\phi} 5930@infoline @expr{phi} 5931using a twenty-term continued fraction. 5932@xref{Programming Answer 5, 5}. (@bullet{}) 5933 5934(@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for 5935Fibonacci numbers can be expressed in terms of matrices. Given a 5936vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this 5937vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and 5938@expr{c} are three successive Fibonacci numbers. Now write a program 5939that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number 5940using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{}) 5941 5942@cindex Harmonic numbers 5943A more sophisticated kind of loop is the @dfn{for} loop. Suppose 5944we wish to compute the 20th ``harmonic'' number, which is equal to 5945the sum of the reciprocals of the integers from 1 to 20. 5946 5947@smallexample 5948@group 59493: 0 1: 3.597739 59502: 1 . 59511: 20 5952 . 5953 59540 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z ) 5955@end group 5956@end smallexample 5957 5958@noindent 5959The ``for'' loop pops two numbers, the lower and upper limits, then 5960repeats the body of the loop as an internal counter increases from 5961the lower limit to the upper one. Just before executing the loop 5962body, it pushes the current loop counter. When the loop body 5963finishes, it pops the ``step,'' i.e., the amount by which to 5964increment the loop counter. As you can see, our loop always 5965uses a step of one. 5966 5967This harmonic number function uses the stack to hold the running 5968total as well as for the various loop housekeeping functions. If 5969you find this disorienting, you can sum in a variable instead: 5970 5971@smallexample 5972@group 59731: 0 2: 1 . 1: 3.597739 5974 . 1: 20 . 5975 . 5976 5977 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7 5978@end group 5979@end smallexample 5980 5981@noindent 5982The @kbd{s +} command adds the top-of-stack into the value in a 5983variable (and removes that value from the stack). 5984 5985It's worth noting that many jobs that call for a ``for'' loop can 5986also be done more easily by Calc's high-level operations. Two 5987other ways to compute harmonic numbers are to use vector mapping 5988and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}), 5989or to use the summation command @kbd{a +}. Both of these are 5990probably easier than using loops. However, there are some 5991situations where loops really are the way to go: 5992 5993(@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first 5994harmonic number which is greater than 4.0. 5995@xref{Programming Answer 7, 7}. (@bullet{}) 5996 5997Of course, if we're going to be using variables in our programs, 5998we have to worry about the programs clobbering values that the 5999caller was keeping in those same variables. This is easy to 6000fix, though: 6001 6002@smallexample 6003@group 6004 . 1: 0.6667 1: 0.6667 3: 0.6667 6005 . . 2: 3.597739 6006 1: 0.6667 6007 . 6008 6009 Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET} 6010@end group 6011@end smallexample 6012 6013@noindent 6014When we type @kbd{Z `} (that's a grave accent), Calc saves 6015its mode settings and the contents of the ten ``quick variables'' 6016for later reference. When we type @kbd{Z '} (that's an apostrophe 6017now), Calc restores those saved values. Thus the @kbd{p 4} and 6018@kbd{s 7} commands have no effect outside this sequence. Wrapping 6019this around the body of a keyboard macro ensures that it doesn't 6020interfere with what the user of the macro was doing. Notice that 6021the contents of the stack, and the values of named variables, 6022survive past the @kbd{Z '} command. 6023 6024@cindex Bernoulli numbers, approximate 6025The @dfn{Bernoulli numbers} are a sequence with the interesting 6026property that all of the odd Bernoulli numbers are zero, and the 6027even ones, while difficult to compute, can be roughly approximated 6028by the formula 6029@texline @math{\displaystyle{2 n! \over (2 \pi)^n}}. 6030@infoline @expr{2 n!@: / (2 pi)^n}. 6031Let's write a keyboard macro to compute (approximate) Bernoulli numbers. 6032(Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but 6033this command is very slow for large @expr{n} since the higher Bernoulli 6034numbers are very large fractions.) 6035 6036@smallexample 6037@group 60381: 10 1: 0.0756823 6039 . . 6040 6041 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x ) 6042@end group 6043@end smallexample 6044 6045@noindent 6046You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and 6047@kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if'' 6048command. For the purposes of @w{@kbd{Z [}}, the condition is ``true'' 6049if the value it pops from the stack is a nonzero number, or ``false'' 6050if it pops zero or something that is not a number (like a formula). 6051Here we take our integer argument modulo 2; this will be nonzero 6052if we're asking for an odd Bernoulli number. 6053 6054The actual tenth Bernoulli number is @expr{5/66}. 6055 6056@smallexample 6057@group 60583: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659 60592: 5:66 . . . . 60601: 0.0757575 6061 . 6062 606310 k b @key{RET} c f M-0 @key{DEL} 11 X @key{DEL} 12 X @key{DEL} 13 X @key{DEL} 14 X 6064@end group 6065@end smallexample 6066 6067Just to exercise loops a bit more, let's compute a table of even 6068Bernoulli numbers. 6069 6070@smallexample 6071@group 60723: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...] 60732: 2 . 60741: 30 6075 . 6076 6077 [ ] 2 @key{RET} 30 Z ( X | 2 Z ) 6078@end group 6079@end smallexample 6080 6081@noindent 6082The vertical-bar @kbd{|} is the vector-concatenation command. When 6083we execute it, the list we are building will be in stack level 2 6084(initially this is an empty list), and the next Bernoulli number 6085will be in level 1. The effect is to append the Bernoulli number 6086onto the end of the list. (To create a table of exact fractional 6087Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above 6088sequence of keystrokes.) 6089 6090With loops and conditionals, you can program essentially anything 6091in Calc. One other command that makes looping easier is @kbd{Z /}, 6092which takes a condition from the stack and breaks out of the enclosing 6093loop if the condition is true (non-zero). You can use this to make 6094``while'' and ``until'' style loops. 6095 6096If you make a mistake when entering a keyboard macro, you can edit 6097it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}. 6098One technique is to enter a throwaway dummy definition for the macro, 6099then enter the real one in the edit command. 6100 6101@smallexample 6102@group 61031: 3 1: 3 Calc Macro Edit Mode. 6104 . . Original keys: 1 <return> 2 + 6105 6106 1 ;; calc digits 6107 RET ;; calc-enter 6108 2 ;; calc digits 6109 + ;; calc-plus 6110 6111C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h 6112@end group 6113@end smallexample 6114 6115@noindent 6116A keyboard macro is stored as a pure keystroke sequence. The 6117@file{edmacro} package (invoked by @kbd{Z E}) scans along the 6118macro and tries to decode it back into human-readable steps. 6119Descriptions of the keystrokes are given as comments, which begin with 6120@samp{;;}, and which are ignored when the edited macro is saved. 6121Spaces and line breaks are also ignored when the edited macro is saved. 6122To enter a space into the macro, type @code{SPC}. All the special 6123characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL}, 6124and @code{NUL} must be written in all uppercase, as must the prefixes 6125@code{C-} and @code{M-}. 6126 6127Let's edit in a new definition, for computing harmonic numbers. 6128First, erase the four lines of the old definition. Then, type 6129in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands 6130to copy it from this page of the Info file; you can of course skip 6131typing the comments, which begin with @samp{;;}). 6132 6133@smallexample 6134Z` ;; calc-kbd-push (Save local values) 61350 ;; calc digits (Push a zero onto the stack) 6136st ;; calc-store-into (Store it in the following variable) 61371 ;; calc quick variable (Quick variable q1) 61381 ;; calc digits (Initial value for the loop) 6139TAB ;; calc-roll-down (Swap initial and final) 6140Z( ;; calc-kbd-for (Begin the "for" loop) 6141& ;; calc-inv (Take the reciprocal) 6142s+ ;; calc-store-plus (Add to the following variable) 61431 ;; calc quick variable (Quick variable q1) 61441 ;; calc digits (The loop step is 1) 6145Z) ;; calc-kbd-end-for (End the "for" loop) 6146sr ;; calc-recall (Recall the final accumulated value) 61471 ;; calc quick variable (Quick variable q1) 6148Z' ;; calc-kbd-pop (Restore values) 6149@end smallexample 6150 6151@noindent 6152Press @kbd{C-c C-c} to finish editing and return to the Calculator. 6153 6154@smallexample 6155@group 61561: 20 1: 3.597739 6157 . . 6158 6159 20 z h 6160@end group 6161@end smallexample 6162 6163The @file{edmacro} package defines a handy @code{read-kbd-macro} command 6164which reads the current region of the current buffer as a sequence of 6165keystroke names, and defines that sequence on the @kbd{X} 6166(and @kbd{C-x e}) key. Because this is so useful, Calc puts this 6167command on the @kbd{C-x * m} key. Try reading in this macro in the 6168following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at 6169one end of the text below, then type @kbd{C-x * m} at the other. 6170 6171@example 6172@group 6173Z ` 0 t 1 6174 1 TAB 6175 Z ( & s + 1 1 Z ) 6176 r 1 6177Z ' 6178@end group 6179@end example 6180 6181(@bullet{}) @strong{Exercise 8.} A general algorithm for solving 6182equations numerically is @dfn{Newton's Method}. Given the equation 6183@expr{f(x) = 0} for any function @expr{f}, and an initial guess 6184@expr{x_0} which is reasonably close to the desired solution, apply 6185this formula over and over: 6186 6187@ifnottex 6188@example 6189new_x = x - f(x)/f'(x) 6190@end example 6191@end ifnottex 6192@tex 6193\beforedisplay 6194$$ x_{\rm new} = x - {f(x) \over f^{\prime}(x)} $$ 6195\afterdisplay 6196@end tex 6197 6198@noindent 6199where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x} 6200values will quickly converge to a solution, i.e., eventually 6201@texline @math{x_{\rm new}} 6202@infoline @expr{new_x} 6203and @expr{x} will be equal to within the limits 6204of the current precision. Write a program which takes a formula 6205involving the variable @expr{x}, and an initial guess @expr{x_0}, 6206on the stack, and produces a value of @expr{x} for which the formula 6207is zero. Use it to find a solution of 6208@texline @math{\sin(\cos x) = 0.5} 6209@infoline @expr{sin(cos(x)) = 0.5} 6210near @expr{x = 4.5}. (Use angles measured in radians.) Note that 6211the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's 6212method when it is able. @xref{Programming Answer 8, 8}. (@bullet{}) 6213 6214@cindex Digamma function 6215@cindex Gamma constant, Euler's 6216@cindex Euler's gamma constant 6217(@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function 6218@texline @math{\psi(z) (``psi'')} 6219@infoline @expr{psi(z)} 6220is defined as the derivative of 6221@texline @math{\ln \Gamma(z)}. 6222@infoline @expr{ln(gamma(z))}. 6223For large values of @expr{z}, it can be approximated by the infinite sum 6224 6225@ifnottex 6226@example 6227psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf) 6228@end example 6229@end ifnottex 6230@tex 6231\beforedisplay 6232$$ \psi(z) \approx \ln z - {1\over2z} - 6233 \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}} 6234$$ 6235\afterdisplay 6236@end tex 6237 6238@noindent 6239where 6240@texline @math{\sum} 6241@infoline @expr{sum} 6242represents the sum over @expr{n} from 1 to infinity 6243(or to some limit high enough to give the desired accuracy), and 6244the @code{bern} function produces (exact) Bernoulli numbers. 6245While this sum is not guaranteed to converge, in practice it is safe. 6246An interesting mathematical constant is Euler's gamma, which is equal 6247to about 0.5772. One way to compute it is by the formula, 6248@texline @math{\gamma = -\psi(1)}. 6249@infoline @expr{gamma = -psi(1)}. 6250Unfortunately, 1 isn't a large enough argument 6251for the above formula to work (5 is a much safer value for @expr{z}). 6252Fortunately, we can compute 6253@texline @math{\psi(1)} 6254@infoline @expr{psi(1)} 6255from 6256@texline @math{\psi(5)} 6257@infoline @expr{psi(5)} 6258using the recurrence 6259@texline @math{\psi(z+1) = \psi(z) + {1 \over z}}. 6260@infoline @expr{psi(z+1) = psi(z) + 1/z}. 6261Your task: Develop a program to compute 6262@texline @math{\psi(z)}; 6263@infoline @expr{psi(z)}; 6264it should ``pump up'' @expr{z} 6265if necessary to be greater than 5, then use the above summation 6266formula. Use looping commands to compute the sum. Use your function 6267to compute 6268@texline @math{\gamma} 6269@infoline @expr{gamma} 6270to twelve decimal places. (Calc has a built-in command 6271for Euler's constant, @kbd{I P}, which you can use to check your answer.) 6272@xref{Programming Answer 9, 9}. (@bullet{}) 6273 6274@cindex Polynomial, list of coefficients 6275(@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and 6276a number @expr{m} on the stack, where the polynomial is of degree 6277@expr{m} or less (i.e., does not have any terms higher than @expr{x^m}), 6278write a program to convert the polynomial into a list-of-coefficients 6279notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6} 6280should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop 6281a way to convert from this form back to the standard algebraic form. 6282@xref{Programming Answer 10, 10}. (@bullet{}) 6283 6284@cindex Recursion 6285(@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the 6286first kind} are defined by the recurrences, 6287 6288@ifnottex 6289@example 6290s(n,n) = 1 for n >= 0, 6291s(n,0) = 0 for n > 0, 6292s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1. 6293@end example 6294@end ifnottex 6295@tex 6296\beforedisplay 6297$$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr 6298 s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr 6299 s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad 6300 \hbox{for } n \ge m \ge 1.} 6301$$ 6302\afterdisplay 6303\vskip5pt 6304(These numbers are also sometimes written $\displaystyle{n \brack m}$.) 6305@end tex 6306 6307This can be implemented using a @dfn{recursive} program in Calc; the 6308program must invoke itself in order to calculate the two righthand 6309terms in the general formula. Since it always invokes itself with 6310``simpler'' arguments, it's easy to see that it must eventually finish 6311the computation. Recursion is a little difficult with Emacs keyboard 6312macros since the macro is executed before its definition is complete. 6313So here's the recommended strategy: Create a ``dummy macro'' and assign 6314it to a key with, e.g., @kbd{Z K s}. Now enter the true definition, 6315using the @kbd{z s} command to call itself recursively, then assign it 6316to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run 6317the complete recursive program. (Another way is to use @w{@kbd{Z E}} 6318or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once, 6319thus avoiding the ``training'' phase.) The task: Write a program 6320that computes Stirling numbers of the first kind, given @expr{n} and 6321@expr{m} on the stack. Test it with @emph{small} inputs like 6322@expr{s(4,2)}. (There is a built-in command for Stirling numbers, 6323@kbd{k s}, which you can use to check your answers.) 6324@xref{Programming Answer 11, 11}. (@bullet{}) 6325 6326The programming commands we've seen in this part of the tutorial 6327are low-level, general-purpose operations. Often you will find 6328that a higher-level function, such as vector mapping or rewrite 6329rules, will do the job much more easily than a detailed, step-by-step 6330program can: 6331 6332(@bullet{}) @strong{Exercise 12.} Write another program for 6333computing Stirling numbers of the first kind, this time using 6334rewrite rules. Once again, @expr{n} and @expr{m} should be taken 6335from the stack. @xref{Programming Answer 12, 12}. (@bullet{}) 6336 6337@example 6338 6339@end example 6340This ends the tutorial section of the Calc manual. Now you know enough 6341about Calc to use it effectively for many kinds of calculations. But 6342Calc has many features that were not even touched upon in this tutorial. 6343@c [not-split] 6344The rest of this manual tells the whole story. 6345@c [when-split] 6346@c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story. 6347 6348@page 6349@node Answers to Exercises, , Programming Tutorial, Tutorial 6350@section Answers to Exercises 6351 6352@noindent 6353This section includes answers to all the exercises in the Calc tutorial. 6354 6355@menu 6356* RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * - 6357* RPN Answer 2:: 2*4 + 7*9.5 + 5/4 6358* RPN Answer 3:: Operating on levels 2 and 3 6359* RPN Answer 4:: Joe's complex problems 6360* Algebraic Answer 1:: Simulating Q command 6361* Algebraic Answer 2:: Joe's algebraic woes 6362* Algebraic Answer 3:: 1 / 0 6363* Modes Answer 1:: 3#0.1 = 3#0.0222222? 6364* Modes Answer 2:: 16#f.e8fe15 6365* Modes Answer 3:: Joe's rounding bug 6366* Modes Answer 4:: Why floating point? 6367* Arithmetic Answer 1:: Why the \ command? 6368* Arithmetic Answer 2:: Tripping up the B command 6369* Vector Answer 1:: Normalizing a vector 6370* Vector Answer 2:: Average position 6371* Matrix Answer 1:: Row and column sums 6372* Matrix Answer 2:: Symbolic system of equations 6373* Matrix Answer 3:: Over-determined system 6374* List Answer 1:: Powers of two 6375* List Answer 2:: Least-squares fit with matrices 6376* List Answer 3:: Geometric mean 6377* List Answer 4:: Divisor function 6378* List Answer 5:: Duplicate factors 6379* List Answer 6:: Triangular list 6380* List Answer 7:: Another triangular list 6381* List Answer 8:: Maximum of Bessel function 6382* List Answer 9:: Integers the hard way 6383* List Answer 10:: All elements equal 6384* List Answer 11:: Estimating pi with darts 6385* List Answer 12:: Estimating pi with matchsticks 6386* List Answer 13:: Hash codes 6387* List Answer 14:: Random walk 6388* Types Answer 1:: Square root of pi times rational 6389* Types Answer 2:: Infinities 6390* Types Answer 3:: What can "nan" be? 6391* Types Answer 4:: Abbey Road 6392* Types Answer 5:: Friday the 13th 6393* Types Answer 6:: Leap years 6394* Types Answer 7:: Erroneous donut 6395* Types Answer 8:: Dividing intervals 6396* Types Answer 9:: Squaring intervals 6397* Types Answer 10:: Fermat's primality test 6398* Types Answer 11:: pi * 10^7 seconds 6399* Types Answer 12:: Abbey Road on CD 6400* Types Answer 13:: Not quite pi * 10^7 seconds 6401* Types Answer 14:: Supercomputers and c 6402* Types Answer 15:: Sam the Slug 6403* Algebra Answer 1:: Squares and square roots 6404* Algebra Answer 2:: Building polynomial from roots 6405* Algebra Answer 3:: Integral of x sin(pi x) 6406* Algebra Answer 4:: Simpson's rule 6407* Rewrites Answer 1:: Multiplying by conjugate 6408* Rewrites Answer 2:: Alternative fib rule 6409* Rewrites Answer 3:: Rewriting opt(a) + opt(b) x 6410* Rewrites Answer 4:: Sequence of integers 6411* Rewrites Answer 5:: Number of terms in sum 6412* Rewrites Answer 6:: Truncated Taylor series 6413* Programming Answer 1:: Fresnel's C(x) 6414* Programming Answer 2:: Negate third stack element 6415* Programming Answer 3:: Compute sin(x) / x, etc. 6416* Programming Answer 4:: Average value of a list 6417* Programming Answer 5:: Continued fraction phi 6418* Programming Answer 6:: Matrix Fibonacci numbers 6419* Programming Answer 7:: Harmonic number greater than 4 6420* Programming Answer 8:: Newton's method 6421* Programming Answer 9:: Digamma function 6422* Programming Answer 10:: Unpacking a polynomial 6423* Programming Answer 11:: Recursive Stirling numbers 6424* Programming Answer 12:: Stirling numbers with rewrites 6425@end menu 6426 6427@c The following kludgery prevents the individual answers from 6428@c being entered on the table of contents. 6429@tex 6430\global\let\oldwrite=\write 6431\gdef\skipwrite#1#2{\let\write=\oldwrite} 6432\global\let\oldchapternofonts=\chapternofonts 6433\gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts} 6434@end tex 6435 6436@node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises 6437@subsection RPN Tutorial Exercise 1 6438 6439@noindent 6440@kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -} 6441 6442The result is 6443@texline @math{1 - (2 \times (3 + 4)) = -13}. 6444@infoline @expr{1 - (2 * (3 + 4)) = -13}. 6445 6446@node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises 6447@subsection RPN Tutorial Exercise 2 6448 6449@noindent 6450@texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75} 6451@infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75} 6452 6453After computing the intermediate term 6454@texline @math{2\times4 = 8}, 6455@infoline @expr{2*4 = 8}, 6456you can leave that result on the stack while you compute the second 6457term. With both of these results waiting on the stack you can then 6458compute the final term, then press @kbd{+ +} to add everything up. 6459 6460@smallexample 6461@group 64622: 2 1: 8 3: 8 2: 8 64631: 4 . 2: 7 1: 66.5 6464 . 1: 9.5 . 6465 . 6466 6467 2 @key{RET} 4 * 7 @key{RET} 9.5 * 6468 6469@end group 6470@end smallexample 6471@noindent 6472@smallexample 6473@group 64744: 8 3: 8 2: 8 1: 75.75 64753: 66.5 2: 66.5 1: 67.75 . 64762: 5 1: 1.25 . 64771: 4 . 6478 . 6479 6480 5 @key{RET} 4 / + + 6481@end group 6482@end smallexample 6483 6484Alternatively, you could add the first two terms before going on 6485with the third term. 6486 6487@smallexample 6488@group 64892: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75 64901: 66.5 . 2: 5 1: 1.25 . 6491 . 1: 4 . 6492 . 6493 6494 ... + 5 @key{RET} 4 / + 6495@end group 6496@end smallexample 6497 6498On an old-style RPN calculator this second method would have the 6499advantage of using only three stack levels. But since Calc's stack 6500can grow arbitrarily large this isn't really an issue. Which method 6501you choose is purely a matter of taste. 6502 6503@node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises 6504@subsection RPN Tutorial Exercise 3 6505 6506@noindent 6507The @key{TAB} key provides a way to operate on the number in level 2. 6508 6509@smallexample 6510@group 65113: 10 3: 10 4: 10 3: 10 3: 10 65122: 20 2: 30 3: 30 2: 30 2: 21 65131: 30 1: 20 2: 20 1: 21 1: 30 6514 . . 1: 1 . . 6515 . 6516 6517 @key{TAB} 1 + @key{TAB} 6518@end group 6519@end smallexample 6520 6521Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3. 6522 6523@smallexample 6524@group 65253: 10 3: 21 3: 21 3: 30 3: 11 65262: 21 2: 30 2: 30 2: 11 2: 21 65271: 30 1: 10 1: 11 1: 21 1: 30 6528 . . . . . 6529 6530 M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB} 6531@end group 6532@end smallexample 6533 6534@node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises 6535@subsection RPN Tutorial Exercise 4 6536 6537@noindent 6538Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked, 6539but using both the comma and the space at once yields: 6540 6541@smallexample 6542@group 65431: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ... 6544 . 1: 2 . 1: (2, ... 1: (2, 3) 6545 . . . 6546 6547 ( 2 , @key{SPC} 3 ) 6548@end group 6549@end smallexample 6550 6551Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the 6552extra incomplete object to the top of the stack and delete it. 6553But a feature of Calc is that @key{DEL} on an incomplete object 6554deletes just one component out of that object, so he had to press 6555@key{DEL} twice to finish the job. 6556 6557@smallexample 6558@group 65592: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3) 65601: (2, 3) 1: (2, ... 1: ( ... . 6561 . . . 6562 6563 @key{TAB} @key{DEL} @key{DEL} 6564@end group 6565@end smallexample 6566 6567(As it turns out, deleting the second-to-top stack entry happens often 6568enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that. 6569@kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit 6570the ``feature'' that tripped poor Joe.) 6571 6572@node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises 6573@subsection Algebraic Entry Tutorial Exercise 1 6574 6575@noindent 6576Type @kbd{' sqrt($) @key{RET}}. 6577 6578If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}. 6579Or, RPN style, @kbd{0.5 ^}. 6580 6581(Actually, @samp{$^1:2}, using the fraction one-half as the power, is 6582a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas 6583@samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.) 6584 6585@node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises 6586@subsection Algebraic Entry Tutorial Exercise 2 6587 6588@noindent 6589In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function 6590name with @samp{1+y} as its argument. Assigning a value to a variable 6591has no relation to a function by the same name. Joe needed to use an 6592explicit @samp{*} symbol here: @samp{2 x*(1+y)}. 6593 6594@node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises 6595@subsection Algebraic Entry Tutorial Exercise 3 6596 6597@noindent 6598The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}. 6599The ``function'' @samp{/} cannot be evaluated when its second argument 6600is zero, so it is left in symbolic form. When you now type @kbd{0 *}, 6601the result will be zero because Calc uses the general rule that ``zero 6602times anything is zero.'' 6603 6604@c [fix-ref Infinities] 6605The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0} 6606results in a special symbol that represents ``infinity.'' If you 6607multiply infinity by zero, Calc uses another special new symbol to 6608show that the answer is ``indeterminate.'' @xref{Infinities}, for 6609further discussion of infinite and indeterminate values. 6610 6611@node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises 6612@subsection Modes Tutorial Exercise 1 6613 6614@noindent 6615Calc always stores its numbers in decimal, so even though one-third has 6616an exact base-3 representation (@samp{3#0.1}), it is still stored as 66170.3333333 (chopped off after 12 or however many decimal digits) inside 6618the calculator's memory. When this inexact number is converted back 6619to base 3 for display, it may still be slightly inexact. When we 6620multiply this number by 3, we get 0.999999, also an inexact value. 6621 6622When Calc displays a number in base 3, it has to decide how many digits 6623to show. If the current precision is 12 (decimal) digits, that corresponds 6624to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an 6625exact integer, Calc shows only 25 digits, with the result that stored 6626numbers carry a little bit of extra information that may not show up on 6627the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666 6628happened to round to a pleasing value when it lost that last 0.15 of a 6629digit, but it was still inexact in Calc's memory. When he divided by 2, 6630he still got the dreaded inexact value 0.333333. (Actually, he divided 66310.666667 by 2 to get 0.333334, which is why he got something a little 6632higher than @code{3#0.1} instead of a little lower.) 6633 6634If Joe didn't want to be bothered with all this, he could have typed 6635@kbd{M-24 d n} to display with one less digit than the default. (If 6636you give @kbd{d n} a negative argument, it uses default-minus-that, 6637so @kbd{M-- d n} would be an easier way to get the same effect.) Those 6638inexact results would still be lurking there, but they would now be 6639rounded to nice, natural-looking values for display purposes. (Remember, 6640@samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding 6641off one digit will round the number up to @samp{0.1}.) Depending on the 6642nature of your work, this hiding of the inexactness may be a benefit or 6643a danger. With the @kbd{d n} command, Calc gives you the choice. 6644 6645Incidentally, another consequence of all this is that if you type 6646@kbd{M-30 d n} to display more digits than are ``really there,'' 6647you'll see garbage digits at the end of the number. (In decimal 6648display mode, with decimally-stored numbers, these garbage digits are 6649always zero so they vanish and you don't notice them.) Because Calc 6650rounds off that 0.15 digit, there is the danger that two numbers could 6651be slightly different internally but still look the same. If you feel 6652uneasy about this, set the @kbd{d n} precision to be a little higher 6653than normal; you'll get ugly garbage digits, but you'll always be able 6654to tell two distinct numbers apart. 6655 6656An interesting side note is that most computers store their 6657floating-point numbers in binary, and convert to decimal for display. 6658Thus everyday programs have the same problem: Decimal 0.1 cannot be 6659represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10} 6660comes out as an inexact approximation to 1 on some machines (though 6661they generally arrange to hide it from you by rounding off one digit as 6662we did above). Because Calc works in decimal instead of binary, you can 6663be sure that numbers that look exact @emph{are} exact as long as you stay 6664in decimal display mode. 6665 6666It's not hard to show that any number that can be represented exactly 6667in binary, octal, or hexadecimal is also exact in decimal, so the kinds 6668of problems we saw in this exercise are likely to be severe only when 6669you use a relatively unusual radix like 3. 6670 6671@node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises 6672@subsection Modes Tutorial Exercise 2 6673 6674If the radix is 15 or higher, we can't use the letter @samp{e} to mark 6675the exponent because @samp{e} is interpreted as a digit. When Calc 6676needs to display scientific notation in a high radix, it writes 6677@samp{16#F.E8F*16.^15}. You can enter a number like this as an 6678algebraic entry. Also, pressing @kbd{e} without any digits before it 6679normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and 6680puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another 6681way to enter this number. 6682 6683The reason Calc puts a decimal point in the @samp{16.^} is to prevent 6684huge integers from being generated if the exponent is large (consider 6685@samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant 6686exact integer and then throw away most of the digits when we multiply 6687it by the floating-point @samp{16#1.23}). While this wouldn't normally 6688matter for display purposes, it could give you a nasty surprise if you 6689copied that number into a file and later moved it back into Calc. 6690 6691@node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises 6692@subsection Modes Tutorial Exercise 3 6693 6694@noindent 6695The answer he got was @expr{0.5000000000006399}. 6696 6697The problem is not that the square operation is inexact, but that the 6698sine of 45 that was already on the stack was accurate to only 12 places. 6699Arbitrary-precision calculations still only give answers as good as 6700their inputs. 6701 6702The real problem is that there is no 12-digit number which, when 6703squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]} 6704commands decrease or increase a number by one unit in the last 6705place (according to the current precision). They are useful for 6706determining facts like this. 6707 6708@smallexample 6709@group 67101: 0.707106781187 1: 0.500000000001 6711 . . 6712 6713 45 S 2 ^ 6714 6715@end group 6716@end smallexample 6717@noindent 6718@smallexample 6719@group 67201: 0.707106781187 1: 0.707106781186 1: 0.499999999999 6721 . . . 6722 6723 U @key{DEL} f [ 2 ^ 6724@end group 6725@end smallexample 6726 6727A high-precision calculation must be carried out in high precision 6728all the way. The only number in the original problem which was known 6729exactly was the quantity 45 degrees, so the precision must be raised 6730before anything is done after the number 45 has been entered in order 6731for the higher precision to be meaningful. 6732 6733@node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises 6734@subsection Modes Tutorial Exercise 4 6735 6736@noindent 6737Many calculations involve real-world quantities, like the width and 6738height of a piece of wood or the volume of a jar. Such quantities 6739can't be measured exactly anyway, and if the data that is input to 6740a calculation is inexact, doing exact arithmetic on it is a waste 6741of time. 6742 6743Fractions become unwieldy after too many calculations have been 6744done with them. For example, the sum of the reciprocals of the 6745integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is 67469304682830147:2329089562800. After a point it will take a long 6747time to add even one more term to this sum, but a floating-point 6748calculation of the sum will not have this problem. 6749 6750Also, rational numbers cannot express the results of all calculations. 6751There is no fractional form for the square root of two, so if you type 6752@w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer. 6753 6754@node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises 6755@subsection Arithmetic Tutorial Exercise 1 6756 6757@noindent 6758Dividing two integers that are larger than the current precision may 6759give a floating-point result that is inaccurate even when rounded 6760down to an integer. Consider @expr{123456789 / 2} when the current 6761precision is 6 digits. The true answer is @expr{61728394.5}, but 6762with a precision of 6 this will be rounded to 6763@texline @math{12345700.0/2.0 = 61728500.0}. 6764@infoline @expr{12345700.@: / 2.@: = 61728500.}. 6765The result, when converted to an integer, will be off by 106. 6766 6767Here are two solutions: Raise the precision enough that the 6768floating-point round-off error is strictly to the right of the 6769decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2} 6770produces the exact fraction @expr{123456789:2}, which can be rounded 6771down by the @kbd{F} command without ever switching to floating-point 6772format. 6773 6774@node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises 6775@subsection Arithmetic Tutorial Exercise 2 6776 6777@noindent 6778@kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it 6779does a floating-point calculation instead and produces @expr{1.5}. 6780 6781Calc will find an exact result for a logarithm if the result is an integer 6782or (when in Fraction mode) the reciprocal of an integer. But there is 6783no efficient way to search the space of all possible rational numbers 6784for an exact answer, so Calc doesn't try. 6785 6786@node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises 6787@subsection Vector Tutorial Exercise 1 6788 6789@noindent 6790Duplicate the vector, compute its length, then divide the vector 6791by its length: @kbd{@key{RET} A /}. 6792 6793@smallexample 6794@group 67951: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1. 6796 . 1: 3.74165738677 . . 6797 . 6798 6799 r 1 @key{RET} A / A 6800@end group 6801@end smallexample 6802 6803The final @kbd{A} command shows that the normalized vector does 6804indeed have unit length. 6805 6806@node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises 6807@subsection Vector Tutorial Exercise 2 6808 6809@noindent 6810The average position is equal to the sum of the products of the 6811positions times their corresponding probabilities. This is the 6812definition of the dot product operation. So all you need to do 6813is to put the two vectors on the stack and press @kbd{*}. 6814 6815@node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises 6816@subsection Matrix Tutorial Exercise 1 6817 6818@noindent 6819The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to 6820get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum. 6821 6822@node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises 6823@subsection Matrix Tutorial Exercise 2 6824 6825@ifnottex 6826@example 6827@group 6828 x + a y = 6 6829 x + b y = 10 6830@end group 6831@end example 6832@end ifnottex 6833@tex 6834\beforedisplay 6835$$ \eqalign{ x &+ a y = 6 \cr 6836 x &+ b y = 10} 6837$$ 6838\afterdisplay 6839@end tex 6840 6841Just enter the righthand side vector, then divide by the lefthand side 6842matrix as usual. 6843 6844@smallexample 6845@group 68461: [6, 10] 2: [6, 10] 1: [4 a / (a - b) + 6, 4 / (b - a) ] 6847 . 1: [ [ 1, a ] . 6848 [ 1, b ] ] 6849 . 6850 6851' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} / 6852@end group 6853@end smallexample 6854 6855This can be made more readable using @kbd{d B} to enable Big display 6856mode: 6857 6858@smallexample 6859@group 6860 4 a 4 68611: [----- + 6, -----] 6862 a - b b - a 6863@end group 6864@end smallexample 6865 6866Type @kbd{d N} to return to Normal display mode afterwards. 6867 6868@node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises 6869@subsection Matrix Tutorial Exercise 3 6870 6871@noindent 6872To solve 6873@texline @math{A^T A \, X = A^T B}, 6874@infoline @expr{trn(A) * A * X = trn(A) * B}, 6875first we compute 6876@texline @math{A' = A^T A} 6877@infoline @expr{A2 = trn(A) * A} 6878and 6879@texline @math{B' = A^T B}; 6880@infoline @expr{B2 = trn(A) * B}; 6881now, we have a system 6882@texline @math{A' X = B'} 6883@infoline @expr{A2 * X = B2} 6884which we can solve using Calc's @samp{/} command. 6885 6886@ifnottex 6887@example 6888@group 6889 a + 2b + 3c = 6 6890 4a + 5b + 6c = 2 6891 7a + 6b = 3 6892 2a + 4b + 6c = 11 6893@end group 6894@end example 6895@end ifnottex 6896@tex 6897\beforedisplayh 6898$$ \openup1\jot \tabskip=0pt plus1fil 6899\halign to\displaywidth{\tabskip=0pt 6900 $\hfil#$&$\hfil{}#{}$& 6901 $\hfil#$&$\hfil{}#{}$& 6902 $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr 6903 a&+&2b&+&3c&=6 \cr 6904 4a&+&5b&+&6c&=2 \cr 6905 7a&+&6b& & &=3 \cr 6906 2a&+&4b&+&6c&=11 \cr} 6907$$ 6908\afterdisplayh 6909@end tex 6910 6911The first step is to enter the coefficient matrix. We'll store it in 6912quick variable number 7 for later reference. Next, we compute the 6913@texline @math{B'} 6914@infoline @expr{B2} 6915vector. 6916 6917@smallexample 6918@group 69191: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96] 6920 [ 4, 5, 6 ] [ 2, 5, 6, 4 ] . 6921 [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ] 6922 [ 2, 4, 6 ] ] 1: [6, 2, 3, 11] 6923 . . 6924 6925' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] * 6926@end group 6927@end smallexample 6928 6929@noindent 6930Now we compute the matrix 6931@texline @math{A'} 6932@infoline @expr{A2} 6933and divide. 6934 6935@smallexample 6936@group 69372: [57, 84, 96] 1: [-11.64, 14.08, -3.64] 69381: [ [ 70, 72, 39 ] . 6939 [ 72, 81, 60 ] 6940 [ 39, 60, 81 ] ] 6941 . 6942 6943 r 7 v t r 7 * / 6944@end group 6945@end smallexample 6946 6947@noindent 6948(The actual computed answer will be slightly inexact due to 6949round-off error.) 6950 6951Notice that the answers are similar to those for the 6952@texline @math{3\times3} 6953@infoline 3x3 6954system solved in the text. That's because the fourth equation that was 6955added to the system is almost identical to the first one multiplied 6956by two. (If it were identical, we would have gotten the exact same 6957answer since the 6958@texline @math{4\times3} 6959@infoline 4x3 6960system would be equivalent to the original 6961@texline @math{3\times3} 6962@infoline 3x3 6963system.) 6964 6965Since the first and fourth equations aren't quite equivalent, they 6966can't both be satisfied at once. Let's plug our answers back into 6967the original system of equations to see how well they match. 6968 6969@smallexample 6970@group 69712: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2] 69721: [ [ 1, 2, 3 ] . 6973 [ 4, 5, 6 ] 6974 [ 7, 6, 0 ] 6975 [ 2, 4, 6 ] ] 6976 . 6977 6978 r 7 @key{TAB} * 6979@end group 6980@end smallexample 6981 6982@noindent 6983This is reasonably close to our original @expr{B} vector, 6984@expr{[6, 2, 3, 11]}. 6985 6986@node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises 6987@subsection List Tutorial Exercise 1 6988 6989@noindent 6990We can use @kbd{v x} to build a vector of integers. This needs to be 6991adjusted to get the range of integers we desire. Mapping @samp{-} 6992across the vector will accomplish this, although it turns out the 6993plain @samp{-} key will work just as well. 6994 6995@smallexample 6996@group 69972: 2 2: 2 69981: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4] 6999 . . 7000 7001 2 v x 9 @key{RET} 5 V M - or 5 - 7002@end group 7003@end smallexample 7004 7005@noindent 7006Now we use @kbd{V M ^} to map the exponentiation operator across the 7007vector. 7008 7009@smallexample 7010@group 70111: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] 7012 . 7013 7014 V M ^ 7015@end group 7016@end smallexample 7017 7018@node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises 7019@subsection List Tutorial Exercise 2 7020 7021@noindent 7022Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before, 7023the first job is to form the matrix that describes the problem. 7024 7025@ifnottex 7026@example 7027 m*x + b*1 = y 7028@end example 7029@end ifnottex 7030@tex 7031\beforedisplay 7032$$ m \times x + b \times 1 = y $$ 7033\afterdisplay 7034@end tex 7035 7036Thus we want a 7037@texline @math{19\times2} 7038@infoline 19x2 7039matrix with our @expr{x} vector as one column and 7040ones as the other column. So, first we build the column of ones, then 7041we combine the two columns to form our @expr{A} matrix. 7042 7043@smallexample 7044@group 70452: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ] 70461: [1, 1, 1, ...] [ 1.41, 1 ] 7047 . [ 1.49, 1 ] 7048 @dots{} 7049 7050 r 1 1 v b 19 @key{RET} M-2 v p v t s 3 7051@end group 7052@end smallexample 7053 7054@noindent 7055Now we compute 7056@texline @math{A^T y} 7057@infoline @expr{trn(A) * y} 7058and 7059@texline @math{A^T A} 7060@infoline @expr{trn(A) * A} 7061and divide. 7062 7063@smallexample 7064@group 70651: [33.36554, 13.613] 2: [33.36554, 13.613] 7066 . 1: [ [ 98.0003, 41.63 ] 7067 [ 41.63, 19 ] ] 7068 . 7069 7070 v t r 2 * r 3 v t r 3 * 7071@end group 7072@end smallexample 7073 7074@noindent 7075(Hey, those numbers look familiar!) 7076 7077@smallexample 7078@group 70791: [0.52141679, -0.425978] 7080 . 7081 7082 / 7083@end group 7084@end smallexample 7085 7086Since we were solving equations of the form 7087@texline @math{m \times x + b \times 1 = y}, 7088@infoline @expr{m*x + b*1 = y}, 7089these numbers should be @expr{m} and @expr{b}, respectively. Sure 7090enough, they agree exactly with the result computed using @kbd{V M} and 7091@kbd{V R}! 7092 7093The moral of this story: @kbd{V M} and @kbd{V R} will probably solve 7094your problem, but there is often an easier way using the higher-level 7095arithmetic functions! 7096 7097@c [fix-ref Curve Fitting] 7098In fact, there is a built-in @kbd{a F} command that does least-squares 7099fits. @xref{Curve Fitting}. 7100 7101@node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises 7102@subsection List Tutorial Exercise 3 7103 7104@noindent 7105Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or 7106whatever) to set the mark, then move to the other end of the list 7107and type @w{@kbd{C-x * g}}. 7108 7109@smallexample 7110@group 71111: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5] 7112 . 7113@end group 7114@end smallexample 7115 7116To make things interesting, let's assume we don't know at a glance 7117how many numbers are in this list. Then we could type: 7118 7119@smallexample 7120@group 71212: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ] 71221: [2.3, 6, 22, ... ] 1: 126356422.5 7123 . . 7124 7125 @key{RET} V R * 7126 7127@end group 7128@end smallexample 7129@noindent 7130@smallexample 7131@group 71322: 126356422.5 2: 126356422.5 1: 7.94652913734 71331: [2.3, 6, 22, ... ] 1: 9 . 7134 . . 7135 7136 @key{TAB} v l I ^ 7137@end group 7138@end smallexample 7139 7140@noindent 7141(The @kbd{I ^} command computes the @var{n}th root of a number. 7142You could also type @kbd{& ^} to take the reciprocal of 9 and 7143then raise the number to that power.) 7144 7145@node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises 7146@subsection List Tutorial Exercise 4 7147 7148@noindent 7149A number @expr{j} is a divisor of @expr{n} if 7150@texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}. 7151@infoline @samp{n % j = 0}. 7152The first step is to get a vector that identifies the divisors. 7153 7154@smallexample 7155@group 71562: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...] 71571: [1, 2, 3, 4, ...] 1: 0 . 7158 . . 7159 7160 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2 7161@end group 7162@end smallexample 7163 7164@noindent 7165This vector has 1's marking divisors of 30 and 0's marking non-divisors. 7166 7167The zeroth divisor function is just the total number of divisors. 7168The first divisor function is the sum of the divisors. 7169 7170@smallexample 7171@group 71721: 8 3: 8 2: 8 2: 8 7173 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72 7174 1: [1, 1, 1, 0, ...] . . 7175 . 7176 7177 V R + r 1 r 2 V M * V R + 7178@end group 7179@end smallexample 7180 7181@noindent 7182Once again, the last two steps just compute a dot product for which 7183a simple @kbd{*} would have worked equally well. 7184 7185@node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises 7186@subsection List Tutorial Exercise 5 7187 7188@noindent 7189The obvious first step is to obtain the list of factors with @kbd{k f}. 7190This list will always be in sorted order, so if there are duplicates 7191they will be right next to each other. A suitable method is to compare 7192the list with a copy of itself shifted over by one. 7193 7194@smallexample 7195@group 71961: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0] 7197 . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19] 7198 . . 7199 7200 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} | 7201 7202@end group 7203@end smallexample 7204@noindent 7205@smallexample 7206@group 72071: [0, 0, 1, 1, 0, 0] 1: 2 1: 0 7208 . . . 7209 7210 V M a = V R + 0 a = 7211@end group 7212@end smallexample 7213 7214@noindent 7215Note that we have to arrange for both vectors to have the same length 7216so that the mapping operation works; no prime factor will ever be 7217zero, so adding zeros on the left and right is safe. From then on 7218the job is pretty straightforward. 7219 7220Incidentally, Calc provides the @dfn{Möbius μ} 7221function which is zero if and only if its argument is square-free. It 7222would be a much more convenient way to do the above test in practice. 7223 7224@node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises 7225@subsection List Tutorial Exercise 6 7226 7227@noindent 7228First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x} 7229to get a list of lists of integers! 7230 7231@node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises 7232@subsection List Tutorial Exercise 7 7233 7234@noindent 7235Here's one solution. First, compute the triangular list from the previous 7236exercise and type @kbd{1 -} to subtract one from all the elements. 7237 7238@smallexample 7239@group 72401: [ [0], 7241 [0, 1], 7242 [0, 1, 2], 7243 @dots{} 7244 7245 1 - 7246@end group 7247@end smallexample 7248 7249The numbers down the lefthand edge of the list we desire are called 7250the ``triangular numbers'' (now you know why!). The @expr{n}th 7251triangular number is the sum of the integers from 1 to @expr{n}, and 7252can be computed directly by the formula 7253@texline @math{n (n+1) \over 2}. 7254@infoline @expr{n * (n+1) / 2}. 7255 7256@smallexample 7257@group 72582: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] 72591: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15] 7260 . . 7261 7262 v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET} 7263@end group 7264@end smallexample 7265 7266@noindent 7267Adding this list to the above list of lists produces the desired 7268result: 7269 7270@smallexample 7271@group 72721: [ [0], 7273 [1, 2], 7274 [3, 4, 5], 7275 [6, 7, 8, 9], 7276 [10, 11, 12, 13, 14], 7277 [15, 16, 17, 18, 19, 20] ] 7278 . 7279 7280 V M + 7281@end group 7282@end smallexample 7283 7284If we did not know the formula for triangular numbers, we could have 7285computed them using a @kbd{V U +} command. We could also have 7286gotten them the hard way by mapping a reduction across the original 7287triangular list. 7288 7289@smallexample 7290@group 72912: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] 72921: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15] 7293 . . 7294 7295 @key{RET} V M V R + 7296@end group 7297@end smallexample 7298 7299@noindent 7300(This means ``map a @kbd{V R +} command across the vector,'' and 7301since each element of the main vector is itself a small vector, 7302@kbd{V R +} computes the sum of its elements.) 7303 7304@node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises 7305@subsection List Tutorial Exercise 8 7306 7307@noindent 7308The first step is to build a list of values of @expr{x}. 7309 7310@smallexample 7311@group 73121: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5] 7313 . . . 7314 7315 v x 21 @key{RET} 1 - 4 / s 1 7316@end group 7317@end smallexample 7318 7319Next, we compute the Bessel function values. 7320 7321@smallexample 7322@group 73231: [0., 0.124, 0.242, ..., -0.328] 7324 . 7325 7326 V M ' besJ(1,$) @key{RET} 7327@end group 7328@end smallexample 7329 7330@noindent 7331(Another way to do this would be @kbd{1 @key{TAB} V M f j}.) 7332 7333A way to isolate the maximum value is to compute the maximum using 7334@kbd{V R X}, then compare all the Bessel values with that maximum. 7335 7336@smallexample 7337@group 73382: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ] 73391: 0.5801562 . 1: 1 7340 . . 7341 7342 @key{RET} V R X V M a = @key{RET} V R + @key{DEL} 7343@end group 7344@end smallexample 7345 7346@noindent 7347It's a good idea to verify, as in the last step above, that only 7348one value is equal to the maximum. (After all, a plot of 7349@texline @math{\sin x} 7350@infoline @expr{sin(x)} 7351might have many points all equal to the maximum value, 1.) 7352 7353The vector we have now has a single 1 in the position that indicates 7354the maximum value of @expr{x}. Now it is a simple matter to convert 7355this back into the corresponding value itself. 7356 7357@smallexample 7358@group 73592: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75 73601: [0, 0.25, 0.5, ... ] . . 7361 . 7362 7363 r 1 V M * V R + 7364@end group 7365@end smallexample 7366 7367If @kbd{a =} had produced more than one @expr{1} value, this method 7368would have given the sum of all maximum @expr{x} values; not very 7369useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector}) 7370instead. This command deletes all elements of a ``data'' vector that 7371correspond to zeros in a ``mask'' vector, leaving us with, in this 7372example, a vector of maximum @expr{x} values. 7373 7374The built-in @kbd{a X} command maximizes a function using more 7375efficient methods. Just for illustration, let's use @kbd{a X} 7376to maximize @samp{besJ(1,x)} over this same interval. 7377 7378@smallexample 7379@group 73802: besJ(1, x) 1: [1.84115, 0.581865] 73811: [0 .. 5] . 7382 . 7383 7384' besJ(1,x), [0..5] @key{RET} a X x @key{RET} 7385@end group 7386@end smallexample 7387 7388@noindent 7389The output from @kbd{a X} is a vector containing the value of @expr{x} 7390that maximizes the function, and the function's value at that maximum. 7391As you can see, our simple search got quite close to the right answer. 7392 7393@node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises 7394@subsection List Tutorial Exercise 9 7395 7396@noindent 7397Step one is to convert our integer into vector notation. 7398 7399@smallexample 7400@group 74011: 25129925999 3: 25129925999 7402 . 2: 10 7403 1: [11, 10, 9, ..., 1, 0] 7404 . 7405 7406 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} - 7407 7408@end group 7409@end smallexample 7410@noindent 7411@smallexample 7412@group 74131: 25129925999 1: [0, 2, 25, 251, 2512, ... ] 74142: [100000000000, ... ] . 7415 . 7416 7417 V M ^ s 1 V M \ 7418@end group 7419@end smallexample 7420 7421@noindent 7422(Recall, the @kbd{\} command computes an integer quotient.) 7423 7424@smallexample 7425@group 74261: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9] 7427 . 7428 7429 10 V M % s 2 7430@end group 7431@end smallexample 7432 7433Next we must increment this number. This involves adding one to 7434the last digit, plus handling carries. There is a carry to the 7435left out of a digit if that digit is a nine and all the digits to 7436the right of it are nines. 7437 7438@smallexample 7439@group 74401: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ] 7441 . . 7442 7443 9 V M a = v v 7444 7445@end group 7446@end smallexample 7447@noindent 7448@smallexample 7449@group 74501: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1] 7451 . . 7452 7453 V U * v v 1 | 7454@end group 7455@end smallexample 7456 7457@noindent 7458Accumulating @kbd{*} across a vector of ones and zeros will preserve 7459only the initial run of ones. These are the carries into all digits 7460except the rightmost digit. Concatenating a one on the right takes 7461care of aligning the carries properly, and also adding one to the 7462rightmost digit. 7463 7464@smallexample 7465@group 74662: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0] 74671: [0, 0, 2, 5, ... ] . 7468 . 7469 7470 0 r 2 | V M + 10 V M % 7471@end group 7472@end smallexample 7473 7474@noindent 7475Here we have concatenated 0 to the @emph{left} of the original number; 7476this takes care of shifting the carries by one with respect to the 7477digits that generated them. 7478 7479Finally, we must convert this list back into an integer. 7480 7481@smallexample 7482@group 74833: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ] 74842: 1000000000000 1: [1000000000000, 100000000000, ... ] 74851: [100000000000, ... ] . 7486 . 7487 7488 10 @key{RET} 12 ^ r 1 | 7489 7490@end group 7491@end smallexample 7492@noindent 7493@smallexample 7494@group 74951: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000 7496 . . 7497 7498 V M * V R + 7499@end group 7500@end smallexample 7501 7502@noindent 7503Another way to do this final step would be to reduce the formula 7504@w{@samp{10 $$ + $}} across the vector of digits. 7505 7506@smallexample 7507@group 75081: [0, 0, 2, 5, ... ] 1: 25129926000 7509 . . 7510 7511 V R ' 10 $$ + $ @key{RET} 7512@end group 7513@end smallexample 7514 7515@node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises 7516@subsection List Tutorial Exercise 10 7517 7518@noindent 7519For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d}, 7520which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is 7521then compared with @expr{c} to produce another 1 or 0, which is then 7522compared with @expr{d}. This is not at all what Joe wanted. 7523 7524Here's a more correct method: 7525 7526@smallexample 7527@group 75281: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7] 7529 . 1: 7 7530 . 7531 7532 ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET} 7533 7534@end group 7535@end smallexample 7536@noindent 7537@smallexample 7538@group 75391: [1, 1, 1, 0, 1] 1: 0 7540 . . 7541 7542 V M a = V R * 7543@end group 7544@end smallexample 7545 7546@node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises 7547@subsection List Tutorial Exercise 11 7548 7549@noindent 7550The circle of unit radius consists of those points @expr{(x,y)} for which 7551@expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2} 7552and a vector of @expr{y^2}. 7553 7554We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} 7555commands. 7556 7557@smallexample 7558@group 75592: [2., 2., ..., 2.] 2: [2., 2., ..., 2.] 75601: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81] 7561 . . 7562 7563 v . t . 2. v b 100 @key{RET} @key{RET} V M k r 7564 7565@end group 7566@end smallexample 7567@noindent 7568@smallexample 7569@group 75702: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036] 75711: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094] 7572 . . 7573 7574 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^ 7575@end group 7576@end smallexample 7577 7578Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to 7579get a vector of 1/0 truth values, then sum the truth values. 7580 7581@smallexample 7582@group 75831: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84 7584 . . . 7585 7586 + 1 V M a < V R + 7587@end group 7588@end smallexample 7589 7590@noindent 7591The ratio @expr{84/100} should approximate the ratio @cpiover{4}. 7592 7593@smallexample 7594@group 75951: 0.84 1: 3.36 2: 3.36 1: 1.0695 7596 . . 1: 3.14159 . 7597 7598 100 / 4 * P / 7599@end group 7600@end smallexample 7601 7602@noindent 7603Our estimate, 3.36, is off by about 7%. We could get a better estimate 7604by taking more points (say, 1000), but it's clear that this method is 7605not very efficient! 7606 7607(Naturally, since this example uses random numbers your own answer 7608will be slightly different from the one shown here!) 7609 7610If you typed @kbd{v .} and @kbd{t .} before, type them again to 7611return to full-sized display of vectors. 7612 7613@node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises 7614@subsection List Tutorial Exercise 12 7615 7616@noindent 7617This problem can be made a lot easier by taking advantage of some 7618symmetries. First of all, after some thought it's clear that the 7619@expr{y} axis can be ignored altogether. Just pick a random @expr{x} 7620component for one end of the match, pick a random direction 7621@texline @math{\theta}, 7622@infoline @expr{theta}, 7623and see if @expr{x} and 7624@texline @math{x + \cos \theta} 7625@infoline @expr{x + cos(theta)} 7626(which is the @expr{x} coordinate of the other endpoint) cross a line. 7627The lines are at integer coordinates, so this happens when the two 7628numbers surround an integer. 7629 7630Since the two endpoints are equivalent, we may as well choose the leftmost 7631of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing 7632to the right, in the range -90 to 90 degrees. (We could use radians, but 7633it would feel like cheating to refer to @cpiover{2} radians while trying 7634to estimate @cpi{}!) 7635 7636In fact, since the field of lines is infinite we can choose the 7637coordinates 0 and 1 for the lines on either side of the leftmost 7638endpoint. The rightmost endpoint will be between 0 and 1 if the 7639match does not cross a line, or between 1 and 2 if it does. So: 7640Pick random @expr{x} and 7641@texline @math{\theta}, 7642@infoline @expr{theta}, 7643compute 7644@texline @math{x + \cos \theta}, 7645@infoline @expr{x + cos(theta)}, 7646and count how many of the results are greater than one. Simple! 7647 7648We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} 7649commands. 7650 7651@smallexample 7652@group 76531: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72] 7654 . 1: [78.4, 64.5, ..., -42.9] 7655 . 7656 7657v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 - 7658@end group 7659@end smallexample 7660 7661@noindent 7662(The next step may be slow, depending on the speed of your computer.) 7663 7664@smallexample 7665@group 76662: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45] 76671: [0.20, 0.43, ..., 0.73] . 7668 . 7669 7670 m d V M C + 7671 7672@end group 7673@end smallexample 7674@noindent 7675@smallexample 7676@group 76771: [0, 1, ..., 1] 1: 0.64 1: 3.125 7678 . . . 7679 7680 1 V M a > V R + 100 / 2 @key{TAB} / 7681@end group 7682@end smallexample 7683 7684Let's try the third method, too. We'll use random integers up to 7685one million. The @kbd{k r} command with an integer argument picks 7686a random integer. 7687 7688@smallexample 7689@group 76902: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975] 76911: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450] 7692 . . 7693 7694 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r 7695 7696@end group 7697@end smallexample 7698@noindent 7699@smallexample 7700@group 77011: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56 7702 . . . 7703 7704 V M k g 1 V M a = V R + 100 / 7705 7706@end group 7707@end smallexample 7708@noindent 7709@smallexample 7710@group 77111: 10.714 1: 3.273 7712 . . 7713 7714 6 @key{TAB} / Q 7715@end group 7716@end smallexample 7717 7718For a proof of this property of the GCD function, see section 4.5.2, 7719exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II. 7720 7721If you typed @kbd{v .} and @kbd{t .} before, type them again to 7722return to full-sized display of vectors. 7723 7724@node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises 7725@subsection List Tutorial Exercise 13 7726 7727@noindent 7728First, we put the string on the stack as a vector of ASCII codes. 7729 7730@smallexample 7731@group 77321: [84, 101, 115, ..., 51] 7733 . 7734 7735 "Testing, 1, 2, 3 @key{RET} 7736@end group 7737@end smallexample 7738 7739@noindent 7740Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so 7741there was no need to type an apostrophe. Also, Calc didn't mind that 7742we omitted the closing @kbd{"}. (The same goes for all closing delimiters 7743like @kbd{)} and @kbd{]} at the end of a formula. 7744 7745We'll show two different approaches here. In the first, we note that 7746if the input vector is @expr{[a, b, c, d]}, then the hash code is 7747@expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words, 7748it's a sum of descending powers of three times the ASCII codes. 7749 7750@smallexample 7751@group 77522: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51] 77531: 16 1: [15, 14, 13, ..., 0] 7754 . . 7755 7756 @key{RET} v l v x 16 @key{RET} - 7757 7758@end group 7759@end smallexample 7760@noindent 7761@smallexample 7762@group 77632: [84, 101, 115, ..., 51] 1: 1960915098 1: 121 77641: [14348907, ..., 1] . . 7765 . 7766 7767 3 @key{TAB} V M ^ * 511 % 7768@end group 7769@end smallexample 7770 7771@noindent 7772Once again, @kbd{*} elegantly summarizes most of the computation. 7773But there's an even more elegant approach: Reduce the formula 7774@kbd{3 $$ + $} across the vector. Recall that this represents a 7775function of two arguments that computes its first argument times three 7776plus its second argument. 7777 7778@smallexample 7779@group 77801: [84, 101, 115, ..., 51] 1: 1960915098 7781 . . 7782 7783 "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET} 7784@end group 7785@end smallexample 7786 7787@noindent 7788If you did the decimal arithmetic exercise, this will be familiar. 7789Basically, we're turning a base-3 vector of digits into an integer, 7790except that our ``digits'' are much larger than real digits. 7791 7792Instead of typing @kbd{511 %} again to reduce the result, we can be 7793cleverer still and notice that rather than computing a huge integer 7794and taking the modulo at the end, we can take the modulo at each step 7795without affecting the result. While this means there are more 7796arithmetic operations, the numbers we operate on remain small so 7797the operations are faster. 7798 7799@smallexample 7800@group 78011: [84, 101, 115, ..., 51] 1: 121 7802 . . 7803 7804 "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET} 7805@end group 7806@end smallexample 7807 7808Why does this work? Think about a two-step computation: 7809@w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means 7810subtracting off enough 511's to put the result in the desired range. 7811So the result when we take the modulo after every step is, 7812 7813@ifnottex 7814@example 78153 (3 a + b - 511 m) + c - 511 n 7816@end example 7817@end ifnottex 7818@tex 7819\beforedisplay 7820$$ 3 (3 a + b - 511 m) + c - 511 n $$ 7821\afterdisplay 7822@end tex 7823 7824@noindent 7825for some suitable integers @expr{m} and @expr{n}. Expanding out by 7826the distributive law yields 7827 7828@ifnottex 7829@example 78309 a + 3 b + c - 511*3 m - 511 n 7831@end example 7832@end ifnottex 7833@tex 7834\beforedisplay 7835$$ 9 a + 3 b + c - 511\times3 m - 511 n $$ 7836\afterdisplay 7837@end tex 7838 7839@noindent 7840The @expr{m} term in the latter formula is redundant because any 7841contribution it makes could just as easily be made by the @expr{n} 7842term. So we can take it out to get an equivalent formula with 7843@expr{n' = 3m + n}, 7844 7845@ifnottex 7846@example 78479 a + 3 b + c - 511 n' 7848@end example 7849@end ifnottex 7850@tex 7851\beforedisplay 7852$$ 9 a + 3 b + c - 511 n^{\prime} $$ 7853\afterdisplay 7854@end tex 7855 7856@noindent 7857which is just the formula for taking the modulo only at the end of 7858the calculation. Therefore the two methods are essentially the same. 7859 7860Later in the tutorial we will encounter @dfn{modulo forms}, which 7861basically automate the idea of reducing every intermediate result 7862modulo some value @var{m}. 7863 7864@node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises 7865@subsection List Tutorial Exercise 14 7866 7867We want to use @kbd{H V U} to nest a function which adds a random 7868step to an @expr{(x,y)} coordinate. The function is a bit long, but 7869otherwise the problem is quite straightforward. 7870 7871@smallexample 7872@group 78732: [0, 0] 1: [ [ 0, 0 ] 78741: 50 [ 0.4288, -0.1695 ] 7875 . [ -0.4787, -0.9027 ] 7876 ... 7877 7878 [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET} 7879@end group 7880@end smallexample 7881 7882Just as the text recommended, we used @samp{< >} nameless function 7883notation to keep the two @code{random} calls from being evaluated 7884before nesting even begins. 7885 7886We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's 7887rules acts like a matrix. We can transpose this matrix and unpack 7888to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing. 7889 7890@smallexample 7891@group 78922: [ 0, 0.4288, -0.4787, ... ] 78931: [ 0, -0.1696, -0.9027, ... ] 7894 . 7895 7896 v t v u g f 7897@end group 7898@end smallexample 7899 7900Incidentally, because the @expr{x} and @expr{y} are completely 7901independent in this case, we could have done two separate commands 7902to create our @expr{x} and @expr{y} vectors of numbers directly. 7903 7904To make a random walk of unit steps, we note that @code{sincos} of 7905a random direction exactly gives us an @expr{[x, y]} step of unit 7906length; in fact, the new nesting function is even briefer, though 7907we might want to lower the precision a bit for it. 7908 7909@smallexample 7910@group 79112: [0, 0] 1: [ [ 0, 0 ] 79121: 50 [ 0.1318, 0.9912 ] 7913 . [ -0.5965, 0.3061 ] 7914 ... 7915 7916 [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET} 7917@end group 7918@end smallexample 7919 7920Another @kbd{v t v u g f} sequence will graph this new random walk. 7921 7922An interesting twist on these random walk functions would be to use 7923complex numbers instead of 2-vectors to represent points on the plane. 7924In the first example, we'd use something like @samp{random + random*(0,1)}, 7925and in the second we could use polar complex numbers with random phase 7926angles. (This exercise was first suggested in this form by Randal 7927Schwartz.) 7928 7929@node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises 7930@subsection Types Tutorial Exercise 1 7931 7932@noindent 7933If the number is the square root of @cpi{} times a rational number, 7934then its square, divided by @cpi{}, should be a rational number. 7935 7936@smallexample 7937@group 79381: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627 7939 . . . 7940 7941 2 ^ P / c F 7942@end group 7943@end smallexample 7944 7945@noindent 7946Technically speaking this is a rational number, but not one that is 7947likely to have arisen in the original problem. More likely, it just 7948happens to be the fraction which most closely represents some 7949irrational number to within 12 digits. 7950 7951But perhaps our result was not quite exact. Let's reduce the 7952precision slightly and try again: 7953 7954@smallexample 7955@group 79561: 0.509433962268 1: 27:53 7957 . . 7958 7959 U p 10 @key{RET} c F 7960@end group 7961@end smallexample 7962 7963@noindent 7964Aha! It's unlikely that an irrational number would equal a fraction 7965this simple to within ten digits, so our original number was probably 7966@texline @math{\sqrt{27 \pi / 53}}. 7967@infoline @expr{sqrt(27 pi / 53)}. 7968 7969Notice that we didn't need to re-round the number when we reduced the 7970precision. Remember, arithmetic operations always round their inputs 7971to the current precision before they begin. 7972 7973@node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises 7974@subsection Types Tutorial Exercise 2 7975 7976@noindent 7977@samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer. 7978But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too. 7979 7980@samp{exp(inf) = inf}. It's tempting to say that the exponential 7981of infinity must be ``bigger'' than ``regular'' infinity, but as 7982far as Calc is concerned all infinities are the same size. 7983In other words, as @expr{x} goes to infinity, @expr{e^x} also goes 7984to infinity, but the fact the @expr{e^x} grows much faster than 7985@expr{x} is not relevant here. 7986 7987@samp{exp(-inf) = 0}. Here we have a finite answer even though 7988the input is infinite. 7989 7990@samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)} 7991represents the imaginary number @expr{i}. Here's a derivation: 7992@samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}. 7993The first part is, by definition, @expr{i}; the second is @code{inf} 7994because, once again, all infinities are the same size. 7995 7996@samp{sqrt(uinf) = uinf}. In fact, we do know something about the 7997direction because @code{sqrt} is defined to return a value in the 7998right half of the complex plane. But Calc has no notation for this, 7999so it settles for the conservative answer @code{uinf}. 8000 8001@samp{abs(uinf) = inf}. No matter which direction @expr{x} points, 8002@samp{abs(x)} always points along the positive real axis. 8003 8004@samp{ln(0) = -inf}. Here we have an infinite answer to a finite 8005input. As in the @expr{1 / 0} case, Calc will only use infinities 8006here if you have turned on Infinite mode. Otherwise, it will 8007treat @samp{ln(0)} as an error. 8008 8009@node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises 8010@subsection Types Tutorial Exercise 3 8011 8012@noindent 8013We can make @samp{inf - inf} be any real number we like, say, 8014@expr{a}, just by claiming that we added @expr{a} to the first 8015infinity but not to the second. This is just as true for complex 8016values of @expr{a}, so @code{nan} can stand for a complex number. 8017(And, similarly, @code{uinf} can stand for an infinity that points 8018in any direction in the complex plane, such as @samp{(0, 1) inf}). 8019 8020In fact, we can multiply the first @code{inf} by two. Surely 8021@w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}. 8022So @code{nan} can even stand for infinity. Obviously it's just 8023as easy to make it stand for minus infinity as for plus infinity. 8024 8025The moral of this story is that ``infinity'' is a slippery fish 8026indeed, and Calc tries to handle it by having a very simple model 8027for infinities (only the direction counts, not the ``size''); but 8028Calc is careful to write @code{nan} any time this simple model is 8029unable to tell what the true answer is. 8030 8031@node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises 8032@subsection Types Tutorial Exercise 4 8033 8034@smallexample 8035@group 80362: 0@@ 47' 26" 1: 0@@ 2' 47.411765" 80371: 17 . 8038 . 8039 8040 0@@ 47' 26" @key{RET} 17 / 8041@end group 8042@end smallexample 8043 8044@noindent 8045The average song length is two minutes and 47.4 seconds. 8046 8047@smallexample 8048@group 80492: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005" 80501: 0@@ 0' 20" . . 8051 . 8052 8053 20" + 17 * 8054@end group 8055@end smallexample 8056 8057@noindent 8058The album would be 53 minutes and 6 seconds long. 8059 8060@node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises 8061@subsection Types Tutorial Exercise 5 8062 8063@noindent 8064Let's suppose it's January 14, 1991. The easiest thing to do is 8065to keep trying 13ths of months until Calc reports a Friday. 8066We can do this by manually entering dates, or by using @kbd{t I}: 8067 8068@smallexample 8069@group 80701: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991> 8071 . . . 8072 8073 ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I 8074@end group 8075@end smallexample 8076 8077@noindent 8078(Calc assumes the current year if you don't say otherwise.) 8079 8080This is getting tedious---we can keep advancing the date by typing 8081@kbd{t I} over and over again, but let's automate the job by using 8082vector mapping. The @kbd{t I} command actually takes a second 8083``how-many-months'' argument, which defaults to one. This 8084argument is exactly what we want to map over: 8085 8086@smallexample 8087@group 80882: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>, 80891: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>, 8090 . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>] 8091 . 8092 8093 v x 6 @key{RET} V M t I 8094@end group 8095@end smallexample 8096 8097@noindent 8098Et voilà, September 13, 1991 is a Friday. 8099 8100@smallexample 8101@group 81021: 242 8103 . 8104 8105' <sep 13> - <jan 14> @key{RET} 8106@end group 8107@end smallexample 8108 8109@noindent 8110And the answer to our original question: 242 days to go. 8111 8112@node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises 8113@subsection Types Tutorial Exercise 6 8114 8115@noindent 8116The full rule for leap years is that they occur in every year divisible 8117by four, except that they don't occur in years divisible by 100, except 8118that they @emph{do} in years divisible by 400. We could work out the 8119answer by carefully counting the years divisible by four and the 8120exceptions, but there is a much simpler way that works even if we 8121don't know the leap year rule. 8122 8123Let's assume the present year is 1991. Years have 365 days, except 8124that leap years (whenever they occur) have 366 days. So let's count 8125the number of days between now and then, and compare that to the 8126number of years times 365. The number of extra days we find must be 8127equal to the number of leap years there were. 8128 8129@smallexample 8130@group 81311: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593 8132 . 1: <Tue Jan 1, 1991> . 8133 . 8134 8135 ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} - 8136 8137@end group 8138@end smallexample 8139@noindent 8140@smallexample 8141@group 81423: 2925593 2: 2925593 2: 2925593 1: 1943 81432: 10001 1: 8010 1: 2923650 . 81441: 1991 . . 8145 . 8146 8147 10001 @key{RET} 1991 - 365 * - 8148@end group 8149@end smallexample 8150 8151@c [fix-ref Date Forms] 8152@noindent 8153There will be 1943 leap years before the year 10001. (Assuming, 8154of course, that the algorithm for computing leap years remains 8155unchanged for that long. @xref{Date Forms}, for some interesting 8156background information in that regard.) 8157 8158@node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises 8159@subsection Types Tutorial Exercise 7 8160 8161@noindent 8162The relative errors must be converted to absolute errors so that 8163@samp{+/-} notation may be used. 8164 8165@smallexample 8166@group 81671: 1. 2: 1. 8168 . 1: 0.2 8169 . 8170 8171 20 @key{RET} .05 * 4 @key{RET} .05 * 8172@end group 8173@end smallexample 8174 8175Now we simply chug through the formula. 8176 8177@smallexample 8178@group 81791: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21 8180 . . . 8181 8182 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ * 8183@end group 8184@end smallexample 8185 8186It turns out the @kbd{v u} command will unpack an error form as 8187well as a vector. This saves us some retyping of numbers. 8188 8189@smallexample 8190@group 81913: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21 81922: 6316.5 1: 0.1118 81931: 706.21 . 8194 . 8195 8196 @key{RET} v u @key{TAB} / 8197@end group 8198@end smallexample 8199 8200@noindent 8201Thus the volume is 6316 cubic centimeters, within about 11 percent. 8202 8203@node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises 8204@subsection Types Tutorial Exercise 8 8205 8206@noindent 8207The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}. 8208Since a number in the interval @samp{(0 .. 10)} can get arbitrarily 8209close to zero, its reciprocal can get arbitrarily large, so the answer 8210is an interval that effectively means, ``any number greater than 0.1'' 8211but with no upper bound. 8212 8213The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}. 8214 8215Calc normally treats division by zero as an error, so that the formula 8216@w{@samp{1 / 0}} is left unsimplified. Our third problem, 8217@w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero 8218is now a member of the interval. So Calc leaves this one unevaluated, too. 8219 8220If you turn on Infinite mode by pressing @kbd{m i}, you will 8221instead get the answer @samp{[0.1 .. inf]}, which includes infinity 8222as a possible value. 8223 8224The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem. 8225Zero is buried inside the interval, but it's still a possible value. 8226It's not hard to see that the actual result of @samp{1 / (-10 .. 10)} 8227will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus 8228the interval goes from minus infinity to plus infinity, with a ``hole'' 8229in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to 8230represent this, so it just reports @samp{[-inf .. inf]} as the answer. 8231It may be disappointing to hear ``the answer lies somewhere between 8232minus infinity and plus infinity, inclusive,'' but that's the best 8233that interval arithmetic can do in this case. 8234 8235@node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises 8236@subsection Types Tutorial Exercise 9 8237 8238@smallexample 8239@group 82401: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9] 8241 . 1: [0 .. 9] 1: [-9 .. 9] 8242 . . 8243 8244 [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} * 8245@end group 8246@end smallexample 8247 8248@noindent 8249In the first case the result says, ``if a number is between @mathit{-3} and 82503, its square is between 0 and 9.'' The second case says, ``the product 8251of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.'' 8252 8253An interval form is not a number; it is a symbol that can stand for 8254many different numbers. Two identical-looking interval forms can stand 8255for different numbers. 8256 8257The same issue arises when you try to square an error form. 8258 8259@node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises 8260@subsection Types Tutorial Exercise 10 8261 8262@noindent 8263Testing the first number, we might arbitrarily choose 17 for @expr{x}. 8264 8265@smallexample 8266@group 82671: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613 8268 . 811749612 . 8269 . 8270 8271 17 M 811749613 @key{RET} 811749612 ^ 8272@end group 8273@end smallexample 8274 8275@noindent 8276Since 533694123 is (considerably) different from 1, the number 811749613 8277must not be prime. 8278 8279It's awkward to type the number in twice as we did above. There are 8280various ways to avoid this, and algebraic entry is one. In fact, using 8281a vector mapping operation we can perform several tests at once. Let's 8282use this method to test the second number. 8283 8284@smallexample 8285@group 82862: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ] 82871: 15485863 . 8288 . 8289 8290 [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET} 8291@end group 8292@end smallexample 8293 8294@noindent 8295The result is three ones (modulo @expr{n}), so it's very probable that 829615485863 is prime. (In fact, this number is the millionth prime.) 8297 8298Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $} 8299would have been hopelessly inefficient, since they would have calculated 8300the power using full integer arithmetic. 8301 8302Calc has a @kbd{k p} command that does primality testing. For small 8303numbers it does an exact test; for large numbers it uses a variant 8304of the Fermat test we used here. You can use @kbd{k p} repeatedly 8305to prove that a large integer is prime with any desired probability. 8306 8307@node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises 8308@subsection Types Tutorial Exercise 11 8309 8310@noindent 8311There are several ways to insert a calculated number into an HMS form. 8312One way to convert a number of seconds to an HMS form is simply to 8313multiply the number by an HMS form representing one second: 8314 8315@smallexample 8316@group 83171: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359" 8318 . 1: 0@@ 0' 1" . 8319 . 8320 8321 P 1e7 * 0@@ 0' 1" * 8322 8323@end group 8324@end smallexample 8325@noindent 8326@smallexample 8327@group 83282: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0" 83291: 15@@ 27' 16" mod 24@@ 0' 0" . 8330 . 8331 8332 x time @key{RET} + 8333@end group 8334@end smallexample 8335 8336@noindent 8337It will be just after six in the morning. 8338 8339The algebraic @code{hms} function can also be used to build an 8340HMS form: 8341 8342@smallexample 8343@group 83441: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359" 8345 . . 8346 8347 ' hms(0, 0, 1e7 pi) @key{RET} = 8348@end group 8349@end smallexample 8350 8351@noindent 8352The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to 8353the actual number 3.14159... 8354 8355@node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises 8356@subsection Types Tutorial Exercise 12 8357 8358@noindent 8359As we recall, there are 17 songs of about 2 minutes and 47 seconds 8360each. 8361 8362@smallexample 8363@group 83642: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"] 83651: [0@@ 0' 20" .. 0@@ 1' 0"] . 8366 . 8367 8368 [ 0@@ 20" .. 0@@ 1' ] + 8369 8370@end group 8371@end smallexample 8372@noindent 8373@smallexample 8374@group 83751: [0@@ 52' 59." .. 1@@ 4' 19."] 8376 . 8377 8378 17 * 8379@end group 8380@end smallexample 8381 8382@noindent 8383No matter how long it is, the album will fit nicely on one CD. 8384 8385@node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises 8386@subsection Types Tutorial Exercise 13 8387 8388@noindent 8389Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds. 8390 8391@node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises 8392@subsection Types Tutorial Exercise 14 8393 8394@noindent 8395How long will it take for a signal to get from one end of the computer 8396to the other? 8397 8398@smallexample 8399@group 84001: m / c 1: 3.3356 ns 8401 . . 8402 8403 ' 1 m / c @key{RET} u c ns @key{RET} 8404@end group 8405@end smallexample 8406 8407@noindent 8408(Recall, @samp{c} is a ``unit'' corresponding to the speed of light.) 8409 8410@smallexample 8411@group 84121: 3.3356 ns 1: 0.81356 84132: 4.1 ns . 8414 . 8415 8416 ' 4.1 ns @key{RET} / 8417@end group 8418@end smallexample 8419 8420@noindent 8421Thus a signal could take up to 81 percent of a clock cycle just to 8422go from one place to another inside the computer, assuming the signal 8423could actually attain the full speed of light. Pretty tight! 8424 8425@node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises 8426@subsection Types Tutorial Exercise 15 8427 8428@noindent 8429The speed limit is 55 miles per hour on most highways. We want to 8430find the ratio of Sam's speed to the US speed limit. 8431 8432@smallexample 8433@group 84341: 55 mph 2: 55 mph 3: 11 hr mph / yd 8435 . 1: 5 yd / hr . 8436 . 8437 8438 ' 55 mph @key{RET} ' 5 yd/hr @key{RET} / 8439@end group 8440@end smallexample 8441 8442The @kbd{u s} command cancels out these units to get a plain 8443number. Now we take the logarithm base two to find the final 8444answer, assuming that each successive pill doubles his speed. 8445 8446@smallexample 8447@group 84481: 19360. 2: 19360. 1: 14.24 8449 . 1: 2 . 8450 . 8451 8452 u s 2 B 8453@end group 8454@end smallexample 8455 8456@noindent 8457Thus Sam can take up to 14 pills without a worry. 8458 8459@node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises 8460@subsection Algebra Tutorial Exercise 1 8461 8462@noindent 8463@c [fix-ref Declarations] 8464The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the 8465Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens 8466if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be 8467simplified to @samp{abs(x)}, but for general complex arguments even 8468that is not safe. (@xref{Declarations}, for a way to tell Calc 8469that @expr{x} is known to be real.) 8470 8471@node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises 8472@subsection Algebra Tutorial Exercise 2 8473 8474@noindent 8475Suppose our roots are @expr{[a, b, c]}. We want a polynomial which 8476is zero when @expr{x} is any of these values. The trivial polynomial 8477@expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)} 8478will do the job. We can use @kbd{a c x} to write this in a more 8479familiar form. 8480 8481@smallexample 8482@group 84831: 34 x - 24 x^3 1: [1.19023, -1.19023, 0] 8484 . . 8485 8486 r 2 a P x @key{RET} 8487 8488@end group 8489@end smallexample 8490@noindent 8491@smallexample 8492@group 84931: [x - 1.19023, x + 1.19023, x] 1: x*(x + 1.19023) (x - 1.19023) 8494 . . 8495 8496 V M ' x-$ @key{RET} V R * 8497 8498@end group 8499@end smallexample 8500@noindent 8501@smallexample 8502@group 85031: x^3 - 1.41666 x 1: 34 x - 24 x^3 8504 . . 8505 8506 a c x @key{RET} 24 n * a x 8507@end group 8508@end smallexample 8509 8510@noindent 8511Sure enough, our answer (multiplied by a suitable constant) is the 8512same as the original polynomial. 8513 8514@node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises 8515@subsection Algebra Tutorial Exercise 3 8516 8517@smallexample 8518@group 85191: x sin(pi x) 1: sin(pi x) / pi^2 - x cos(pi x) / pi 8520 . . 8521 8522 ' x sin(pi x) @key{RET} m r a i x @key{RET} 8523 8524@end group 8525@end smallexample 8526@noindent 8527@smallexample 8528@group 85291: [y, 1] 85302: sin(pi x) / pi^2 - x cos(pi x) / pi 8531 . 8532 8533 ' [y,1] @key{RET} @key{TAB} 8534 8535@end group 8536@end smallexample 8537@noindent 8538@smallexample 8539@group 85401: [sin(pi y) / pi^2 - y cos(pi y) / pi, 1 / pi] 8541 . 8542 8543 V M $ @key{RET} 8544 8545@end group 8546@end smallexample 8547@noindent 8548@smallexample 8549@group 85501: sin(pi y) / pi^2 - y cos(pi y) / pi - 1 / pi 8551 . 8552 8553 V R - 8554 8555@end group 8556@end smallexample 8557@noindent 8558@smallexample 8559@group 85601: sin(3.14159 y) / 9.8696 - y cos(3.14159 y) / 3.14159 - 0.3183 8561 . 8562 8563 = 8564 8565@end group 8566@end smallexample 8567@noindent 8568@smallexample 8569@group 85701: [0., -0.95493, 0.63662, -1.5915, 1.2732] 8571 . 8572 8573 v x 5 @key{RET} @key{TAB} V M $ @key{RET} 8574@end group 8575@end smallexample 8576 8577@node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises 8578@subsection Algebra Tutorial Exercise 4 8579 8580@noindent 8581The hard part is that @kbd{V R +} is no longer sufficient to add up all 8582the contributions from the slices, since the slices have varying 8583coefficients. So first we must come up with a vector of these 8584coefficients. Here's one way: 8585 8586@smallexample 8587@group 85882: -1 2: 3 1: [4, 2, ..., 4] 85891: [1, 2, ..., 9] 1: [-1, 1, ..., -1] . 8590 . . 8591 8592 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} - 8593 8594@end group 8595@end smallexample 8596@noindent 8597@smallexample 8598@group 85991: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1] 8600 . . 8601 8602 1 | 1 @key{TAB} | 8603@end group 8604@end smallexample 8605 8606@noindent 8607Now we compute the function values. Note that for this method we need 8608eleven values, including both endpoints of the desired interval. 8609 8610@smallexample 8611@group 86122: [1, 4, 2, ..., 4, 1] 86131: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.] 8614 . 8615 8616 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x 8617 8618@end group 8619@end smallexample 8620@noindent 8621@smallexample 8622@group 86232: [1, 4, 2, ..., 4, 1] 86241: [0., 0.084941, 0.16993, ... ] 8625 . 8626 8627 ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET} 8628@end group 8629@end smallexample 8630 8631@noindent 8632Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the 8633same thing. 8634 8635@smallexample 8636@group 86371: 11.22 1: 1.122 1: 0.374 8638 . . . 8639 8640 * .1 * 3 / 8641@end group 8642@end smallexample 8643 8644@noindent 8645Wow! That's even better than the result from the Taylor series method. 8646 8647@node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises 8648@subsection Rewrites Tutorial Exercise 1 8649 8650@noindent 8651We'll use Big mode to make the formulas more readable. 8652 8653@smallexample 8654@group 8655 ___ 8656 V 2 + 2 86571: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------- 8658 . ___ 8659 V 2 + 1 8660 8661 . 8662 8663 ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B 8664@end group 8665@end smallexample 8666 8667@noindent 8668Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}. 8669 8670@smallexample 8671@group 8672 ___ ___ 86731: (2 + V 2 ) (V 2 - 1) 8674 . 8675 8676 a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET} 8677 8678@end group 8679@end smallexample 8680@noindent 8681@smallexample 8682@group 8683 ___ 86841: V 2 8685 . 8686 8687 a r a*(b+c) := a*b + a*c 8688@end group 8689@end smallexample 8690 8691@noindent 8692(We could have used @kbd{a x} instead of a rewrite rule for the 8693second step.) 8694 8695The multiply-by-conjugate rule turns out to be useful in many 8696different circumstances, such as when the denominator involves 8697sines and cosines or the imaginary constant @code{i}. 8698 8699@node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises 8700@subsection Rewrites Tutorial Exercise 2 8701 8702@noindent 8703Here is the rule set: 8704 8705@smallexample 8706@group 8707[ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1, 8708 fib(1, x, y) := x, 8709 fib(n, x, y) := fib(n-1, y, x+y) ] 8710@end group 8711@end smallexample 8712 8713@noindent 8714The first rule turns a one-argument @code{fib} that people like to write 8715into a three-argument @code{fib} that makes computation easier. The 8716second rule converts back from three-argument form once the computation 8717is done. The third rule does the computation itself. It basically 8718says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers, 8719then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci 8720numbers. 8721 8722Notice that because the number @expr{n} was ``validated'' by the 8723conditions on the first rule, there is no need to put conditions on 8724the other rules because the rule set would never get that far unless 8725the input were valid. That further speeds computation, since no 8726extra conditions need to be checked at every step. 8727 8728Actually, a user with a nasty sense of humor could enter a bad 8729three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)}, 8730which would get the rules into an infinite loop. One thing that would 8731help keep this from happening by accident would be to use something like 8732@samp{ZzFib} instead of @code{fib} as the name of the three-argument 8733function. 8734 8735@node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises 8736@subsection Rewrites Tutorial Exercise 3 8737 8738@noindent 8739He got an infinite loop. First, Calc did as expected and rewrote 8740@w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to 8741apply the rule again, and found that @samp{f(2, 3, x)} looks like 8742@samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to 8743@samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)} 8744around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r} 8745to make sure the rule applied only once. 8746 8747(Actually, even the first step didn't work as he expected. What Calc 8748really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)}, 8749treating 2 as the ``variable,'' and @samp{3 x} as a constant being added 8750to it. While this may seem odd, it's just as valid a solution as the 8751``obvious'' one. One way to fix this would be to add the condition 8752@samp{:: variable(x)} to the rule, to make sure the thing that matches 8753@samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)} 8754on the lefthand side, so that the rule matches the actual variable 8755@samp{x} rather than letting @samp{x} stand for something else.) 8756 8757@node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises 8758@subsection Rewrites Tutorial Exercise 4 8759 8760@noindent 8761@ignore 8762@starindex 8763@end ignore 8764@tindex seq 8765Here is a suitable set of rules to solve the first part of the problem: 8766 8767@smallexample 8768@group 8769[ seq(n, c) := seq(n/2, c+1) :: n%2 = 0, 8770 seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ] 8771@end group 8772@end smallexample 8773 8774Given the initial formula @samp{seq(6, 0)}, application of these 8775rules produces the following sequence of formulas: 8776 8777@example 8778seq( 3, 1) 8779seq(10, 2) 8780seq( 5, 3) 8781seq(16, 4) 8782seq( 8, 5) 8783seq( 4, 6) 8784seq( 2, 7) 8785seq( 1, 8) 8786@end example 8787 8788@noindent 8789whereupon neither of the rules match, and rewriting stops. 8790 8791We can pretty this up a bit with a couple more rules: 8792 8793@smallexample 8794@group 8795[ seq(n) := seq(n, 0), 8796 seq(1, c) := c, 8797 ... ] 8798@end group 8799@end smallexample 8800 8801@noindent 8802Now, given @samp{seq(6)} as the starting configuration, we get 8 8803as the result. 8804 8805The change to return a vector is quite simple: 8806 8807@smallexample 8808@group 8809[ seq(n) := seq(n, []) :: integer(n) :: n > 0, 8810 seq(1, v) := v | 1, 8811 seq(n, v) := seq(n/2, v | n) :: n%2 = 0, 8812 seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ] 8813@end group 8814@end smallexample 8815 8816@noindent 8817Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. 8818 8819Notice that the @expr{n > 1} guard is no longer necessary on the last 8820rule since the @expr{n = 1} case is now detected by another rule. 8821But a guard has been added to the initial rule to make sure the 8822initial value is suitable before the computation begins. 8823 8824While still a good idea, this guard is not as vitally important as it 8825was for the @code{fib} function, since calling, say, @samp{seq(x, [])} 8826will not get into an infinite loop. Calc will not be able to prove 8827the symbol @samp{x} is either even or odd, so none of the rules will 8828apply and the rewrites will stop right away. 8829 8830@node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises 8831@subsection Rewrites Tutorial Exercise 5 8832 8833@noindent 8834@ignore 8835@starindex 8836@end ignore 8837@tindex nterms 8838If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must 8839be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x} 8840is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1. 8841 8842@smallexample 8843@group 8844[ nterms(a + b) := nterms(a) + nterms(b), 8845 nterms(x) := 1 ] 8846@end group 8847@end smallexample 8848 8849@noindent 8850Here we have taken advantage of the fact that earlier rules always 8851match before later rules; @samp{nterms(x)} will only be tried if we 8852already know that @samp{x} is not a sum. 8853 8854@node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises 8855@subsection Rewrites Tutorial Exercise 6 8856 8857@noindent 8858Here is a rule set that will do the job: 8859 8860@smallexample 8861@group 8862[ a*(b + c) := a*b + a*c, 8863 opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m 8864 :: constant(a) :: constant(b), 8865 opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m 8866 :: constant(a) :: constant(b), 8867 a O(x^n) := O(x^n) :: constant(a), 8868 x^opt(m) O(x^n) := O(x^(n+m)), 8869 O(x^n) O(x^m) := O(x^(n+m)) ] 8870@end group 8871@end smallexample 8872 8873If we really want the @kbd{+} and @kbd{*} keys to operate naturally 8874on power series, we should put these rules in @code{EvalRules}. For 8875testing purposes, it is better to put them in a different variable, 8876say, @code{O}, first. 8877 8878The first rule just expands products of sums so that the rest of the 8879rules can assume they have an expanded-out polynomial to work with. 8880Note that this rule does not mention @samp{O} at all, so it will 8881apply to any product-of-sum it encounters---this rule may surprise 8882you if you put it into @code{EvalRules}! 8883 8884In the second rule, the sum of two O's is changed to the smaller O@. 8885The optional constant coefficients are there mostly so that 8886@samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled 8887as well as @samp{O(x^2) + O(x^3)}. 8888 8889The third rule absorbs higher powers of @samp{x} into O's. 8890 8891The fourth rule says that a constant times a negligible quantity 8892is still negligible. (This rule will also match @samp{O(x^3) / 4}, 8893with @samp{a = 1/4}.) 8894 8895The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}. 8896(It is easy to see that if one of these forms is negligible, the other 8897is, too.) Notice the @samp{x^opt(m)} to pick up terms like 8898@w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1} 8899but not 1 as @samp{x^0}. This turns out to be exactly what we want here. 8900 8901The sixth rule is the corresponding rule for products of two O's. 8902 8903Another way to solve this problem would be to create a new ``data type'' 8904that represents truncated power series. We might represent these as 8905function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is 8906a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so 8907on. Rules would exist for sums and products of such @code{series} 8908objects, and as an optional convenience could also know how to combine a 8909@code{series} object with a normal polynomial. (With this, and with a 8910rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form, 8911you could still enter power series in exactly the same notation as 8912before.) Operations on such objects would probably be more efficient, 8913although the objects would be a bit harder to read. 8914 8915@c [fix-ref Compositions] 8916Some other symbolic math programs provide a power series data type 8917similar to this. Mathematica, for example, has an object that looks 8918like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin}, 8919@var{nmax}, @var{den}]}, where @var{x0} is the point about which the 8920power series is taken (we've been assuming this was always zero), 8921and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series 8922with fractional or negative powers. Also, the @code{PowerSeries} 8923objects have a special display format that makes them look like 8924@samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions}, 8925for a way to do this in Calc, although for something as involved as 8926this it would probably be better to write the formatting routine 8927in Lisp.) 8928 8929@node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises 8930@subsection Programming Tutorial Exercise 1 8931 8932@noindent 8933Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type 8934@kbd{Z F}, and answer the questions. Since this formula contains two 8935variables, the default argument list will be @samp{(t x)}. We want to 8936change this to @samp{(x)} since @expr{t} is really a dummy variable 8937to be used within @code{ninteg}. 8938 8939The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}. 8940(The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.) 8941 8942@node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises 8943@subsection Programming Tutorial Exercise 2 8944 8945@noindent 8946One way is to move the number to the top of the stack, operate on 8947it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}. 8948 8949Another way is to negate the top three stack entries, then negate 8950again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}. 8951 8952Finally, it turns out that a negative prefix argument causes a 8953command like @kbd{n} to operate on the specified stack entry only, 8954which is just what we want: @kbd{C-x ( M-- 3 n C-x )}. 8955 8956Just for kicks, let's also do it algebraically: 8957@w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}. 8958 8959@node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises 8960@subsection Programming Tutorial Exercise 3 8961 8962@noindent 8963Each of these functions can be computed using the stack, or using 8964algebraic entry, whichever way you prefer: 8965 8966@noindent 8967Computing 8968@texline @math{\displaystyle{\sin x \over x}}: 8969@infoline @expr{sin(x) / x}: 8970 8971Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}. 8972 8973Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}. 8974 8975@noindent 8976Computing the logarithm: 8977 8978Using the stack: @kbd{C-x ( @key{TAB} B C-x )} 8979 8980Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}. 8981 8982@noindent 8983Computing the vector of integers: 8984 8985Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that 8986@kbd{C-u v x} takes the vector size, starting value, and increment 8987from the stack.) 8988 8989Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a 8990number from the stack and uses it as the prefix argument for the 8991next command.) 8992 8993Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}. 8994 8995@node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises 8996@subsection Programming Tutorial Exercise 4 8997 8998@noindent 8999Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}. 9000 9001@node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises 9002@subsection Programming Tutorial Exercise 5 9003 9004@smallexample 9005@group 90062: 1 1: 1.61803398502 2: 1.61803398502 90071: 20 . 1: 1.61803398875 9008 . . 9009 9010 1 @key{RET} 20 Z < & 1 + Z > I H P 9011@end group 9012@end smallexample 9013 9014@noindent 9015This answer is quite accurate. 9016 9017@node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises 9018@subsection Programming Tutorial Exercise 6 9019 9020@noindent 9021Here is the matrix: 9022 9023@example 9024[ [ 0, 1 ] * [a, b] = [b, a + b] 9025 [ 1, 1 ] ] 9026@end example 9027 9028@noindent 9029Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1} 9030and @expr{n+2}. Here's one program that does the job: 9031 9032@example 9033C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x ) 9034@end example 9035 9036@noindent 9037This program is quite efficient because Calc knows how to raise a 9038matrix (or other value) to the power @expr{n} in only 9039@texline @math{\log_2 n} 9040@infoline @expr{log(n,2)} 9041steps. For example, this program can compute the 1000th Fibonacci 9042number (a 209-digit integer!)@: in about 10 steps; even though the 9043@kbd{Z < ... Z >} solution had much simpler steps, it would have 9044required so many steps that it would not have been practical. 9045 9046@node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises 9047@subsection Programming Tutorial Exercise 7 9048 9049@noindent 9050The trick here is to compute the harmonic numbers differently, so that 9051the loop counter itself accumulates the sum of reciprocals. We use 9052a separate variable to hold the integer counter. 9053 9054@smallexample 9055@group 90561: 1 2: 1 1: . 9057 . 1: 4 9058 . 9059 9060 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z ) 9061@end group 9062@end smallexample 9063 9064@noindent 9065The body of the loop goes as follows: First save the harmonic sum 9066so far in variable 2. Then delete it from the stack; the for loop 9067itself will take care of remembering it for us. Next, recall the 9068count from variable 1, add one to it, and feed its reciprocal to 9069the for loop to use as the step value. The for loop will increase 9070the ``loop counter'' by that amount and keep going until the 9071loop counter exceeds 4. 9072 9073@smallexample 9074@group 90752: 31 3: 31 90761: 3.99498713092 2: 3.99498713092 9077 . 1: 4.02724519544 9078 . 9079 9080 r 1 r 2 @key{RET} 31 & + 9081@end group 9082@end smallexample 9083 9084Thus we find that the 30th harmonic number is 3.99, and the 31st 9085harmonic number is 4.02. 9086 9087@node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises 9088@subsection Programming Tutorial Exercise 8 9089 9090@noindent 9091The first step is to compute the derivative @expr{f'(x)} and thus 9092the formula 9093@texline @math{\displaystyle{x - {f(x) \over f'(x)}}}. 9094@infoline @expr{x - f(x)/f'(x)}. 9095 9096(Because this definition is long, it will be repeated in concise form 9097below. You can use @w{@kbd{C-x * m}} to load it from there. While you are 9098entering a @kbd{Z ` Z '} body in a macro, Calc simply collects 9099keystrokes without executing them. In the following diagrams we'll 9100pretend Calc actually executed the keystrokes as you typed them, 9101just for purposes of illustration.) 9102 9103@smallexample 9104@group 91052: sin(cos(x)) - 0.5 3: 4.5 91061: 4.5 2: sin(cos(x)) - 0.5 9107 . 1: -(sin(x) cos(cos(x))) 9108 . 9109 9110' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} 9111 9112@end group 9113@end smallexample 9114@noindent 9115@smallexample 9116@group 91172: 4.5 91181: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x)) 9119 . 9120 9121 / ' x @key{RET} @key{TAB} - t 1 9122@end group 9123@end smallexample 9124 9125Now, we enter the loop. We'll use a repeat loop with a 20-repetition 9126limit just in case the method fails to converge for some reason. 9127(Normally, the @w{@kbd{Z /}} command will stop the loop before all 20 9128repetitions are done.) 9129 9130@smallexample 9131@group 91321: 4.5 3: 4.5 2: 4.5 9133 . 2: x + (sin(cos(x)) ... 1: 5.24196456928 9134 1: 4.5 . 9135 . 9136 9137 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET} 9138@end group 9139@end smallexample 9140 9141This is the new guess for @expr{x}. Now we compare it with the 9142old one to see if we've converged. 9143 9144@smallexample 9145@group 91463: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348 91472: 5.24196 1: 0 . . 91481: 4.5 . 9149 . 9150 9151 @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x ) 9152@end group 9153@end smallexample 9154 9155The loop converges in just a few steps to this value. To check 9156the result, we can simply substitute it back into the equation. 9157 9158@smallexample 9159@group 91602: 5.26345856348 91611: 0.499999999997 9162 . 9163 9164 @key{RET} ' sin(cos($)) @key{RET} 9165@end group 9166@end smallexample 9167 9168Let's test the new definition again: 9169 9170@smallexample 9171@group 91722: x^2 - 9 1: 3. 91731: 1 . 9174 . 9175 9176 ' x^2-9 @key{RET} 1 X 9177@end group 9178@end smallexample 9179 9180Once again, here's the full Newton's Method definition: 9181 9182@example 9183@group 9184C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1 9185 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET} 9186 @key{RET} M-@key{TAB} a = Z / 9187 Z > 9188 Z ' 9189C-x ) 9190@end group 9191@end example 9192 9193@c [fix-ref Nesting and Fixed Points] 9194It turns out that Calc has a built-in command for applying a formula 9195repeatedly until it converges to a number. @xref{Nesting and Fixed Points}, 9196to see how to use it. 9197 9198@c [fix-ref Root Finding] 9199Also, of course, @kbd{a R} is a built-in command that uses Newton's 9200method (among others) to look for numerical solutions to any equation. 9201@xref{Root Finding}. 9202 9203@node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises 9204@subsection Programming Tutorial Exercise 9 9205 9206@noindent 9207The first step is to adjust @expr{z} to be greater than 5. A simple 9208``for'' loop will do the job here. If @expr{z} is less than 5, we 9209reduce the problem using 9210@texline @math{\psi(z) = \psi(z+1) - 1/z}. 9211@infoline @expr{psi(z) = psi(z+1) - 1/z}. We go 9212on to compute 9213@texline @math{\psi(z+1)}, 9214@infoline @expr{psi(z+1)}, 9215and remember to add back a factor of @expr{-1/z} when we're done. This 9216step is repeated until @expr{z > 5}. 9217 9218(Because this definition is long, it will be repeated in concise form 9219below. You can use @w{@kbd{C-x * m}} to load it from there. While you are 9220entering a @kbd{Z ` Z '} body in a macro, Calc simply collects 9221keystrokes without executing them. In the following diagrams we'll 9222pretend Calc actually executed the keystrokes as you typed them, 9223just for purposes of illustration.) 9224 9225@smallexample 9226@group 92271: 1. 1: 1. 9228 . . 9229 9230 1.0 @key{RET} C-x ( Z ` s 1 0 t 2 9231@end group 9232@end smallexample 9233 9234Here, variable 1 holds @expr{z} and variable 2 holds the adjustment 9235factor. If @expr{z < 5}, we use a loop to increase it. 9236 9237(By the way, we started with @samp{1.0} instead of the integer 1 because 9238otherwise the calculation below will try to do exact fractional arithmetic, 9239and will never converge because fractions compare equal only if they 9240are exactly equal, not just equal to within the current precision.) 9241 9242@smallexample 9243@group 92443: 1. 2: 1. 1: 6. 92452: 1. 1: 1 . 92461: 5 . 9247 . 9248 9249 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] 9250@end group 9251@end smallexample 9252 9253Now we compute the initial part of the sum: 9254@texline @math{\ln z - {1 \over 2z}} 9255@infoline @expr{ln(z) - 1/2z} 9256minus the adjustment factor. 9257 9258@smallexample 9259@group 92602: 1.79175946923 2: 1.7084261359 1: -0.57490719743 92611: 0.0833333333333 1: 2.28333333333 . 9262 . . 9263 9264 L r 1 2 * & - r 2 - 9265@end group 9266@end smallexample 9267 9268Now we evaluate the series. We'll use another ``for'' loop counting 9269up the value of @expr{2 n}. (Calc does have a summation command, 9270@kbd{a +}, but we'll use loops just to get more practice with them.) 9271 9272@smallexample 9273@group 92743: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749 92752: 2 2: 1:6 3: 1:6 1: 2.3148e-3 92761: 40 1: 2 2: 2 . 9277 . . 1: 36. 9278 . 9279 9280 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * / 9281 9282@end group 9283@end smallexample 9284@noindent 9285@smallexample 9286@group 92873: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892 92882: -0.5749 2: -0.5772 1: 0 . 92891: 2.3148e-3 1: -0.5749 . 9290 . . 9291 9292 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x ) 9293@end group 9294@end smallexample 9295 9296This is the value of 9297@texline @math{-\gamma}, 9298@infoline @expr{- gamma}, 9299with a slight bit of roundoff error. To get a full 12 digits, let's use 9300a higher precision: 9301 9302@smallexample 9303@group 93042: -0.577215664892 2: -0.577215664892 93051: 1. 1: -0.577215664901532 9306 9307 1. @key{RET} p 16 @key{RET} X 9308@end group 9309@end smallexample 9310 9311Here's the complete sequence of keystrokes: 9312 9313@example 9314@group 9315C-x ( Z ` s 1 0 t 2 9316 @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] 9317 L r 1 2 * & - r 2 - 9318 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * / 9319 @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 9320 2 Z ) 9321 Z ' 9322C-x ) 9323@end group 9324@end example 9325 9326@node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises 9327@subsection Programming Tutorial Exercise 10 9328 9329@noindent 9330Taking the derivative of a term of the form @expr{x^n} will produce 9331a term like 9332@texline @math{n x^{n-1}}. 9333@infoline @expr{n x^(n-1)}. 9334Taking the derivative of a constant 9335produces zero. From this it is easy to see that the @expr{n}th 9336derivative of a polynomial, evaluated at @expr{x = 0}, will equal the 9337coefficient on the @expr{x^n} term times @expr{n!}. 9338 9339(Because this definition is long, it will be repeated in concise form 9340below. You can use @w{@kbd{C-x * m}} to load it from there. While you are 9341entering a @kbd{Z ` Z '} body in a macro, Calc simply collects 9342keystrokes without executing them. In the following diagrams we'll 9343pretend Calc actually executed the keystrokes as you typed them, 9344just for purposes of illustration.) 9345 9346@smallexample 9347@group 93482: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2 93491: 6 2: 0 9350 . 1: 6 9351 . 9352 9353 ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB} 9354@end group 9355@end smallexample 9356 9357@noindent 9358Variable 1 will accumulate the vector of coefficients. 9359 9360@smallexample 9361@group 93622: 0 3: 0 2: 5 x^4 + ... 93631: 5 x^4 + ... 2: 5 x^4 + ... 1: 1 9364 . 1: 1 . 9365 . 9366 9367 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1 9368@end group 9369@end smallexample 9370 9371@noindent 9372Note that @kbd{s | 1} appends the top-of-stack value to the vector 9373in a variable; it is completely analogous to @kbd{s + 1}. We could 9374have written instead, @kbd{r 1 @key{TAB} | t 1}. 9375 9376@smallexample 9377@group 93781: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0] 9379 . . . 9380 9381 a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x ) 9382@end group 9383@end smallexample 9384 9385To convert back, a simple method is just to map the coefficients 9386against a table of powers of @expr{x}. 9387 9388@smallexample 9389@group 93902: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0] 93911: 6 1: [0, 1, 2, 3, 4, 5, 6] 9392 . . 9393 9394 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x 9395 9396@end group 9397@end smallexample 9398@noindent 9399@smallexample 9400@group 94012: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4 94021: [1, x, x^2, x^3, ... ] . 9403 . 9404 9405 ' x @key{RET} @key{TAB} V M ^ * 9406@end group 9407@end smallexample 9408 9409Once again, here are the whole polynomial to/from vector programs: 9410 9411@example 9412@group 9413C-x ( Z ` [ ] t 1 0 @key{TAB} 9414 Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1 9415 a d x @key{RET} 9416 1 Z ) r 1 9417 Z ' 9418C-x ) 9419 9420C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x ) 9421@end group 9422@end example 9423 9424@node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises 9425@subsection Programming Tutorial Exercise 11 9426 9427@noindent 9428First we define a dummy program to go on the @kbd{z s} key. The true 9429@w{@kbd{z s}} key is supposed to take two numbers from the stack and 9430return one number, so @key{DEL} as a dummy definition will make 9431sure the stack comes out right. 9432 9433@smallexample 9434@group 94352: 4 1: 4 2: 4 94361: 2 . 1: 2 9437 . . 9438 9439 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2 9440@end group 9441@end smallexample 9442 9443The last step replaces the 2 that was eaten during the creation 9444of the dummy @kbd{z s} command. Now we move on to the real 9445definition. The recurrence needs to be rewritten slightly, 9446to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}. 9447 9448(Because this definition is long, it will be repeated in concise form 9449below. You can use @kbd{C-x * m} to load it from there.) 9450 9451@smallexample 9452@group 94532: 4 4: 4 3: 4 2: 4 94541: 2 3: 2 2: 2 1: 2 9455 . 2: 4 1: 0 . 9456 1: 2 . 9457 . 9458 9459 C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z : 9460 9461@end group 9462@end smallexample 9463@noindent 9464@smallexample 9465@group 94664: 4 2: 4 2: 3 4: 3 4: 3 3: 3 94673: 2 1: 2 1: 2 3: 2 3: 2 2: 2 94682: 2 . . 2: 3 2: 3 1: 3 94691: 0 1: 2 1: 1 . 9470 . . . 9471 9472 @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s 9473@end group 9474@end smallexample 9475 9476@noindent 9477(Note that the value 3 that our dummy @kbd{z s} produces is not correct; 9478it is merely a placeholder that will do just as well for now.) 9479 9480@smallexample 9481@group 94823: 3 4: 3 3: 3 2: 3 1: -6 94832: 3 3: 3 2: 3 1: 9 . 94841: 2 2: 3 1: 3 . 9485 . 1: 2 . 9486 . 9487 9488 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * - 9489 9490@end group 9491@end smallexample 9492@noindent 9493@smallexample 9494@group 94951: -6 2: 4 1: 11 2: 11 9496 . 1: 2 . 1: 11 9497 . . 9498 9499 Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s 9500@end group 9501@end smallexample 9502 9503Even though the result that we got during the definition was highly 9504bogus, once the definition is complete the @kbd{z s} command gets 9505the right answers. 9506 9507Here's the full program once again: 9508 9509@example 9510@group 9511C-x ( M-2 @key{RET} a = 9512 Z [ @key{DEL} @key{DEL} 1 9513 Z : @key{RET} 0 a = 9514 Z [ @key{DEL} @key{DEL} 0 9515 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s 9516 M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * - 9517 Z ] 9518 Z ] 9519C-x ) 9520@end group 9521@end example 9522 9523You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro}) 9524followed by @kbd{Z K s}, without having to make a dummy definition 9525first, because @code{read-kbd-macro} doesn't need to execute the 9526definition as it reads it in. For this reason, @code{C-x * m} is often 9527the easiest way to create recursive programs in Calc. 9528 9529@node Programming Answer 12, , Programming Answer 11, Answers to Exercises 9530@subsection Programming Tutorial Exercise 12 9531 9532@noindent 9533This turns out to be a much easier way to solve the problem. Let's 9534denote Stirling numbers as calls of the function @samp{s}. 9535 9536First, we store the rewrite rules corresponding to the definition of 9537Stirling numbers in a convenient variable: 9538 9539@smallexample 9540s e StirlingRules @key{RET} 9541[ s(n,n) := 1 :: n >= 0, 9542 s(n,0) := 0 :: n > 0, 9543 s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ] 9544C-c C-c 9545@end smallexample 9546 9547Now, it's just a matter of applying the rules: 9548 9549@smallexample 9550@group 95512: 4 1: s(4, 2) 1: 11 95521: 2 . . 9553 . 9554 9555 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x ) 9556@end group 9557@end smallexample 9558 9559As in the case of the @code{fib} rules, it would be useful to put these 9560rules in @code{EvalRules} and to add a @samp{:: remember} condition to 9561the last rule. 9562 9563@c This ends the table-of-contents kludge from above: 9564@tex 9565\global\let\chapternofonts=\oldchapternofonts 9566@end tex 9567 9568@c [reference] 9569 9570@node Introduction, Data Types, Tutorial, Top 9571@chapter Introduction 9572 9573@noindent 9574This chapter is the beginning of the Calc reference manual. 9575It covers basic concepts such as the stack, algebraic and 9576numeric entry, undo, numeric prefix arguments, etc. 9577 9578@c [when-split] 9579@c (Chapter 2, the Tutorial, has been printed in a separate volume.) 9580 9581@menu 9582* Basic Commands:: 9583* Help Commands:: 9584* Stack Basics:: 9585* Numeric Entry:: 9586* Algebraic Entry:: 9587* Quick Calculator:: 9588* Prefix Arguments:: 9589* Undo:: 9590* Error Messages:: 9591* Multiple Calculators:: 9592* Troubleshooting Commands:: 9593@end menu 9594 9595@node Basic Commands, Help Commands, Introduction, Introduction 9596@section Basic Commands 9597 9598@noindent 9599@pindex calc 9600@pindex calc-mode 9601@cindex Starting the Calculator 9602@cindex Running the Calculator 9603To start the Calculator in its standard interface, type @kbd{M-x calc}. 9604By default this creates a pair of small windows, @file{*Calculator*} 9605and @file{*Calc Trail*}. The former displays the contents of the 9606Calculator stack and is manipulated exclusively through Calc commands. 9607It is possible (though not usually necessary) to create several Calc 9608mode buffers each of which has an independent stack, undo list, and 9609mode settings. There is exactly one Calc Trail buffer; it records a 9610list of the results of all calculations that have been done. The 9611Calc Trail buffer uses a variant of Calc mode, so Calculator commands 9612still work when the trail buffer's window is selected. It is possible 9613to turn the trail window off, but the @file{*Calc Trail*} buffer itself 9614still exists and is updated silently. @xref{Trail Commands}. 9615 9616@kindex C-x * c 9617@kindex C-x * * 9618@ignore 9619@mindex @null 9620@end ignore 9621In most installations, the @kbd{C-x * c} key sequence is a more 9622convenient way to start the Calculator. Also, @kbd{C-x * *} 9623is a synonym for @kbd{C-x * c} unless you last used Calc 9624in its Keypad mode. 9625 9626@kindex x 9627@kindex M-x 9628@pindex calc-execute-extended-command 9629Most Calc commands use one or two keystrokes. Lower- and upper-case 9630letters are distinct. Commands may also be entered in full @kbd{M-x} form; 9631for some commands this is the only form. As a convenience, the @kbd{x} 9632key (@code{calc-execute-extended-command}) 9633is like @kbd{M-x} except that it enters the initial string @samp{calc-} 9634for you. For example, the following key sequences are equivalent: 9635@kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}. 9636 9637Although Calc is designed to be used from the keyboard, some of 9638Calc's more common commands are available from a menu. In the menu, the 9639arguments to the functions are given by referring to their stack level 9640numbers. 9641 9642@cindex Extensions module 9643@cindex @file{calc-ext} module 9644The Calculator exists in many parts. When you type @kbd{C-x * c}, the 9645Emacs ``auto-load'' mechanism will bring in only the first part, which 9646contains the basic arithmetic functions. The other parts will be 9647auto-loaded the first time you use the more advanced commands like trig 9648functions or matrix operations. This is done to improve the response time 9649of the Calculator in the common case when all you need to do is a 9650little arithmetic. If for some reason the Calculator fails to load an 9651extension module automatically, you can force it to load all the 9652extensions by using the @kbd{C-x * L} (@code{calc-load-everything}) 9653command. @xref{Mode Settings}. 9654 9655If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument, 9656the Calculator is loaded if necessary, but it is not actually started. 9657If the argument is positive, the @file{calc-ext} extensions are also 9658loaded if necessary. User-written Lisp code that wishes to make use 9659of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)} 9660to auto-load the Calculator. 9661 9662@kindex C-x * b 9663@pindex full-calc 9664If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you 9665will get a Calculator that uses the full height of the Emacs screen. 9666When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc} 9667command instead of @code{calc}. From the Unix shell you can type 9668@samp{emacs -f full-calc} to start a new Emacs specifically for use 9669as a calculator. When Calc is started from the Emacs command line 9670like this, Calc's normal ``quit'' commands actually quit Emacs itself. 9671 9672@kindex C-x * o 9673@pindex calc-other-window 9674The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc 9675window is not actually selected. If you are already in the Calc 9676window, @kbd{C-x * o} switches you out of it. (The regular Emacs 9677@kbd{C-x o} command would also work for this, but it has a 9678tendency to drop you into the Calc Trail window instead, which 9679@kbd{C-x * o} takes care not to do.) 9680 9681@ignore 9682@mindex C-x * q 9683@end ignore 9684For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc}) 9685which prompts you for a formula (like @samp{2+3/4}). The result is 9686displayed at the bottom of the Emacs screen without ever creating 9687any special Calculator windows. @xref{Quick Calculator}. 9688 9689@ignore 9690@mindex C-x * k 9691@end ignore 9692Finally, if you are using the X window system you may want to try 9693@kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a 9694``calculator keypad'' picture as well as a stack display. Click on 9695the keys with the mouse to operate the calculator. @xref{Keypad Mode}. 9696 9697@kindex q 9698@pindex calc-quit 9699@cindex Quitting the Calculator 9700@cindex Exiting the Calculator 9701The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the 9702Calculator's window(s). It does not delete the Calculator buffers. 9703If you type @kbd{M-x calc} again, the Calculator will reappear with the 9704contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *} 9705again from inside the Calculator buffer is equivalent to executing 9706@code{calc-quit}; you can think of @kbd{C-x * *} as toggling the 9707Calculator on and off. 9708 9709@kindex C-x * x 9710The @kbd{C-x * x} command also turns the Calculator off, no matter which 9711user interface (standard, Keypad, or Embedded) is currently active. 9712It also cancels @code{calc-edit} mode if used from there. 9713 9714@kindex d SPC 9715@pindex calc-refresh 9716@cindex Refreshing a garbled display 9717@cindex Garbled displays, refreshing 9718The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents 9719of the Calculator buffer from memory. Use this if the contents of the 9720buffer have been damaged somehow. 9721 9722@ignore 9723@mindex o 9724@end ignore 9725The @kbd{o} key (@code{calc-realign}) moves the cursor back to its 9726``home'' position at the bottom of the Calculator buffer. 9727 9728@kindex < 9729@kindex > 9730@pindex calc-scroll-left 9731@pindex calc-scroll-right 9732@cindex Horizontal scrolling 9733@cindex Scrolling 9734@cindex Wide text, scrolling 9735The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and 9736@code{calc-scroll-right}. These are just like the normal horizontal 9737scrolling commands except that they scroll one half-screen at a time by 9738default. (Calc formats its output to fit within the bounds of the 9739window whenever it can.) 9740 9741@kindex @{ 9742@kindex @} 9743@pindex calc-scroll-down 9744@pindex calc-scroll-up 9745@cindex Vertical scrolling 9746The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down} 9747and @code{calc-scroll-up}. They scroll up or down by one-half the 9748height of the Calc window. 9749 9750@kindex C-x * 0 9751@pindex calc-reset 9752The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed 9753by a zero) resets the Calculator to its initial state. This clears 9754the stack, resets all the modes to their initial values (the values 9755that were saved with @kbd{m m} (@code{calc-save-modes})), clears the 9756caches (@pxref{Caches}), and so on. (It does @emph{not} erase the 9757values of any variables.) With an argument of 0, Calc will be reset to 9758its default state; namely, the modes will be given their default values. 9759With a positive prefix argument, @kbd{C-x * 0} preserves the contents of 9760the stack but resets everything else to its initial state; with a 9761negative prefix argument, @kbd{C-x * 0} preserves the contents of the 9762stack but resets everything else to its default state. 9763 9764@node Help Commands, Stack Basics, Basic Commands, Introduction 9765@section Help Commands 9766 9767@noindent 9768@cindex Help commands 9769@kindex ? 9770@kindex a ? 9771@kindex b ? 9772@kindex c ? 9773@kindex d ? 9774@kindex f ? 9775@kindex g ? 9776@kindex j ? 9777@kindex k ? 9778@kindex m ? 9779@kindex r ? 9780@kindex s ? 9781@kindex t ? 9782@kindex u ? 9783@kindex v ? 9784@kindex V ? 9785@kindex z ? 9786@kindex Z ? 9787@pindex calc-help 9788The @kbd{?} key (@code{calc-help}) displays a series of brief help messages. 9789Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs's 9790@key{ESC} and @kbd{C-x} prefixes. You can type 9791@kbd{?} after a prefix to see a list of commands beginning with that 9792prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again 9793to see additional commands for that prefix.) 9794 9795@kindex h h 9796@pindex calc-full-help 9797The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?} 9798responses at once. When printed, this makes a nice, compact (three pages) 9799summary of Calc keystrokes. 9800 9801In general, the @kbd{h} key prefix introduces various commands that 9802provide help within Calc. Many of the @kbd{h} key functions are 9803Calc-specific analogues to the @kbd{C-h} functions for Emacs help. 9804 9805@kindex h i 9806@kindex C-x * i 9807@kindex i 9808@pindex calc-info 9809The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system 9810to read this manual on-line. This is basically the same as typing 9811@kbd{C-h i} (the regular way to run the Info system), then, if Info 9812is not already in the Calc manual, selecting the beginning of the 9813manual. The @kbd{C-x * i} command is another way to read the Calc 9814manual; it is different from @kbd{h i} in that it works any time, 9815not just inside Calc. The plain @kbd{i} key is also equivalent to 9816@kbd{h i}, though this key is obsolete and may be replaced with a 9817different command in a future version of Calc. 9818 9819@kindex h t 9820@kindex C-x * t 9821@pindex calc-tutorial 9822The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on 9823the Tutorial section of the Calc manual. It is like @kbd{h i}, 9824except that it selects the starting node of the tutorial rather 9825than the beginning of the whole manual. (It actually selects the 9826node ``Interactive Tutorial'' which tells a few things about 9827using the Info system before going on to the actual tutorial.) 9828The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at 9829all times). 9830 9831@kindex h s 9832@kindex C-x * s 9833@pindex calc-info-summary 9834The @kbd{h s} (@code{calc-info-summary}) command runs the Info system 9835on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s} 9836key is equivalent to @kbd{h s}. 9837 9838@kindex h k 9839@pindex calc-describe-key 9840The @kbd{h k} (@code{calc-describe-key}) command looks up a key 9841sequence in the Calc manual. For example, @kbd{h k H a S} looks 9842up the documentation on the @kbd{H a S} (@code{calc-solve-for}) 9843command. This works by looking up the textual description of 9844the key(s) in the Key Index of the manual, then jumping to the 9845node indicated by the index. 9846 9847Most Calc commands do not have traditional Emacs documentation 9848strings, since the @kbd{h k} command is both more convenient and 9849more instructive. This means the regular Emacs @kbd{C-h k} 9850(@code{describe-key}) command will not be useful for Calc keystrokes. 9851 9852@kindex h c 9853@pindex calc-describe-key-briefly 9854The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a 9855key sequence and displays a brief one-line description of it at 9856the bottom of the screen. It looks for the key sequence in the 9857Summary node of the Calc manual; if it doesn't find the sequence 9858there, it acts just like its regular Emacs counterpart @kbd{C-h c} 9859(@code{describe-key-briefly}). For example, @kbd{h c H a S} 9860gives the description: 9861 9862@smallexample 9863H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes) 9864@end smallexample 9865 9866@noindent 9867which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for} 9868takes a value @expr{a} from the stack, prompts for a value @expr{v}, 9869then applies the algebraic function @code{fsolve} to these values. 9870The @samp{?=notes} message means you can now type @kbd{?} to see 9871additional notes from the summary that apply to this command. 9872 9873@kindex h f 9874@pindex calc-describe-function 9875The @kbd{h f} (@code{calc-describe-function}) command looks up an 9876algebraic function or a command name in the Calc manual. Enter an 9877algebraic function name to look up that function in the Function 9878Index or enter a command name beginning with @samp{calc-} to look it 9879up in the Command Index. This command will also look up operator 9880symbols that can appear in algebraic formulas, like @samp{%} and 9881@samp{=>}. 9882 9883@kindex h v 9884@pindex calc-describe-variable 9885The @kbd{h v} (@code{calc-describe-variable}) command looks up a 9886variable in the Calc manual. Enter a variable name like @code{pi} or 9887@code{PlotRejects}. 9888 9889@kindex h b 9890@pindex describe-bindings 9891The @kbd{h b} (@code{calc-describe-bindings}) command is just like 9892@kbd{C-h b}, except that only local (Calc-related) key bindings are 9893listed. 9894 9895@kindex h n 9896The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays 9897the ``news'' or change history of Emacs, and jumps to the most recent 9898portion concerning Calc (if present). For older history, see the file 9899@file{etc/CALC-NEWS} in the Emacs distribution. 9900 9901@kindex h C-c 9902@kindex h C-d 9903@kindex h C-w 9904The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying, 9905distribution, and warranty information about Calc. These work by 9906pulling up the appropriate parts of the ``Copying'' or ``Reporting 9907Bugs'' sections of the manual. 9908 9909@node Stack Basics, Numeric Entry, Help Commands, Introduction 9910@section Stack Basics 9911 9912@noindent 9913@cindex Stack basics 9914@c [fix-tut RPN Calculations and the Stack] 9915Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN 9916Tutorial}. 9917 9918To add the numbers 1 and 2 in Calc you would type the keys: 9919@kbd{1 @key{RET} 2 +}. 9920(@key{RET} corresponds to the @key{ENTER} key on most calculators.) 9921The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The 9922@kbd{+} key always ``pops'' the top two numbers from the stack, adds them, 9923and pushes the result (3) back onto the stack. This number is ready for 9924further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the 99253 and 5, subtracts them, and pushes the result (@mathit{-2}). 9926 9927Note that the ``top'' of the stack actually appears at the @emph{bottom} 9928of the buffer. A line containing a single @samp{.} character signifies 9929the end of the buffer; Calculator commands operate on the number(s) 9930directly above this line. The @kbd{d t} (@code{calc-truncate-stack}) 9931command allows you to move the @samp{.} marker up and down in the stack; 9932@pxref{Truncating the Stack}. 9933 9934@kindex d l 9935@pindex calc-line-numbering 9936Stack elements are numbered consecutively, with number 1 being the top of 9937the stack. These line numbers are ordinarily displayed on the lefthand side 9938of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls 9939whether these numbers appear. (Line numbers may be turned off since they 9940slow the Calculator down a bit and also clutter the display.) 9941 9942@kindex o 9943@pindex calc-realign 9944The unshifted letter @kbd{o} (@code{calc-realign}) command repositions 9945the cursor to its top-of-stack ``home'' position. It also undoes any 9946horizontal scrolling in the window. If you give it a numeric prefix 9947argument, it instead moves the cursor to the specified stack element. 9948 9949The @key{RET} (or equivalent @key{SPC}) key is only required to separate 9950two consecutive numbers. 9951(After all, if you typed @kbd{1 2} by themselves the Calculator 9952would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not} 9953right after typing a number, the key duplicates the number on the top of 9954the stack. @kbd{@key{RET} *} is thus a handy way to square a number. 9955 9956The @key{DEL} key pops and throws away the top number on the stack. 9957The @key{TAB} key swaps the top two objects on the stack. 9958@xref{Stack and Trail}, for descriptions of these and other stack-related 9959commands. 9960 9961@node Numeric Entry, Algebraic Entry, Stack Basics, Introduction 9962@section Numeric Entry 9963 9964@noindent 9965@kindex 0-9 9966@kindex . 9967@kindex e 9968@cindex Numeric entry 9969@cindex Entering numbers 9970Pressing a digit or other numeric key begins numeric entry using the 9971minibuffer. The number is pushed on the stack when you press the @key{RET} 9972or @key{SPC} keys. If you press any other non-numeric key, the number is 9973pushed onto the stack and the appropriate operation is performed. If 9974you press a numeric key which is not valid, the key is ignored. 9975 9976@cindex Minus signs 9977@cindex Negative numbers, entering 9978@kindex _ 9979There are three different concepts corresponding to the word ``minus,'' 9980typified by @expr{a-b} (subtraction), @expr{-x} 9981(change-sign), and @expr{-5} (negative number). Calc uses three 9982different keys for these operations, respectively: 9983@kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts 9984the two numbers on the top of the stack. The @kbd{n} key changes the sign 9985of the number on the top of the stack or the number currently being entered. 9986The @kbd{_} key begins entry of a negative number or changes the sign of 9987the number currently being entered. The following sequences all enter the 9988number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}}, 9989@kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}. 9990 9991Some other keys are active during numeric entry, such as @kbd{#} for 9992non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms. 9993These notations are described later in this manual with the corresponding 9994data types. @xref{Data Types}. 9995 9996During numeric entry, the only editing key available is @key{DEL}. 9997 9998@node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction 9999@section Algebraic Entry 10000 10001@noindent 10002@kindex ' 10003@pindex calc-algebraic-entry 10004@cindex Algebraic notation 10005@cindex Formulas, entering 10006The @kbd{'} (@code{calc-algebraic-entry}) command can be used to enter 10007calculations in algebraic form. This is accomplished by typing the 10008apostrophe key, ', followed by the expression in standard format: 10009 10010@example 10011' 2+3*4 @key{RET}. 10012@end example 10013 10014@noindent 10015This will compute 10016@texline @math{2+(3\times4) = 14} 10017@infoline @expr{2+(3*4) = 14} 10018and push it on the stack. If you wish you can 10019ignore the RPN aspect of Calc altogether and simply enter algebraic 10020expressions in this way. You may want to use @key{DEL} every so often to 10021clear previous results off the stack. 10022 10023You can press the apostrophe key during normal numeric entry to switch 10024the half-entered number into Algebraic entry mode. One reason to do 10025this would be to fix a typo, as the full Emacs cursor motion and editing 10026keys are available during algebraic entry but not during numeric entry. 10027 10028In the same vein, during either numeric or algebraic entry you can 10029press @kbd{`} (grave accent) to switch to @code{calc-edit} mode, where 10030you complete your half-finished entry in a separate buffer. 10031@xref{Editing Stack Entries}. 10032 10033@kindex m a 10034@pindex calc-algebraic-mode 10035@cindex Algebraic Mode 10036If you prefer algebraic entry, you can use the command @kbd{m a} 10037(@code{calc-algebraic-mode}) to set Algebraic mode. In this mode, 10038digits and other keys that would normally start numeric entry instead 10039start full algebraic entry; as long as your formula begins with a digit 10040you can omit the apostrophe. Open parentheses and square brackets also 10041begin algebraic entry. You can still do RPN calculations in this mode, 10042but you will have to press @key{RET} to terminate every number: 10043@kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same 10044thing as @kbd{2*3+4 @key{RET}}. 10045 10046@cindex Incomplete Algebraic Mode 10047If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a} 10048command, it enables Incomplete Algebraic mode; this is like regular 10049Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys 10050only. Numeric keys still begin a numeric entry in this mode. 10051 10052@kindex m t 10053@pindex calc-total-algebraic-mode 10054@cindex Total Algebraic Mode 10055The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even 10056stronger algebraic-entry mode, in which @emph{all} regular letter and 10057punctuation keys begin algebraic entry. Use this if you prefer typing 10058@w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of 10059@kbd{a f}, and so on. To type regular Calc commands when you are in 10060Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q} 10061is the command to quit Calc, @kbd{M-p} sets the precision, and 10062@kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic 10063mode back off again. Meta keys also terminate algebraic entry, so 10064that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol 10065@samp{Alg*} will appear in the mode line whenever you are in this mode. 10066 10067Pressing @kbd{'} (the apostrophe) a second time re-enters the previous 10068algebraic formula. You can then use the normal Emacs editing keys to 10069modify this formula to your liking before pressing @key{RET}. 10070 10071@kindex $ 10072@cindex Formulas, referring to stack 10073Within a formula entered from the keyboard, the symbol @kbd{$} 10074represents the number on the top of the stack. If an entered formula 10075contains any @kbd{$} characters, the Calculator replaces the top of 10076stack with that formula rather than simply pushing the formula onto the 10077stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2 10078@key{RET}} replaces it with 6. Note that the @kbd{$} key always 10079initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the 10080first character in the new formula. 10081 10082Higher stack elements can be accessed from an entered formula with the 10083symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements 10084removed (to be replaced by the entered values) equals the number of dollar 10085signs in the longest such symbol in the formula. For example, @samp{$$+$$$} 10086adds the second and third stack elements, replacing the top three elements 10087with the answer. (All information about the top stack element is thus lost 10088since no single @samp{$} appears in this formula.) 10089 10090A slightly different way to refer to stack elements is with a dollar 10091sign followed by a number: @samp{$1}, @samp{$2}, and so on are much 10092like @samp{$}, @samp{$$}, etc., except that stack entries referred 10093to numerically are not replaced by the algebraic entry. That is, while 10094@samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5 10095on the stack and pushes an additional 6. 10096 10097If a sequence of formulas are entered separated by commas, each formula 10098is pushed onto the stack in turn. For example, @samp{1,2,3} pushes 10099those three numbers onto the stack (leaving the 3 at the top), and 10100@samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also, 10101@samp{$,$$} exchanges the top two elements of the stack, just like the 10102@key{TAB} key. 10103 10104You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead 10105of @key{RET}. This uses @kbd{=} to evaluate the variables in each 10106formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes 10107the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.) 10108 10109If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j}) 10110instead of @key{RET}, Calc disables simplification 10111(as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry 10112is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3 10113on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2}; 10114you might then press @kbd{=} when it is time to evaluate this formula. 10115 10116@node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction 10117@section ``Quick Calculator'' Mode 10118 10119@noindent 10120@kindex C-x * q 10121@pindex quick-calc 10122@cindex Quick Calculator 10123There is another way to invoke the Calculator if all you need to do 10124is make one or two quick calculations. Type @kbd{C-x * q} (or 10125@kbd{M-x quick-calc}), then type any formula as an algebraic entry. 10126The Calculator will compute the result and display it in the echo 10127area, without ever actually putting up a Calc window. 10128 10129You can use the @kbd{$} character in a Quick Calculator formula to 10130refer to the previous Quick Calculator result. Older results are 10131not retained; the Quick Calculator has no effect on the full 10132Calculator's stack or trail. If you compute a result and then 10133forget what it was, just run @code{C-x * q} again and enter 10134@samp{$} as the formula. 10135 10136If this is the first time you have used the Calculator in this Emacs 10137session, the @kbd{C-x * q} command will create the @file{*Calculator*} 10138buffer and perform all the usual initializations; it simply will 10139refrain from putting that buffer up in a new window. The Quick 10140Calculator refers to the @file{*Calculator*} buffer for all mode 10141settings. Thus, for example, to set the precision that the Quick 10142Calculator uses, simply run the full Calculator momentarily and use 10143the regular @kbd{p} command. 10144 10145If you use @code{C-x * q} from inside the Calculator buffer, the 10146effect is the same as pressing the apostrophe key (algebraic entry). 10147 10148The result of a Quick calculation is placed in the Emacs ``kill ring'' 10149as well as being displayed. A subsequent @kbd{C-y} command will 10150yank the result into the editing buffer. You can also use this 10151to yank the result into the next @kbd{C-x * q} input line as a more 10152explicit alternative to @kbd{$} notation, or to yank the result 10153into the Calculator stack after typing @kbd{C-x * c}. 10154 10155If you give a prefix argument to @kbd{C-x * q} or finish your formula 10156by typing @key{LFD} (or @kbd{C-j}) instead of @key{RET}, the result is 10157inserted immediately into the current buffer rather than going into 10158the kill ring. 10159 10160Quick Calculator results are actually evaluated as if by the @kbd{=} 10161key (which replaces variable names by their stored values, if any). 10162If the formula you enter is an assignment to a variable using the 10163@samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1}, 10164then the result of the evaluation is stored in that Calc variable. 10165@xref{Store and Recall}. 10166 10167If the result is an integer and the current display radix is decimal, 10168the number will also be displayed in hex, octal and binary formats. If 10169the integer is in the range from 1 to 126, it will also be displayed as 10170an ASCII character. 10171 10172For example, the quoted character @samp{"x"} produces the vector 10173result @samp{[120]} (because 120 is the ASCII code of the lower-case 10174``x''; @pxref{Strings}). Since this is a vector, not an integer, it 10175is displayed only according to the current mode settings. But 10176running Quick Calc again and entering @samp{120} will produce the 10177result @samp{120 (16#78, 8#170, x)} which shows the number in its 10178decimal, hexadecimal, octal, and ASCII forms. 10179 10180Please note that the Quick Calculator is not any faster at loading 10181or computing the answer than the full Calculator; the name ``quick'' 10182merely refers to the fact that it's much less hassle to use for 10183small calculations. 10184 10185@node Prefix Arguments, Undo, Quick Calculator, Introduction 10186@section Numeric Prefix Arguments 10187 10188@noindent 10189Many Calculator commands use numeric prefix arguments. Some, such as 10190@kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of 10191the prefix argument or use a default if you don't use a prefix. 10192Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument 10193and prompt for a number if you don't give one as a prefix. 10194 10195As a rule, stack-manipulation commands accept a numeric prefix argument 10196which is interpreted as an index into the stack. A positive argument 10197operates on the top @var{n} stack entries; a negative argument operates 10198on the @var{n}th stack entry in isolation; and a zero argument operates 10199on the entire stack. 10200 10201Most commands that perform computations (such as the arithmetic and 10202scientific functions) accept a numeric prefix argument that allows the 10203operation to be applied across many stack elements. For unary operations 10204(that is, functions of one argument like absolute value or complex 10205conjugate), a positive prefix argument applies that function to the top 10206@var{n} stack entries simultaneously, and a negative argument applies it 10207to the @var{n}th stack entry only. For binary operations (functions of 10208two arguments like addition, GCD, and vector concatenation), a positive 10209prefix argument ``reduces'' the function across the top @var{n} 10210stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries; 10211@pxref{Reducing and Mapping}), and a negative argument maps the next-to-top 10212@var{n} stack elements with the top stack element as a second argument 10213(for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements). 10214This feature is not available for operations which use the numeric prefix 10215argument for some other purpose. 10216 10217Numeric prefixes are specified the same way as always in Emacs: Press 10218a sequence of @key{META}-digits, or press @key{ESC} followed by digits, 10219or press @kbd{C-u} followed by digits. Some commands treat plain 10220@kbd{C-u} (without any actual digits) specially. 10221 10222@kindex ~ 10223@pindex calc-num-prefix 10224You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the 10225top of the stack and enter it as the numeric prefix for the next command. 10226For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate 10227(silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2 10228to the fourth power and set the precision to that value. 10229 10230Conversely, if you have typed a numeric prefix argument the @kbd{~} key 10231pushes it onto the stack in the form of an integer. 10232 10233@node Undo, Error Messages, Prefix Arguments, Introduction 10234@section Undoing Mistakes 10235 10236@noindent 10237@kindex U 10238@kindex C-_ 10239@pindex calc-undo 10240@cindex Mistakes, undoing 10241@cindex Undoing mistakes 10242@cindex Errors, undoing 10243The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation. 10244If that operation added or dropped objects from the stack, those objects 10245are removed or restored. If it was a ``store'' operation, you are 10246queried whether or not to restore the variable to its original value. 10247The @kbd{U} key may be pressed any number of times to undo successively 10248farther back in time; with a numeric prefix argument it undoes a 10249specified number of operations. When the Calculator is quit, as with 10250the @kbd{q} (@code{calc-quit}) command, the undo history will be 10251truncated to the length of the customizable variable 10252@code{calc-undo-length} (@pxref{Customizing Calc}), which by default 10253is @expr{100}. (Recall that @kbd{C-x * c} is synonymous with 10254@code{calc-quit} while inside the Calculator; this also truncates the 10255undo history.) 10256 10257Currently the mode-setting commands (like @code{calc-precision}) are not 10258undoable. You can undo past a point where you changed a mode, but you 10259will need to reset the mode yourself. 10260 10261@kindex D 10262@pindex calc-redo 10263@cindex Redoing after an Undo 10264The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was 10265mistakenly undone. Pressing @kbd{U} with a negative prefix argument is 10266equivalent to executing @code{calc-redo}. You can redo any number of 10267times, up to the number of recent consecutive undo commands. Redo 10268information is cleared whenever you give any command that adds new undo 10269information, i.e., if you undo, then enter a number on the stack or make 10270any other change, then it will be too late to redo. 10271 10272@kindex M-RET 10273@pindex calc-last-args 10274@cindex Last-arguments feature 10275@cindex Arguments, restoring 10276The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that 10277it restores the arguments of the most recent command onto the stack; 10278however, it does not remove the result of that command. Given a numeric 10279prefix argument, this command applies to the @expr{n}th most recent 10280command which removed items from the stack; it pushes those items back 10281onto the stack. 10282 10283The @kbd{K} (@code{calc-keep-args}) command provides a related function 10284to @kbd{M-@key{RET}}. @xref{Stack and Trail}. 10285 10286It is also possible to recall previous results or inputs using the trail. 10287@xref{Trail Commands}. 10288 10289The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}. 10290 10291@node Error Messages, Multiple Calculators, Undo, Introduction 10292@section Error Messages 10293 10294@noindent 10295@kindex w 10296@pindex calc-why 10297@cindex Errors, messages 10298@cindex Why did an error occur? 10299Many situations that would produce an error message in other calculators 10300simply create unsimplified formulas in the Emacs Calculator. For example, 10301@kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes 10302the formula @samp{ln(0)}. Floating-point overflow and underflow are also 10303reasons for this to happen. 10304 10305When a function call must be left in symbolic form, Calc usually 10306produces a message explaining why. Messages that are probably 10307surprising or indicative of user errors are displayed automatically. 10308Other messages are simply kept in Calc's memory and are displayed only 10309if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if 10310the same computation results in several messages. (The first message 10311will end with @samp{[w=more]} in this case.) 10312 10313@kindex d w 10314@pindex calc-auto-why 10315The @kbd{d w} (@code{calc-auto-why}) command controls when error messages 10316are displayed automatically. (Calc effectively presses @kbd{w} for you 10317after your computation finishes.) By default, this occurs only for 10318``important'' messages. The other possible modes are to report 10319@emph{all} messages automatically, or to report none automatically (so 10320that you must always press @kbd{w} yourself to see the messages). 10321 10322@node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction 10323@section Multiple Calculators 10324 10325@noindent 10326@pindex another-calc 10327It is possible to have any number of Calc mode buffers at once. 10328Usually this is done by executing @kbd{M-x another-calc}, which 10329is similar to @kbd{C-x * c} except that if a @file{*Calculator*} 10330buffer already exists, a new, independent one with a name of the 10331form @file{*Calculator*<@var{n}>} is created. You can also use the 10332command @code{calc-mode} to put any buffer into Calculator mode, but 10333this would ordinarily never be done. 10334 10335The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer; 10336it only closes its window. Use @kbd{M-x kill-buffer} to destroy a 10337Calculator buffer. 10338 10339Each Calculator buffer keeps its own stack, undo list, and mode settings 10340such as precision, angular mode, and display formats. In Emacs terms, 10341variables such as @code{calc-stack} are buffer-local variables. The 10342global default values of these variables are used only when a new 10343Calculator buffer is created. The @code{calc-quit} command saves 10344the stack and mode settings of the buffer being quit as the new defaults. 10345 10346There is only one trail buffer, @file{*Calc Trail*}, used by all 10347Calculator buffers. 10348 10349@node Troubleshooting Commands, , Multiple Calculators, Introduction 10350@section Troubleshooting Commands 10351 10352@noindent 10353This section describes commands you can use in case a computation 10354incorrectly fails or gives the wrong answer. 10355 10356@xref{Reporting Bugs}, if you find a problem that appears to be due 10357to a bug or deficiency in Calc. 10358 10359@menu 10360* Autoloading Problems:: 10361* Recursion Depth:: 10362* Caches:: 10363* Debugging Calc:: 10364@end menu 10365 10366@node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands 10367@subsection Autoloading Problems 10368 10369@noindent 10370The Calc program is split into many component files; components are 10371loaded automatically as you use various commands that require them. 10372Occasionally Calc may lose track of when a certain component is 10373necessary; typically this means you will type a command and it won't 10374work because some function you've never heard of was undefined. 10375 10376@kindex C-x * L 10377@pindex calc-load-everything 10378If this happens, the easiest workaround is to type @kbd{C-x * L} 10379(@code{calc-load-everything}) to force all the parts of Calc to be 10380loaded right away. This will cause Emacs to take up a lot more 10381memory than it would otherwise, but it's guaranteed to fix the problem. 10382 10383@node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands 10384@subsection Recursion Depth 10385 10386@noindent 10387@kindex M 10388@kindex I M 10389@pindex calc-more-recursion-depth 10390@pindex calc-less-recursion-depth 10391@cindex Recursion depth 10392@cindex ``Computation got stuck'' message 10393@cindex @code{max-lisp-eval-depth} 10394@cindex @code{max-specpdl-size} 10395Calc uses recursion in many of its calculations. Emacs Lisp keeps a 10396variable @code{max-lisp-eval-depth} which limits the amount of recursion 10397possible in an attempt to recover from program bugs. If a calculation 10398ever halts incorrectly with the message ``Computation got stuck or 10399ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth}) 10400to increase this limit. (Of course, this will not help if the 10401calculation really did get stuck due to some problem inside Calc.) 10402 10403The limit is always increased (multiplied) by a factor of two. There 10404is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which 10405decreases this limit by a factor of two, down to a minimum value of 200. 10406The default value is 1000. 10407 10408These commands also double or halve @code{max-specpdl-size}, another 10409internal Lisp recursion limit. The minimum value for this limit is 600. 10410 10411@node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands 10412@subsection Caches 10413 10414@noindent 10415@cindex Caches 10416@cindex Flushing caches 10417Calc saves certain values after they have been computed once. For 10418example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the 10419constant @cpi{} to about 20 decimal places; if the current precision 10420is greater than this, it will recompute @cpi{} using a series 10421approximation. This value will not need to be recomputed ever again 10422unless you raise the precision still further. Many operations such as 10423logarithms and sines make use of similarly cached values such as 10424@cpiover{4} and 10425@texline @math{\ln 2}. 10426@infoline @expr{ln(2)}. 10427The visible effect of caching is that 10428high-precision computations may seem to do extra work the first time. 10429Other things cached include powers of two (for the binary arithmetic 10430functions), matrix inverses and determinants, symbolic integrals, and 10431data points computed by the graphing commands. 10432 10433@pindex calc-flush-caches 10434If you suspect a Calculator cache has become corrupt, you can use the 10435@code{calc-flush-caches} command to reset all caches to the empty state. 10436(This should only be necessary in the event of bugs in the Calculator.) 10437The @kbd{C-x * 0} (with the zero key) command also resets caches along 10438with all other aspects of the Calculator's state. 10439 10440@node Debugging Calc, , Caches, Troubleshooting Commands 10441@subsection Debugging Calc 10442 10443@noindent 10444A few commands exist to help in the debugging of Calc commands. 10445@xref{Programming}, to see the various ways that you can write 10446your own Calc commands. 10447 10448@kindex Z T 10449@pindex calc-timing 10450The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode 10451in which the timing of slow commands is reported in the Trail. 10452Any Calc command that takes two seconds or longer writes a line 10453to the Trail showing how many seconds it took. This value is 10454accurate only to within one second. 10455 10456All steps of executing a command are included; in particular, time 10457taken to format the result for display in the stack and trail is 10458counted. Some prompts also count time taken waiting for them to 10459be answered, while others do not; this depends on the exact 10460implementation of the command. For best results, if you are timing 10461a sequence that includes prompts or multiple commands, define a 10462keyboard macro to run the whole sequence at once. Calc's @kbd{X} 10463command (@pxref{Keyboard Macros}) will then report the time taken 10464to execute the whole macro. 10465 10466Another advantage of the @kbd{X} command is that while it is 10467executing, the stack and trail are not updated from step to step. 10468So if you expect the output of your test sequence to leave a result 10469that may take a long time to format and you don't wish to count 10470this formatting time, end your sequence with a @key{DEL} keystroke 10471to clear the result from the stack. When you run the sequence with 10472@kbd{X}, Calc will never bother to format the large result. 10473 10474Another thing @kbd{Z T} does is to increase the Emacs variable 10475@code{gc-cons-threshold} to a much higher value (two million; the 10476usual default in Calc is 250,000) for the duration of each command. 10477This generally prevents garbage collection during the timing of 10478the command, though it may cause your Emacs process to grow 10479abnormally large. (Garbage collection time is a major unpredictable 10480factor in the timing of Emacs operations.) 10481 10482Another command that is useful when debugging your own Lisp 10483extensions to Calc is @kbd{M-x calc-pass-errors}, which disables 10484the error handler that changes the ``@code{max-lisp-eval-depth} 10485exceeded'' message to the much more friendly ``Computation got 10486stuck or ran too long.'' This handler interferes with the Emacs 10487Lisp debugger's @code{debug-on-error} mode. Errors are reported 10488in the handler itself rather than at the true location of the 10489error. After you have executed @code{calc-pass-errors}, Lisp 10490errors will be reported correctly but the user-friendly message 10491will be lost. 10492 10493@node Data Types, Stack and Trail, Introduction, Top 10494@chapter Data Types 10495 10496@noindent 10497This chapter discusses the various types of objects that can be placed 10498on the Calculator stack, how they are displayed, and how they are 10499entered. (@xref{Data Type Formats}, for information on how these data 10500types are represented as underlying Lisp objects.) 10501 10502Integers, fractions, and floats are various ways of describing real 10503numbers. HMS forms also for many purposes act as real numbers. These 10504types can be combined to form complex numbers, modulo forms, error forms, 10505or interval forms. (But these last four types cannot be combined 10506arbitrarily: error forms may not contain modulo forms, for example.) 10507Finally, all these types of numbers may be combined into vectors, 10508matrices, or algebraic formulas. 10509 10510@menu 10511* Integers:: The most basic data type. 10512* Fractions:: This and above are called @dfn{rationals}. 10513* Floats:: This and above are called @dfn{reals}. 10514* Complex Numbers:: This and above are called @dfn{numbers}. 10515* Infinities:: 10516* Vectors and Matrices:: 10517* Strings:: 10518* HMS Forms:: 10519* Date Forms:: 10520* Modulo Forms:: 10521* Error Forms:: 10522* Interval Forms:: 10523* Incomplete Objects:: 10524* Variables:: 10525* Formulas:: 10526@end menu 10527 10528@node Integers, Fractions, Data Types, Data Types 10529@section Integers 10530 10531@noindent 10532@cindex Integers 10533The Calculator stores integers to arbitrary precision. Addition, 10534subtraction, and multiplication of integers always yields an exact 10535integer result. (If the result of a division or exponentiation of 10536integers is not an integer, it is expressed in fractional or 10537floating-point form according to the current Fraction mode. 10538@xref{Fraction Mode}.) 10539 10540A decimal integer is represented as an optional sign followed by a 10541sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to 10542insert a comma at every third digit for display purposes, but you 10543must not type commas during the entry of numbers. 10544 10545@kindex # 10546A non-decimal integer is represented as an optional sign, a radix 10547between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11 10548and above, the letters A through Z (upper- or lower-case) count as 10549digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how 10550to set the default radix for display of integers. Numbers of any radix 10551may be entered at any time. If you press @kbd{#} at the beginning of a 10552number, the current display radix is used. 10553 10554@node Fractions, Floats, Integers, Data Types 10555@section Fractions 10556 10557@noindent 10558@cindex Fractions 10559A @dfn{fraction} is a ratio of two integers. Fractions are traditionally 10560written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key 10561performs RPN division; the following two sequences push the number 10562@samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /} 10563assuming Fraction mode has been enabled.) 10564When the Calculator produces a fractional result it always reduces it to 10565simplest form, which may in fact be an integer. 10566 10567Fractions may also be entered in a three-part form, where @samp{2:3:4} 10568represents two-and-three-quarters. @xref{Fraction Formats}, for fraction 10569display formats. 10570 10571Non-decimal fractions are entered and displayed as 10572@samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part 10573form). The numerator and denominator always use the same radix. 10574 10575@node Floats, Complex Numbers, Fractions, Data Types 10576@section Floats 10577 10578@noindent 10579@cindex Floating-point numbers 10580A floating-point number or @dfn{float} is a number stored in scientific 10581notation. The number of significant digits in the fractional part is 10582governed by the current floating precision (@pxref{Precision}). The 10583range of acceptable values is from 10584@texline @math{10^{-3999999}} 10585@infoline @expr{10^-3999999} 10586(inclusive) to 10587@texline @math{10^{4000000}} 10588@infoline @expr{10^4000000} 10589(exclusive), plus the corresponding negative values and zero. 10590 10591Calculations that would exceed the allowable range of values (such 10592as @samp{exp(exp(20))}) are left in symbolic form by Calc. The 10593messages ``floating-point overflow'' or ``floating-point underflow'' 10594indicate that during the calculation a number would have been produced 10595that was too large or too close to zero, respectively, to be represented 10596by Calc. This does not necessarily mean the final result would have 10597overflowed, just that an overflow occurred while computing the result. 10598(In fact, it could report an underflow even though the final result 10599would have overflowed!) 10600 10601If a rational number and a float are mixed in a calculation, the result 10602will in general be expressed as a float. Commands that require an integer 10603value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued 10604floats, i.e., floating-point numbers with nothing after the decimal point. 10605 10606Floats are identified by the presence of a decimal point and/or an 10607exponent. In general a float consists of an optional sign, digits 10608including an optional decimal point, and an optional exponent consisting 10609of an @samp{e}, an optional sign, and up to seven exponent digits. 10610For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power, 10611or 0.235. 10612 10613Floating-point numbers are normally displayed in decimal notation with 10614all significant figures shown. Exceedingly large or small numbers are 10615displayed in scientific notation. Various other display options are 10616available. @xref{Float Formats}. 10617 10618@cindex Accuracy of calculations 10619Floating-point numbers are stored in decimal, not binary. The result 10620of each operation is rounded to the nearest value representable in the 10621number of significant digits specified by the current precision, 10622rounding away from zero in the case of a tie. Thus (in the default 10623display mode) what you see is exactly what you get. Some operations such 10624as square roots and transcendental functions are performed with several 10625digits of extra precision and then rounded down, in an effort to make the 10626final result accurate to the full requested precision. However, 10627accuracy is not rigorously guaranteed. If you suspect the validity of a 10628result, try doing the same calculation in a higher precision. The 10629Calculator's arithmetic is not intended to be IEEE-conformant in any 10630way. 10631 10632While floats are always @emph{stored} in decimal, they can be entered 10633and displayed in any radix just like integers and fractions. Since a 10634float that is entered in a radix other that 10 will be converted to 10635decimal, the number that Calc stores may not be exactly the number that 10636was entered, it will be the closest decimal approximation given the 10637current precision. The notation @samp{@var{radix}#@var{ddd}.@var{ddd}} 10638is a floating-point number whose digits are in the specified radix. 10639Note that the @samp{.} is more aptly referred to as a ``radix point'' 10640than as a decimal point in this case. The number @samp{8#123.4567} is 10641defined as @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can 10642use @samp{e} notation to write a non-decimal number in scientific 10643notation. The exponent is written in decimal, and is considered to be a 10644power of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, 10645the letter @samp{e} is a digit, so scientific notation must be written 10646out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the 10647Modes Tutorial explore some of the properties of non-decimal floats. 10648 10649@node Complex Numbers, Infinities, Floats, Data Types 10650@section Complex Numbers 10651 10652@noindent 10653@cindex Complex numbers 10654There are two supported formats for complex numbers: rectangular and 10655polar. The default format is rectangular, displayed in the form 10656@samp{(@var{real},@var{imag})} where @var{real} is the real part and 10657@var{imag} is the imaginary part, each of which may be any real number. 10658Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i} 10659notation; @pxref{Complex Formats}. 10660 10661Polar complex numbers are displayed in the form 10662@texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}' 10663@infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}' 10664where @var{r} is the nonnegative magnitude and 10665@texline @math{\theta} 10666@infoline @var{theta} 10667is the argument or phase angle. The range of 10668@texline @math{\theta} 10669@infoline @var{theta} 10670depends on the current angular mode (@pxref{Angular Modes}); it is 10671generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range 10672in radians. 10673 10674Complex numbers are entered in stages using incomplete objects. 10675@xref{Incomplete Objects}. 10676 10677Operations on rectangular complex numbers yield rectangular complex 10678results, and similarly for polar complex numbers. Where the two types 10679are mixed, or where new complex numbers arise (as for the square root of 10680a negative real), the current @dfn{Polar mode} is used to determine the 10681type. @xref{Polar Mode}. 10682 10683A complex result in which the imaginary part is zero (or the phase angle 10684is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real 10685number. 10686 10687@node Infinities, Vectors and Matrices, Complex Numbers, Data Types 10688@section Infinities 10689 10690@noindent 10691@cindex Infinity 10692@cindex @code{inf} variable 10693@cindex @code{uinf} variable 10694@cindex @code{nan} variable 10695@vindex inf 10696@vindex uinf 10697@vindex nan 10698The word @code{inf} represents the mathematical concept of @dfn{infinity}. 10699Calc actually has three slightly different infinity-like values: 10700@code{inf}, @code{uinf}, and @code{nan}. These are just regular 10701variable names (@pxref{Variables}); you should avoid using these 10702names for your own variables because Calc gives them special 10703treatment. Infinities, like all variable names, are normally 10704entered using algebraic entry. 10705 10706Mathematically speaking, it is not rigorously correct to treat 10707``infinity'' as if it were a number, but mathematicians often do 10708so informally. When they say that @samp{1 / inf = 0}, what they 10709really mean is that @expr{1 / x}, as @expr{x} becomes larger and 10710larger, becomes arbitrarily close to zero. So you can imagine 10711that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x} 10712would go all the way to zero. Similarly, when they say that 10713@samp{exp(inf) = inf}, they mean that 10714@texline @math{e^x} 10715@infoline @expr{exp(x)} 10716grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise 10717stands for an infinitely negative real value; for example, we say that 10718@samp{exp(-inf) = 0}. You can have an infinity pointing in any 10719direction on the complex plane: @samp{sqrt(-inf) = i inf}. 10720 10721The same concept of limits can be used to define @expr{1 / 0}. We 10722really want the value that @expr{1 / x} approaches as @expr{x} 10723approaches zero. But if all we have is @expr{1 / 0}, we can't 10724tell which direction @expr{x} was coming from. If @expr{x} was 10725positive and decreasing toward zero, then we should say that 10726@samp{1 / 0 = inf}. But if @expr{x} was negative and increasing 10727toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x} 10728could be an imaginary number, giving the answer @samp{i inf} or 10729@samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean 10730@dfn{undirected infinity}, i.e., a value which is infinitely 10731large but with an unknown sign (or direction on the complex plane). 10732 10733Calc actually has three modes that say how infinities are handled. 10734Normally, infinities never arise from calculations that didn't 10735already have them. Thus, @expr{1 / 0} is treated simply as an 10736error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode}) 10737command (@pxref{Infinite Mode}) enables a mode in which 10738@expr{1 / 0} evaluates to @code{uinf} instead. There is also 10739an alternative type of infinite mode which says to treat zeros 10740as if they were positive, so that @samp{1 / 0 = inf}. While this 10741is less mathematically correct, it may be the answer you want in 10742some cases. 10743 10744Since all infinities are ``as large'' as all others, Calc simplifies, 10745e.g., @samp{5 inf} to @samp{inf}. Another example is 10746@samp{5 - inf = -inf}, where the @samp{-inf} is so large that 10747adding a finite number like five to it does not affect it. 10748Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes 10749that variables like @code{a} always stand for finite quantities. 10750Just to show that infinities really are all the same size, 10751note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's 10752notation. 10753 10754It's not so easy to define certain formulas like @samp{0 * inf} and 10755@samp{inf / inf}. Depending on where these zeros and infinities 10756came from, the answer could be literally anything. The latter 10757formula could be the limit of @expr{x / x} (giving a result of one), 10758or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}), 10759or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan} 10760to represent such an @dfn{indeterminate} value. (The name ``nan'' 10761comes from analogy with the ``NAN'' concept of IEEE standard 10762arithmetic; it stands for ``Not A Number.'' This is somewhat of a 10763misnomer, since @code{nan} @emph{does} stand for some number or 10764infinity, it's just that @emph{which} number it stands for 10765cannot be determined.) In Calc's notation, @samp{0 * inf = nan} 10766and @samp{inf / inf = nan}. A few other common indeterminate 10767expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also, 10768@samp{0 / 0 = nan} if you have turned on Infinite mode 10769(as described above). 10770 10771Infinities are especially useful as parts of @dfn{intervals}. 10772@xref{Interval Forms}. 10773 10774@node Vectors and Matrices, Strings, Infinities, Data Types 10775@section Vectors and Matrices 10776 10777@noindent 10778@cindex Vectors 10779@cindex Plain vectors 10780@cindex Matrices 10781The @dfn{vector} data type is flexible and general. A vector is simply a 10782list of zero or more data objects. When these objects are numbers, the 10783whole is a vector in the mathematical sense. When these objects are 10784themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}. 10785A vector which is not a matrix is referred to here as a @dfn{plain vector}. 10786 10787A vector is displayed as a list of values separated by commas and enclosed 10788in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by 107893 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex 10790numbers, are entered as incomplete objects. @xref{Incomplete Objects}. 10791During algebraic entry, vectors are entered all at once in the usual 10792brackets-and-commas form. Matrices may be entered algebraically as nested 10793vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}}, 10794with rows separated by semicolons. The commas may usually be omitted 10795when entering vectors: @samp{[1 2 3]}. Curly braces may be used in 10796place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in 10797this case. 10798 10799Traditional vector and matrix arithmetic is also supported; 10800@pxref{Basic Arithmetic} and @pxref{Matrix Functions}. 10801Many other operations are applied to vectors element-wise. For example, 10802the complex conjugate of a vector is a vector of the complex conjugates 10803of its elements. 10804 10805@ignore 10806@starindex 10807@end ignore 10808@tindex vec 10809Algebraic functions for building vectors include @samp{vec(a, b, c)} 10810to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an 10811@texline @math{n\times m} 10812@infoline @var{n}x@var{m} 10813matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers 10814from 1 to @samp{n}. 10815 10816@node Strings, HMS Forms, Vectors and Matrices, Data Types 10817@section Strings 10818 10819@noindent 10820@kindex " 10821@cindex Strings 10822@cindex Character strings 10823Character strings are not a special data type in the Calculator. 10824Rather, a string is represented simply as a vector all of whose 10825elements are integers in the range 0 to 255 (ASCII codes). You can 10826enter a string at any time by pressing the @kbd{"} key. Quotation 10827marks and backslashes are written @samp{\"} and @samp{\\}, respectively, 10828inside strings. Other notations introduced by backslashes are: 10829 10830@example 10831@group 10832\a 7 \^@@ 0 10833\b 8 \^a-z 1-26 10834\e 27 \^[ 27 10835\f 12 \^\\ 28 10836\n 10 \^] 29 10837\r 13 \^^ 30 10838\t 9 \^_ 31 10839 \^? 127 10840@end group 10841@end example 10842 10843@noindent 10844Finally, a backslash followed by three octal digits produces any 10845character from its ASCII code. 10846 10847@kindex d " 10848@pindex calc-display-strings 10849Strings are normally displayed in vector-of-integers form. The 10850@w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in 10851which any vectors of small integers are displayed as quoted strings 10852instead. 10853 10854The backslash notations shown above are also used for displaying 10855strings. Characters 128 and above are not translated by Calc; unless 10856you have an Emacs modified for 8-bit fonts, these will show up in 10857backslash-octal-digits notation. For characters below 32, and 10858for character 127, Calc uses the backslash-letter combination if 10859there is one, or otherwise uses a @samp{\^} sequence. 10860 10861The only Calc feature that uses strings is @dfn{compositions}; 10862@pxref{Compositions}. Strings also provide a convenient 10863way to do conversions between ASCII characters and integers. 10864 10865@ignore 10866@starindex 10867@end ignore 10868@tindex string 10869There is a @code{string} function which provides a different display 10870format for strings. Basically, @samp{string(@var{s})}, where @var{s} 10871is a vector of integers in the proper range, is displayed as the 10872corresponding string of characters with no surrounding quotation 10873marks or other modifications. Thus @samp{string("ABC")} (or 10874@samp{string([65 66 67])}) will look like @samp{ABC} on the stack. 10875This happens regardless of whether @w{@kbd{d "}} has been used. The 10876only way to turn it off is to use @kbd{d U} (unformatted language 10877mode) which will display @samp{string("ABC")} instead. 10878 10879Control characters are displayed somewhat differently by @code{string}. 10880Characters below 32, and character 127, are shown using @samp{^} notation 10881(same as shown above, but without the backslash). The quote and 10882backslash characters are left alone, as are characters 128 and above. 10883 10884@ignore 10885@starindex 10886@end ignore 10887@tindex bstring 10888The @code{bstring} function is just like @code{string} except that 10889the resulting string is breakable across multiple lines if it doesn't 10890fit all on one line. Potential break points occur at every space 10891character in the string. 10892 10893@node HMS Forms, Date Forms, Strings, Data Types 10894@section HMS Forms 10895 10896@noindent 10897@cindex Hours-minutes-seconds forms 10898@cindex Degrees-minutes-seconds forms 10899@dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular 10900argument, the interpretation is Degrees-Minutes-Seconds. All functions 10901that operate on angles accept HMS forms. These are interpreted as 10902degrees regardless of the current angular mode. It is also possible to 10903use HMS as the angular mode so that calculated angles are expressed in 10904degrees, minutes, and seconds. 10905 10906@kindex @@ 10907@ignore 10908@mindex @null 10909@end ignore 10910@kindex ' @r{(HMS forms)} 10911@ignore 10912@mindex @null 10913@end ignore 10914@kindex " @r{(HMS forms)} 10915@ignore 10916@mindex @null 10917@end ignore 10918@kindex h @r{(HMS forms)} 10919@ignore 10920@mindex @null 10921@end ignore 10922@kindex o @r{(HMS forms)} 10923@ignore 10924@mindex @null 10925@end ignore 10926@kindex m @r{(HMS forms)} 10927@ignore 10928@mindex @null 10929@end ignore 10930@kindex s @r{(HMS forms)} 10931The default format for HMS values is 10932@samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters 10933@samp{h} (for ``hours'') or 10934@samp{o} (approximating the ``degrees'' symbol) are accepted as well as 10935@samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is 10936accepted in place of @samp{"}. 10937The @var{hours} value is an integer (or integer-valued float). 10938The @var{mins} value is an integer or integer-valued float between 0 and 59. 10939The @var{secs} value is a real number between 0 (inclusive) and 60 10940(exclusive). A positive HMS form is interpreted as @var{hours} + 10941@var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted 10942as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600. 10943Display format for HMS forms is quite flexible. @xref{HMS Formats}. 10944 10945HMS forms can be added and subtracted. When they are added to numbers, 10946the numbers are interpreted according to the current angular mode. HMS 10947forms can also be multiplied and divided by real numbers. Dividing 10948two HMS forms produces a real-valued ratio of the two angles. 10949 10950@pindex calc-time 10951@cindex Time of day 10952Just for kicks, @kbd{M-x calc-time} pushes the current time of day on 10953the stack as an HMS form. 10954 10955@node Date Forms, Modulo Forms, HMS Forms, Data Types 10956@section Date Forms 10957 10958@noindent 10959@cindex Date forms 10960A @dfn{date form} represents a date and possibly an associated time. 10961Simple date arithmetic is supported: Adding a number to a date 10962produces a new date shifted by that many days; adding an HMS form to 10963a date shifts it by that many hours. Subtracting two date forms 10964computes the number of days between them (represented as a simple 10965number). Many other operations, such as multiplying two date forms, 10966are nonsensical and are not allowed by Calc. 10967 10968Date forms are entered and displayed enclosed in @samp{< >} brackets. 10969The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates, 10970or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times. 10971Input is flexible; date forms can be entered in any of the usual 10972notations for dates and times. @xref{Date Formats}. 10973 10974Date forms are stored internally as numbers, specifically the number 10975of days since midnight on the morning of December 31 of the year 1 BC@. 10976If the internal number is an integer, the form represents a date only; 10977if the internal number is a fraction or float, the form represents 10978a date and time. For example, @samp{<6:00am Thu Jan 10, 1991>} 10979is represented by the number 726842.25. The standard precision of 1098012 decimal digits is enough to ensure that a (reasonable) date and 10981time can be stored without roundoff error. 10982 10983If the current precision is greater than 12, date forms will keep 10984additional digits in the seconds position. For example, if the 10985precision is 15, the seconds will keep three digits after the 10986decimal point. Decreasing the precision below 12 may cause the 10987time part of a date form to become inaccurate. This can also happen 10988if astronomically high years are used, though this will not be an 10989issue in everyday (or even everymillennium) use. Note that date 10990forms without times are stored as exact integers, so roundoff is 10991never an issue for them. 10992 10993You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u} 10994(@code{calc-unpack}) commands to get at the numerical representation 10995of a date form. @xref{Packing and Unpacking}. 10996 10997Date forms can go arbitrarily far into the future or past. Negative 10998year numbers represent years BC@. There is no ``year 0''; the day 10999before @samp{<Mon Jan 1, +1>} is @samp{<Sun Dec 31, -1>}. These are 11000days 1 and 0 respectively in Calc's internal numbering scheme. The 11001Gregorian calendar is used for all dates, including dates before the 11002Gregorian calendar was invented (although that can be configured; see 11003below). Thus Calc's use of the day number @mathit{-10000} to 11004represent August 15, 28 BC should be taken with a grain of salt. 11005 11006@cindex Julian calendar 11007@cindex Gregorian calendar 11008Some historical background: The Julian calendar was created by 11009Julius Caesar in the year 46 BC as an attempt to fix the confusion 11010caused by the irregular Roman calendar that was used before that time. 11011The Julian calendar introduced an extra day in all years divisible by 11012four. After some initial confusion, the calendar was adopted around 11013the year we call 8 AD@. Some centuries later it became 11014apparent that the Julian year of 365.25 days was itself not quite 11015right. In 1582 Pope Gregory XIII introduced the Gregorian calendar, 11016which added the new rule that years divisible by 100, but not by 400, 11017were not to be considered leap years despite being divisible by four. 11018Many countries delayed adoption of the Gregorian calendar 11019because of religious differences. For example, Great Britain and the 11020British colonies switched to the Gregorian calendar in September 110211752, when the Julian calendar was eleven days behind the 11022Gregorian calendar. That year in Britain, the day after September 2 11023was September 14. To take another example, Russia did not adopt the 11024Gregorian calendar until 1918, and that year in Russia the day after 11025January 31 was February 14. Calc's reckoning therefore matches English 11026practice starting in 1752 and Russian practice starting in 1918, but 11027disagrees with earlier dates in both countries. 11028 11029When the Julian calendar was introduced, it had January 1 as the first 11030day of the year. By the Middle Ages, many European countries 11031had changed the beginning of a new year to a different date, often to 11032a religious festival. Almost all countries reverted to using January 1 11033as the beginning of the year by the time they adopted the Gregorian 11034calendar. 11035 11036Some calendars attempt to mimic the historical situation by using the 11037Gregorian calendar for recent dates and the Julian calendar for older 11038dates. The @code{cal} program in most Unix implementations does this, 11039for example. While January 1 wasn't always the beginning of a calendar 11040year, these hybrid calendars still use January 1 as the beginning of 11041the year even for older dates. The customizable variable 11042@code{calc-gregorian-switch} (@pxref{Customizing Calc}) can be set to 11043have Calc's date forms switch from the Julian to Gregorian calendar at 11044any specified date. 11045 11046Today's timekeepers introduce an occasional ``leap second''. 11047These do not occur regularly and Calc does not take these minor 11048effects into account. (If it did, it would have to report a 11049non-integer number of days between, say, 11050@samp{<12:00am Mon Jan 1, 1900>} and 11051@samp{<12:00am Sat Jan 1, 2000>}.) 11052 11053@cindex Julian day counting 11054Another day counting system in common use is, confusingly, also called 11055``Julian.'' Julian days go from noon to noon. The Julian day number 11056is the numbers of days since 12:00 noon (GMT) on November 24, 4714 BC 11057in the Gregorian calendar (i.e., January 1, 4713 BC in the Julian 11058calendar). In Calc's scheme (in GMT) the Julian day origin is 11059@mathit{-1721424.5}, because Calc starts at midnight instead of noon. 11060Thus to convert a Calc date code obtained by unpacking a 11061date form into a Julian day number, simply add 1721424.5 after 11062compensating for the time zone difference. The built-in @kbd{t J} 11063command performs this conversion for you. 11064 11065The Julian day number is based on the Julian cycle, which was invented 11066in 1583 by Joseph Justus Scaliger. Scaliger named it the Julian cycle 11067since it involves the Julian calendar, but some have suggested that 11068Scaliger named it in honor of his father, Julius Caesar Scaliger. The 11069Julian cycle is based on three other cycles: the indiction cycle, the 11070Metonic cycle, and the solar cycle. The indiction cycle is a 15 year 11071cycle originally used by the Romans for tax purposes but later used to 11072date medieval documents. The Metonic cycle is a 19 year cycle; 19 11073years is close to being a common multiple of a solar year and a lunar 11074month, and so every 19 years the phases of the moon will occur on the 11075same days of the year. The solar cycle is a 28 year cycle; the Julian 11076calendar repeats itself every 28 years. The smallest time period 11077which contains multiples of all three cycles is the least common 11078multiple of 15 years, 19 years and 28 years, which (since they're 11079pairwise relatively prime) is 11080@texline @math{15\times 19\times 28 = 7980} years. 11081@infoline 15*19*28 = 7980 years. 11082This is the length of a Julian cycle. Working backwards, the previous 11083year in which all three cycles began was 4713 BC, and so Scaliger 11084chose that year as the beginning of a Julian cycle. Since at the time 11085there were no historical records from before 4713 BC, using this year 11086as a starting point had the advantage of avoiding negative year 11087numbers. In 1849, the astronomer John Herschel (son of William 11088Herschel) suggested using the number of days since the beginning of 11089the Julian cycle as an astronomical dating system; this idea was taken 11090up by other astronomers. (At the time, noon was the start of the 11091astronomical day. Herschel originally suggested counting the days 11092since Jan 1, 4713 BC at noon Alexandria time; this was later amended to 11093noon GMT@.) Julian day numbering is largely used in astronomy. 11094 11095@cindex Unix time format 11096The Unix operating system measures time as an integer number of 11097seconds since midnight, Jan 1, 1970. To convert a Calc date 11098value into a Unix time stamp, first subtract 719163 (the code 11099for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of 11100seconds in a day) and press @kbd{R} to round to the nearest 11101integer. If you have a date form, you can simply subtract the 11102day @samp{<Jan 1, 1970>} instead of unpacking and subtracting 11103719163. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>} 11104to convert from Unix time to a Calc date form. (Note that 11105Unix normally maintains the time in the GMT time zone; you may 11106need to subtract five hours to get New York time, or eight hours 11107for California time. The same is usually true of Julian day 11108counts.) The built-in @kbd{t U} command performs these 11109conversions. 11110 11111@node Modulo Forms, Error Forms, Date Forms, Data Types 11112@section Modulo Forms 11113 11114@noindent 11115@cindex Modulo forms 11116A @dfn{modulo form} is a real number which is taken modulo (i.e., within 11117an integer multiple of) some value @var{M}. Arithmetic modulo @var{M} 11118often arises in number theory. Modulo forms are written 11119`@var{a} @tfn{mod} @var{M}', 11120where @var{a} and @var{M} are real numbers or HMS forms, and 11121@texline @math{0 \le a < M}. 11122@infoline @expr{0 <= a < @var{M}}. 11123In many applications @expr{a} and @expr{M} will be 11124integers but this is not required. 11125 11126@ignore 11127@mindex M 11128@end ignore 11129@kindex M @r{(modulo forms)} 11130@ignore 11131@mindex mod 11132@end ignore 11133@tindex mod (operator) 11134To create a modulo form during numeric entry, press the shift-@kbd{M} 11135key to enter the word @samp{mod}. As a special convenience, pressing 11136shift-@kbd{M} a second time automatically enters the value of @expr{M} 11137that was most recently used before. During algebraic entry, either 11138type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}). 11139Once again, pressing this a second time enters the current modulo. 11140 11141Modulo forms are not to be confused with the modulo operator @samp{%}. 11142The expression @samp{27 % 10} means to compute 27 modulo 10 to produce 11143the result 7. Further computations treat this 7 as just a regular integer. 11144The expression @samp{27 mod 10} produces the result @samp{7 mod 10}; 11145further computations with this value are again reduced modulo 10 so that 11146the result always lies in the desired range. 11147 11148When two modulo forms with identical @expr{M}'s are added or multiplied, 11149the Calculator simply adds or multiplies the values, then reduces modulo 11150@expr{M}. If one argument is a modulo form and the other a plain number, 11151the plain number is treated like a compatible modulo form. It is also 11152possible to raise modulo forms to powers; the result is the value raised 11153to the power, then reduced modulo @expr{M}. (When all values involved 11154are integers, this calculation is done much more efficiently than 11155actually computing the power and then reducing.) 11156 11157@cindex Modulo division 11158Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}' 11159can be divided if @expr{a}, @expr{b}, and @expr{M} are all 11160integers. The result is the modulo form which, when multiplied by 11161`@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If 11162there is no solution to this equation (which can happen only when 11163@expr{M} is non-prime), or if any of the arguments are non-integers, the 11164division is left in symbolic form. Other operations, such as square 11165roots, are not yet supported for modulo forms. (Note that, although 11166@w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root'' 11167in the sense of reducing 11168@texline @math{\sqrt a} 11169@infoline @expr{sqrt(a)} 11170modulo @expr{M}, this is not a useful definition from the 11171number-theoretical point of view.) 11172 11173It is possible to mix HMS forms and modulo forms. For example, an 11174HMS form modulo 24 could be used to manipulate clock times; an HMS 11175form modulo 360 would be suitable for angles. Making the modulo @expr{M} 11176also be an HMS form eliminates troubles that would arise if the angular 11177mode were inadvertently set to Radians, in which case 11178@w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo 1117924 radians! 11180 11181Modulo forms cannot have variables or formulas for components. If you 11182enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus 11183to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}. 11184 11185You can use @kbd{v p} and @kbd{%} to modify modulo forms. 11186@xref{Packing and Unpacking}. @xref{Basic Arithmetic}. 11187 11188@ignore 11189@starindex 11190@end ignore 11191@tindex makemod 11192The algebraic function @samp{makemod(a, m)} builds the modulo form 11193@w{@samp{a mod m}}. 11194 11195@node Error Forms, Interval Forms, Modulo Forms, Data Types 11196@section Error Forms 11197 11198@noindent 11199@cindex Error forms 11200@cindex Standard deviations 11201An @dfn{error form} is a number with an associated standard 11202deviation, as in @samp{2.3 +/- 0.12}. The notation 11203@texline `@var{x} @tfn{+/-} @math{\sigma}' 11204@infoline `@var{x} @tfn{+/-} sigma' 11205stands for an uncertain value which follows 11206a normal or Gaussian distribution of mean @expr{x} and standard 11207deviation or ``error'' 11208@texline @math{\sigma}. 11209@infoline @expr{sigma}. 11210Both the mean and the error can be either numbers or 11211formulas. Generally these are real numbers but the mean may also be 11212complex. If the error is negative or complex, it is changed to its 11213absolute value. An error form with zero error is converted to a 11214regular number by the Calculator. 11215 11216All arithmetic and transcendental functions accept error forms as input. 11217Operations on the mean-value part work just like operations on regular 11218numbers. The error part for any function @expr{f(x)} (such as 11219@texline @math{\sin x} 11220@infoline @expr{sin(x)}) 11221is defined by the error of @expr{x} times the derivative of @expr{f} 11222evaluated at the mean value of @expr{x}. For a two-argument function 11223@expr{f(x,y)} (such as addition) the error is the square root of the sum 11224of the squares of the errors due to @expr{x} and @expr{y}. 11225@tex 11226$$ \eqalign{ 11227 f(x \hbox{\code{ +/- }} \sigma) 11228 &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr 11229 f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y) 11230 &= f(x,y) \hbox{\code{ +/- }} 11231 \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x} 11232 \right| \right)^2 11233 +\left(\sigma_y \left| {\partial f(x,y) \over \partial y} 11234 \right| \right)^2 } \cr 11235} $$ 11236@end tex 11237Note that this 11238definition assumes the errors in @expr{x} and @expr{y} are uncorrelated. 11239A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)} 11240is not the same as @samp{(2 +/- 1)^2}; the former represents the product 11241of two independent values which happen to have the same probability 11242distributions, and the latter is the product of one random value with itself. 11243The former will produce an answer with less error, since on the average 11244the two independent errors can be expected to cancel out. 11245 11246Consult a good text on error analysis for a discussion of the proper use 11247of standard deviations. Actual errors often are neither Gaussian-distributed 11248nor uncorrelated, and the above formulas are valid only when errors 11249are small. As an example, the error arising from 11250@texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}' 11251@infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}' 11252is 11253@texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'. 11254@infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'. 11255When @expr{x} is close to zero, 11256@texline @math{\cos x} 11257@infoline @expr{cos(x)} 11258is close to one so the error in the sine is close to 11259@texline @math{\sigma}; 11260@infoline @expr{sigma}; 11261this makes sense, since 11262@texline @math{\sin x} 11263@infoline @expr{sin(x)} 11264is approximately @expr{x} near zero, so a given error in @expr{x} will 11265produce about the same error in the sine. Likewise, near 90 degrees 11266@texline @math{\cos x} 11267@infoline @expr{cos(x)} 11268is nearly zero and so the computed error is 11269small: The sine curve is nearly flat in that region, so an error in @expr{x} 11270has relatively little effect on the value of 11271@texline @math{\sin x}. 11272@infoline @expr{sin(x)}. 11273However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so 11274Calc will report zero error! We get an obviously wrong result because 11275we have violated the small-error approximation underlying the error 11276analysis. If the error in @expr{x} had been small, the error in 11277@texline @math{\sin x} 11278@infoline @expr{sin(x)} 11279would indeed have been negligible. 11280 11281@ignore 11282@mindex p 11283@end ignore 11284@kindex p @r{(error forms)} 11285@tindex +/- 11286To enter an error form during regular numeric entry, use the @kbd{p} 11287(``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually 11288typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's 11289@kbd{+} command!) Within an algebraic formula, you can press @kbd{M-+} to 11290type the @samp{+/-} symbol, or type it out by hand. 11291 11292Error forms and complex numbers can be mixed; the formulas shown above 11293are used for complex numbers, too; note that if the error part evaluates 11294to a complex number its absolute value (or the square root of the sum of 11295the squares of the absolute values of the two error contributions) is 11296used. Mathematically, this corresponds to a radially symmetric Gaussian 11297distribution of numbers on the complex plane. However, note that Calc 11298considers an error form with real components to represent a real number, 11299not a complex distribution around a real mean. 11300 11301Error forms may also be composed of HMS forms. For best results, both 11302the mean and the error should be HMS forms if either one is. 11303 11304@ignore 11305@starindex 11306@end ignore 11307@tindex sdev 11308The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}. 11309 11310@node Interval Forms, Incomplete Objects, Error Forms, Data Types 11311@section Interval Forms 11312 11313@noindent 11314@cindex Interval forms 11315An @dfn{interval} is a subset of consecutive real numbers. For example, 11316the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4, 11317inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you 11318obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if 11319you multiply some number in the range @samp{[2 ..@: 4]} by some other 11320number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range 11321from 1 to 8. Interval arithmetic is used to get a worst-case estimate 11322of the possible range of values a computation will produce, given the 11323set of possible values of the input. 11324 11325@ifnottex 11326Calc supports several varieties of intervals, including @dfn{closed} 11327intervals of the type shown above, @dfn{open} intervals such as 11328@samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4 11329@emph{exclusive}, and @dfn{semi-open} intervals in which one end 11330uses a round parenthesis and the other a square bracket. In mathematical 11331terms, 11332@samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas 11333@samp{[2 ..@: 4)} represents @expr{2 <= x < 4}, 11334@samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and 11335@samp{(2 ..@: 4)} represents @expr{2 < x < 4}. 11336@end ifnottex 11337@tex 11338Calc supports several varieties of intervals, including \dfn{closed} 11339intervals of the type shown above, \dfn{open} intervals such as 11340\samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4 11341\emph{exclusive}, and \dfn{semi-open} intervals in which one end 11342uses a round parenthesis and the other a square bracket. In mathematical 11343terms, 11344$$ \eqalign{ 11345 [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr 11346 [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr 11347 (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr 11348 (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr 11349} $$ 11350@end tex 11351 11352The lower and upper limits of an interval must be either real numbers 11353(or HMS or date forms), or symbolic expressions which are assumed to be 11354real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit 11355must be less than the upper limit. A closed interval containing only 11356one value, @samp{[3 ..@: 3]}, is converted to a plain number (3) 11357automatically. An interval containing no values at all (such as 11358@samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not 11359guaranteed to behave well when used in arithmetic. Note that the 11360interval @samp{[3 .. inf)} represents all real numbers greater than 11361or equal to 3, and @samp{(-inf .. inf)} represents all real numbers. 11362In fact, @samp{[-inf .. inf]} represents all real numbers including 11363the real infinities. 11364 11365Intervals are entered in the notation shown here, either as algebraic 11366formulas, or using incomplete forms. (@xref{Incomplete Objects}.) 11367In algebraic formulas, multiple periods in a row are collected from 11368left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2} 11369rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to 11370get the other interpretation. If you omit the lower or upper limit, 11371a default of @samp{-inf} or @samp{inf} (respectively) is furnished. 11372 11373Infinite mode also affects operations on intervals 11374(@pxref{Infinities}). Calc will always introduce an open infinity, 11375as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities, 11376@w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode; 11377otherwise they are left unevaluated. Note that the ``direction'' of 11378a zero is not an issue in this case since the zero is always assumed 11379to be continuous with the rest of the interval. For intervals that 11380contain zero inside them Calc is forced to give the result, 11381@samp{1 / (-2 .. 2) = [-inf .. inf]}. 11382 11383While it may seem that intervals and error forms are similar, they are 11384based on entirely different concepts of inexact quantities. An error 11385form 11386@texline `@var{x} @tfn{+/-} @math{\sigma}' 11387@infoline `@var{x} @tfn{+/-} @var{sigma}' 11388means a variable is random, and its value could 11389be anything but is ``probably'' within one 11390@texline @math{\sigma} 11391@infoline @var{sigma} 11392of the mean value @expr{x}. An interval 11393`@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a 11394variable's value is unknown, but guaranteed to lie in the specified 11395range. Error forms are statistical or ``average case'' approximations; 11396interval arithmetic tends to produce ``worst case'' bounds on an 11397answer. 11398 11399Intervals may not contain complex numbers, but they may contain 11400HMS forms or date forms. 11401 11402@xref{Set Operations}, for commands that interpret interval forms 11403as subsets of the set of real numbers. 11404 11405@ignore 11406@starindex 11407@end ignore 11408@tindex intv 11409The algebraic function @samp{intv(n, a, b)} builds an interval form 11410from @samp{a} to @samp{b}; @samp{n} is an integer code which must 11411be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or 114123 for @samp{[..]}. 11413 11414Please note that in fully rigorous interval arithmetic, care would be 11415taken to make sure that the computation of the lower bound rounds toward 11416minus infinity, while upper bound computations round toward plus 11417infinity. Calc's arithmetic always uses a round-to-nearest mode, 11418which means that roundoff errors could creep into an interval 11419calculation to produce intervals slightly smaller than they ought to 11420be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^} 11421should yield the interval @samp{[1..2]} again, but in fact it yields the 11422(slightly too small) interval @samp{[1..1.9999999]} due to roundoff 11423error. 11424 11425@node Incomplete Objects, Variables, Interval Forms, Data Types 11426@section Incomplete Objects 11427 11428@noindent 11429@ignore 11430@mindex [ ] 11431@end ignore 11432@kindex [ 11433@ignore 11434@mindex ( ) 11435@end ignore 11436@kindex ( 11437@kindex , 11438@ignore 11439@mindex @null 11440@end ignore 11441@kindex ] 11442@ignore 11443@mindex @null 11444@end ignore 11445@kindex ) 11446@cindex Incomplete vectors 11447@cindex Incomplete complex numbers 11448@cindex Incomplete interval forms 11449When @kbd{(} or @kbd{[} is typed to begin entering a complex number or 11450vector, respectively, the effect is to push an @dfn{incomplete} complex 11451number or vector onto the stack. The @kbd{,} key adds the value(s) at 11452the top of the stack onto the current incomplete object. The @kbd{)} 11453and @kbd{]} keys ``close'' the incomplete object after adding any values 11454on the top of the stack in front of the incomplete object. 11455 11456As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]} 11457pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )} 11458pushes the complex number @samp{(1, 1.414)} (approximately). 11459 11460If several values lie on the stack in front of the incomplete object, 11461all are collected and appended to the object. Thus the @kbd{,} key 11462is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people 11463prefer the equivalent @key{SPC} key to @key{RET}. 11464 11465As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or 11466@kbd{,} adds a zero or duplicates the preceding value in the list being 11467formed. Typing @key{DEL} during incomplete entry removes the last item 11468from the list. 11469 11470@kindex ; 11471The @kbd{;} key is used in the same way as @kbd{,} to create polar complex 11472numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for 11473creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is 11474equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}. 11475 11476@kindex .. 11477@pindex calc-dots 11478Incomplete entry is also used to enter intervals. For example, 11479@kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type 11480the first period, it will be interpreted as a decimal point, but when 11481you type a second period immediately afterward, it is re-interpreted as 11482part of the interval symbol. Typing @kbd{..} corresponds to executing 11483the @code{calc-dots} command. 11484 11485If you find incomplete entry distracting, you may wish to enter vectors 11486and complex numbers as algebraic formulas by pressing the apostrophe key. 11487 11488@node Variables, Formulas, Incomplete Objects, Data Types 11489@section Variables 11490 11491@noindent 11492@cindex Variables, in formulas 11493A @dfn{variable} is somewhere between a storage register on a conventional 11494calculator, and a variable in a programming language. (In fact, a Calc 11495variable is really just an Emacs Lisp variable that contains a Calc number 11496or formula.) A variable's name is normally composed of letters and digits. 11497Calc also allows apostrophes and @code{#} signs in variable names. 11498(The Calc variable @code{foo} corresponds to the Emacs Lisp variable 11499@code{var-foo}, but unless you access the variable from within Emacs 11500Lisp, you don't need to worry about it. Variable names in algebraic 11501formulas implicitly have @samp{var-} prefixed to their names. The 11502@samp{#} character in variable names used in algebraic formulas 11503corresponds to a dash @samp{-} in the Lisp variable name. If the name 11504contains any dashes, the prefix @samp{var-} is @emph{not} automatically 11505added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both 11506refer to the same variable.) 11507 11508In a command that takes a variable name, you can either type the full 11509name of a variable, or type a single digit to use one of the special 11510convenience variables @code{q0} through @code{q9}. For example, 11511@kbd{3 s s 2} stores the number 3 in variable @code{q2}, and 11512@w{@kbd{3 s s foo @key{RET}}} stores that number in variable 11513@code{foo}. 11514 11515To push a variable itself (as opposed to the variable's value) on the 11516stack, enter its name as an algebraic expression using the apostrophe 11517(@key{'}) key. 11518 11519@kindex = 11520@pindex calc-evaluate 11521@cindex Evaluation of variables in a formula 11522@cindex Variables, evaluation 11523@cindex Formulas, evaluation 11524The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by 11525replacing all variables in the formula which have been given values by a 11526@code{calc-store} or @code{calc-let} command by their stored values. 11527Other variables are left alone. Thus a variable that has not been 11528stored acts like an abstract variable in algebra; a variable that has 11529been stored acts more like a register in a traditional calculator. 11530With a positive numeric prefix argument, @kbd{=} evaluates the top 11531@var{n} stack entries; with a negative argument, @kbd{=} evaluates 11532the @var{n}th stack entry. 11533 11534@cindex @code{e} variable 11535@cindex @code{pi} variable 11536@cindex @code{i} variable 11537@cindex @code{phi} variable 11538@cindex @code{gamma} variable 11539@vindex e 11540@vindex pi 11541@vindex i 11542@vindex phi 11543@vindex gamma 11544A few variables are called @dfn{special constants}. Their names are 11545@samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}. 11546(@xref{Scientific Functions}.) When they are evaluated with @kbd{=}, 11547their values are calculated if necessary according to the current precision 11548or complex polar mode. If you wish to use these symbols for other purposes, 11549simply undefine or redefine them using @code{calc-store}. 11550 11551The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for 11552infinite or indeterminate values. It's best not to use them as 11553regular variables, since Calc uses special algebraic rules when 11554it manipulates them. Calc displays a warning message if you store 11555a value into any of these special variables. 11556 11557@xref{Store and Recall}, for a discussion of commands dealing with variables. 11558 11559@node Formulas, , Variables, Data Types 11560@section Formulas 11561 11562@noindent 11563@cindex Formulas 11564@cindex Expressions 11565@cindex Operators in formulas 11566@cindex Precedence of operators 11567When you press the apostrophe key you may enter any expression or formula 11568in algebraic form. (Calc uses the terms ``expression'' and ``formula'' 11569interchangeably.) An expression is built up of numbers, variable names, 11570and function calls, combined with various arithmetic operators. 11571Parentheses may 11572be used to indicate grouping. Spaces are ignored within formulas, except 11573that spaces are not permitted within variable names or numbers. 11574Arithmetic operators, in order from highest to lowest precedence, and 11575with their equivalent function names, are: 11576 11577@samp{_} [@code{subscr}] (subscripts); 11578 11579postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25}); 11580 11581prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x}); 11582 11583@samp{+/-} [@code{sdev}] (the standard deviation symbol) and 11584@samp{mod} [@code{makemod}] (the symbol for modulo forms); 11585 11586postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!}) 11587and postfix @samp{!!} [@code{dfact}] (double factorial); 11588 11589@samp{^} [@code{pow}] (raised-to-the-power-of); 11590 11591prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x}); 11592 11593@samp{*} [@code{mul}]; 11594 11595@samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and 11596@samp{\} [@code{idiv}] (integer division); 11597 11598infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y}); 11599 11600@samp{|} [@code{vconcat}] (vector concatenation); 11601 11602relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}], 11603@samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}]; 11604 11605@samp{&&} [@code{land}] (logical ``and''); 11606 11607@samp{||} [@code{lor}] (logical ``or''); 11608 11609the C-style ``if'' operator @samp{a?b:c} [@code{if}]; 11610 11611@samp{!!!} [@code{pnot}] (rewrite pattern ``not''); 11612 11613@samp{&&&} [@code{pand}] (rewrite pattern ``and''); 11614 11615@samp{|||} [@code{por}] (rewrite pattern ``or''); 11616 11617@samp{:=} [@code{assign}] (for assignments and rewrite rules); 11618 11619@samp{::} [@code{condition}] (rewrite pattern condition); 11620 11621@samp{=>} [@code{evalto}]. 11622 11623Note that, unlike in usual computer notation, multiplication binds more 11624strongly than division: @samp{a*b/c*d} is equivalent to 11625@texline @math{a b \over c d}. 11626@infoline @expr{(a*b)/(c*d)}. 11627 11628@cindex Multiplication, implicit 11629@cindex Implicit multiplication 11630The multiplication sign @samp{*} may be omitted in many cases. In particular, 11631if the righthand side is a number, variable name, or parenthesized 11632expression, the @samp{*} may be omitted. Implicit multiplication has the 11633same precedence as the explicit @samp{*} operator. The one exception to 11634the rule is that a variable name followed by a parenthesized expression, 11635as in @samp{f(x)}, 11636is interpreted as a function call, not an implicit @samp{*}. In many 11637cases you must use a space if you omit the @samp{*}: @samp{2a} is the 11638same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab} 11639is a variable called @code{ab}, @emph{not} the product of @samp{a} and 11640@samp{b}! Also note that @samp{f (x)} is still a function call. 11641 11642@cindex Implicit comma in vectors 11643The rules are slightly different for vectors written with square brackets. 11644In vectors, the space character is interpreted (like the comma) as a 11645separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is 11646equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent 11647to @samp{2*a*b + c*d}. 11648Note that spaces around the brackets, and around explicit commas, are 11649ignored. To force spaces to be interpreted as multiplication you can 11650enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is 11651interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted 11652between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}. 11653 11654Vectors that contain commas (not embedded within nested parentheses or 11655brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector 11656of two elements. Also, if it would be an error to treat spaces as 11657separators, but not otherwise, then Calc will ignore spaces: 11658@w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is 11659a vector of two elements. Finally, vectors entered with curly braces 11660instead of square brackets do not give spaces any special treatment. 11661When Calc displays a vector that does not contain any commas, it will 11662insert parentheses if necessary to make the meaning clear: 11663@w{@samp{[(a b)]}}. 11664 11665The expression @samp{5%-2} is ambiguous; is this five-percent minus two, 11666or five modulo minus-two? Calc always interprets the leftmost symbol as 11667an infix operator preferentially (modulo, in this case), so you would 11668need to write @samp{(5%)-2} to get the former interpretation. 11669 11670@cindex Function call notation 11671A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function 11672@code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo}, 11673but unless you access the function from within Emacs Lisp, you don't 11674need to worry about it.) Most mathematical Calculator commands like 11675@code{calc-sin} have function equivalents like @code{sin}. 11676If no Lisp function is defined for a function called by a formula, the 11677call is left as it is during algebraic manipulation: @samp{f(x+y)} is 11678left alone. Beware that many innocent-looking short names like @code{in} 11679and @code{re} have predefined meanings which could surprise you; however, 11680single letters or single letters followed by digits are always safe to 11681use for your own function names. @xref{Function Index}. 11682 11683In the documentation for particular commands, the notation @kbd{H S} 11684(@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the 11685command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all 11686represent the same operation. 11687 11688Commands that interpret (``parse'') text as algebraic formulas include 11689algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse 11690the contents of the editing buffer when you finish, the @kbd{C-x * g} 11691and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system 11692``paste'' mouse operation, and Embedded mode. All of these operations 11693use the same rules for parsing formulas; in particular, language modes 11694(@pxref{Language Modes}) affect them all in the same way. 11695 11696When you read a large amount of text into the Calculator (say a vector 11697which represents a big set of rewrite rules; @pxref{Rewrite Rules}), 11698you may wish to include comments in the text. Calc's formula parser 11699ignores the symbol @samp{%%} and anything following it on a line: 11700 11701@example 11702[ a + b, %% the sum of "a" and "b" 11703 c + d, 11704 %% last line is coming up: 11705 e + f ] 11706@end example 11707 11708@noindent 11709This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}. 11710 11711@xref{Syntax Tables}, for a way to create your own operators and other 11712input notations. @xref{Compositions}, for a way to create new display 11713formats. 11714 11715@xref{Algebra}, for commands for manipulating formulas symbolically. 11716 11717@node Stack and Trail, Mode Settings, Data Types, Top 11718@chapter Stack and Trail Commands 11719 11720@noindent 11721This chapter describes the Calc commands for manipulating objects on the 11722stack and in the trail buffer. (These commands operate on objects of any 11723type, such as numbers, vectors, formulas, and incomplete objects.) 11724 11725@menu 11726* Stack Manipulation:: 11727* Editing Stack Entries:: 11728* Trail Commands:: 11729* Keep Arguments:: 11730@end menu 11731 11732@node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail 11733@section Stack Manipulation Commands 11734 11735@noindent 11736@kindex RET 11737@kindex SPC 11738@pindex calc-enter 11739@cindex Duplicating stack entries 11740To duplicate the top object on the stack, press @key{RET} or @key{SPC} 11741(two equivalent keys for the @code{calc-enter} command). 11742Given a positive numeric prefix argument, these commands duplicate 11743several elements at the top of the stack. 11744Given a negative argument, 11745these commands duplicate the specified element of the stack. 11746Given an argument of zero, they duplicate the entire stack. 11747For example, with @samp{10 20 30} on the stack, 11748@key{RET} creates @samp{10 20 30 30}, 11749@kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30}, 11750@kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and 11751@kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}. 11752 11753@kindex LFD 11754@pindex calc-over 11755The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you 11756have it, else on @kbd{C-j}) is like @code{calc-enter} 11757except that the sign of the numeric prefix argument is interpreted 11758oppositely. Also, with no prefix argument the default argument is 2. 11759Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}} 11760are both equivalent to @kbd{C-u - 2 @key{RET}}, producing 11761@samp{10 20 30 20}. 11762 11763@kindex DEL 11764@kindex C-d 11765@pindex calc-pop 11766@cindex Removing stack entries 11767@cindex Deleting stack entries 11768To remove the top element from the stack, press @key{DEL} (@code{calc-pop}). 11769The @kbd{C-d} key is a synonym for @key{DEL}. 11770(If the top element is an incomplete object with at least one element, the 11771last element is removed from it.) Given a positive numeric prefix argument, 11772several elements are removed. Given a negative argument, the specified 11773element of the stack is deleted. Given an argument of zero, the entire 11774stack is emptied. 11775For example, with @samp{10 20 30} on the stack, 11776@key{DEL} leaves @samp{10 20}, 11777@kbd{C-u 2 @key{DEL}} leaves @samp{10}, 11778@kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and 11779@kbd{C-u 0 @key{DEL}} leaves an empty stack. 11780 11781@kindex M-DEL 11782@pindex calc-pop-above 11783The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what 11784@key{LFD} is to @key{RET}: It interprets the sign of the numeric 11785prefix argument in the opposite way, and the default argument is 2. 11786Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element, 11787leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes 11788the third stack element. 11789 11790The above commands do not depend on the location of the cursor. 11791If the customizable variable @code{calc-context-sensitive-enter} is 11792non-@code{nil} (@pxref{Customizing Calc}), these commands will become 11793context sensitive. For example, instead of duplicating the top of the stack, 11794@key{RET} will copy the element at the cursor to the top of the 11795stack. With a positive numeric prefix, a copy of the element at the 11796cursor and the appropriate number of preceding elements will be placed 11797at the top of the stack. A negative prefix will still duplicate the 11798specified element of the stack regardless of the cursor position. 11799Similarly, @key{DEL} will remove the corresponding elements from the 11800stack. 11801 11802@kindex TAB 11803@pindex calc-roll-down 11804To exchange the top two elements of the stack, press @key{TAB} 11805(@code{calc-roll-down}). Given a positive numeric prefix argument, the 11806specified number of elements at the top of the stack are rotated downward. 11807Given a negative argument, the entire stack is rotated downward the specified 11808number of times. Given an argument of zero, the entire stack is reversed 11809top-for-bottom. 11810For example, with @samp{10 20 30 40 50} on the stack, 11811@key{TAB} creates @samp{10 20 30 50 40}, 11812@kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40}, 11813@kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and 11814@kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}. 11815 11816@kindex M-TAB 11817@pindex calc-roll-up 11818The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB} 11819except that it rotates upward instead of downward. Also, the default 11820with no prefix argument is to rotate the top 3 elements. 11821For example, with @samp{10 20 30 40 50} on the stack, 11822@kbd{M-@key{TAB}} creates @samp{10 20 40 50 30}, 11823@kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20}, 11824@kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and 11825@kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}. 11826 11827A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in 11828terms of moving a particular element to a new position in the stack. 11829With a positive argument @var{n}, @key{TAB} moves the top stack 11830element down to level @var{n}, making room for it by pulling all the 11831intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the 11832element at level @var{n} up to the top. (Compare with @key{LFD}, 11833which copies instead of moving the element in level @var{n}.) 11834 11835With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack 11836to move the object in level @var{n} to the deepest place in the 11837stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}} 11838rotates the deepest stack element to be in level @var{n}, also 11839putting the top stack element in level @mathit{@var{n}+1}. 11840 11841@xref{Selecting Subformulas}, for a way to apply these commands to 11842any portion of a vector or formula on the stack. 11843 11844@kindex C-xC-t 11845@pindex calc-transpose-lines 11846@cindex Moving stack entries 11847The command @kbd{C-x C-t} (@code{calc-transpose-lines}) will transpose 11848the stack object determined by the point with the stack object at the 11849next higher level. For example, with @samp{10 20 30 40 50} on the 11850stack and the point on the line containing @samp{30}, @kbd{C-x C-t} 11851creates @samp{10 20 40 30 50}. More generally, @kbd{C-x C-t} acts on 11852the stack objects determined by the current point (and mark) similar 11853to how the text-mode command @code{transpose-lines} acts on 11854lines. With argument @var{n}, @kbd{C-x C-t} will move the stack object 11855at the level above the current point and move it past N other objects; 11856for example, with @samp{10 20 30 40 50} on the stack and the point on 11857the line containing @samp{30}, @kbd{C-u 2 C-x C-t} creates 11858@samp{10 40 20 30 50}. With an argument of 0, @kbd{C-x C-t} will switch 11859the stack objects at the levels determined by the point and the mark. 11860 11861@node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail 11862@section Editing Stack Entries 11863 11864@noindent 11865@kindex ` 11866@pindex calc-edit 11867@pindex calc-edit-finish 11868@cindex Editing the stack with Emacs 11869The @kbd{`} (@code{calc-edit}) command creates a temporary buffer 11870(@file{*Calc Edit*}) for editing the top-of-stack value using regular 11871Emacs commands. Note that @kbd{`} is a grave accent, not an apostrophe. 11872With a numeric prefix argument, it edits the specified number of stack 11873entries at once. (An argument of zero edits the entire stack; a 11874negative argument edits one specific stack entry.) 11875 11876When you are done editing, press @kbd{C-c C-c} to finish and return 11877to Calc. The @key{RET} and @key{LFD} keys also work to finish most 11878sorts of editing, though in some cases Calc leaves @key{RET} with its 11879usual meaning (``insert a newline'') if it's a situation where you 11880might want to insert new lines into the editing buffer. 11881 11882When you finish editing, the Calculator parses the lines of text in 11883the @file{*Calc Edit*} buffer as numbers or formulas, replaces the 11884original stack elements in the original buffer with these new values, 11885then kills the @file{*Calc Edit*} buffer. The original Calculator buffer 11886continues to exist during editing, but for best results you should be 11887careful not to change it until you have finished the edit. You can 11888also cancel the edit by killing the buffer with @kbd{C-x k}. 11889 11890The formula is normally reevaluated as it is put onto the stack. 11891For example, editing @samp{a + 2} to @samp{3 + 2} and pressing 11892@kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to 11893finish, Calc will put the result on the stack without evaluating it. 11894 11895If you give a prefix argument to @kbd{C-c C-c}, 11896Calc will not kill the @file{*Calc Edit*} buffer. You can switch 11897back to that buffer and continue editing if you wish. However, you 11898should understand that if you initiated the edit with @kbd{`}, the 11899@kbd{C-c C-c} operation will be programmed to replace the top of the 11900stack with the new edited value, and it will do this even if you have 11901rearranged the stack in the meanwhile. This is not so much of a problem 11902with other editing commands, though, such as @kbd{s e} 11903(@code{calc-edit-variable}; @pxref{Operations on Variables}). 11904 11905If the @code{calc-edit} command involves more than one stack entry, 11906each line of the @file{*Calc Edit*} buffer is interpreted as a 11907separate formula. Otherwise, the entire buffer is interpreted as 11908one formula, with line breaks ignored. (You can use @kbd{C-o} or 11909@kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.) 11910 11911The @kbd{`} key also works during numeric or algebraic entry. The 11912text entered so far is moved to the @file{*Calc Edit*} buffer for 11913more extensive editing than is convenient in the minibuffer. 11914 11915@node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail 11916@section Trail Commands 11917 11918@noindent 11919@cindex Trail buffer 11920The commands for manipulating the Calc Trail buffer are two-key sequences 11921beginning with the @kbd{t} prefix. 11922 11923@kindex t d 11924@pindex calc-trail-display 11925The @kbd{t d} (@code{calc-trail-display}) command turns display of the 11926trail on and off. Normally the trail display is toggled on if it was off, 11927off if it was on. With a numeric prefix of zero, this command always 11928turns the trail off; with a prefix of one, it always turns the trail on. 11929The other trail-manipulation commands described here automatically turn 11930the trail on. Note that when the trail is off values are still recorded 11931there; they are simply not displayed. To set Emacs to turn the trail 11932off by default, type @kbd{t d} and then save the mode settings with 11933@kbd{m m} (@code{calc-save-modes}). 11934 11935@kindex t i 11936@pindex calc-trail-in 11937@kindex t o 11938@pindex calc-trail-out 11939The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o} 11940(@code{calc-trail-out}) commands switch the cursor into and out of the 11941Calc Trail window. In practice they are rarely used, since the commands 11942shown below are a more convenient way to move around in the 11943trail, and they work ``by remote control'' when the cursor is still 11944in the Calculator window. 11945 11946@cindex Trail pointer 11947There is a @dfn{trail pointer} which selects some entry of the trail at 11948any given time. The trail pointer looks like a @samp{>} symbol right 11949before the selected number. The following commands operate on the 11950trail pointer in various ways. 11951 11952@kindex t y 11953@pindex calc-trail-yank 11954@cindex Retrieving previous results 11955The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in 11956the trail and pushes it onto the Calculator stack. It allows you to 11957re-use any previously computed value without retyping. With a numeric 11958prefix argument @var{n}, it yanks the value @var{n} lines above the current 11959trail pointer. 11960 11961@kindex t < 11962@pindex calc-trail-scroll-left 11963@kindex t > 11964@pindex calc-trail-scroll-right 11965The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >} 11966(@code{calc-trail-scroll-right}) commands horizontally scroll the trail 11967window left or right by one half of its width. 11968 11969@kindex t n 11970@pindex calc-trail-next 11971@kindex t p 11972@pindex calc-trail-previous 11973@kindex t f 11974@pindex calc-trail-forward 11975@kindex t b 11976@pindex calc-trail-backward 11977The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p} 11978(@code{calc-trail-previous)} commands move the trail pointer down or up 11979one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b} 11980(@code{calc-trail-backward}) commands move the trail pointer down or up 11981one screenful at a time. All of these commands accept numeric prefix 11982arguments to move several lines or screenfuls at a time. 11983 11984@kindex t [ 11985@pindex calc-trail-first 11986@kindex t ] 11987@pindex calc-trail-last 11988@kindex t h 11989@pindex calc-trail-here 11990The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]} 11991(@code{calc-trail-last}) commands move the trail pointer to the first or 11992last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command 11993moves the trail pointer to the cursor position; unlike the other trail 11994commands, @kbd{t h} works only when Calc Trail is the selected window. 11995 11996@kindex t s 11997@pindex calc-trail-isearch-forward 11998@kindex t r 11999@pindex calc-trail-isearch-backward 12000@ifnottex 12001The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} 12002(@code{calc-trail-isearch-backward}) commands perform an incremental 12003search forward or backward through the trail. You can press @key{RET} 12004to terminate the search; the trail pointer moves to the current line. 12005If you cancel the search with @kbd{C-g}, the trail pointer stays where 12006it was when the search began. 12007@end ifnottex 12008@tex 12009The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} 12010(@code{calc-trail-isearch-backward}) com\-mands perform an incremental 12011search forward or backward through the trail. You can press @key{RET} 12012to terminate the search; the trail pointer moves to the current line. 12013If you cancel the search with @kbd{C-g}, the trail pointer stays where 12014it was when the search began. 12015@end tex 12016 12017@kindex t m 12018@pindex calc-trail-marker 12019The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a 12020line of text of your own choosing into the trail. The text is inserted 12021after the line containing the trail pointer; this usually means it is 12022added to the end of the trail. Trail markers are useful mainly as the 12023targets for later incremental searches in the trail. 12024 12025@kindex t k 12026@pindex calc-trail-kill 12027The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line 12028from the trail. The line is saved in the Emacs kill ring suitable for 12029yanking into another buffer, but it is not easy to yank the text back 12030into the trail buffer. With a numeric prefix argument, this command 12031kills the @var{n} lines below or above the selected one. 12032 12033The @kbd{t .} (@code{calc-full-trail-vectors}) command is described 12034elsewhere; @pxref{Vector and Matrix Formats}. 12035 12036@node Keep Arguments, , Trail Commands, Stack and Trail 12037@section Keep Arguments 12038 12039@noindent 12040@kindex K 12041@pindex calc-keep-args 12042The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for 12043the following command. It prevents that command from removing its 12044arguments from the stack. For example, after @kbd{2 @key{RET} 3 +}, 12045the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +}, 12046the stack contains the arguments and the result: @samp{2 3 5}. 12047 12048With the exception of keyboard macros, this works for all commands that 12049take arguments off the stack. (To avoid potentially unpleasant behavior, 12050a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K} 12051prefix called @emph{within} the keyboard macro will still take effect.) 12052As another example, @kbd{K a s} simplifies a formula, pushing the 12053simplified version of the formula onto the stack after the original 12054formula (rather than replacing the original formula). Note that you 12055could get the same effect by typing @kbd{@key{RET} a s}, copying the 12056formula and then simplifying the copy. One difference is that for a very 12057large formula the time taken to format the intermediate copy in 12058@kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this 12059extra work. 12060 12061Even stack manipulation commands are affected. @key{TAB} works by 12062popping two values and pushing them back in the opposite order, 12063so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}. 12064 12065A few Calc commands provide other ways of doing the same thing. 12066For example, @kbd{' sin($)} replaces the number on the stack with 12067its sine using algebraic entry; to push the sine and keep the 12068original argument you could use either @kbd{' sin($1)} or 12069@kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s} 12070command is effectively the same as @kbd{K s t}. @xref{Storing Variables}. 12071 12072If you execute a command and then decide you really wanted to keep 12073the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}). 12074This command pushes the last arguments that were popped by any command 12075onto the stack. Note that the order of things on the stack will be 12076different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves 12077@samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}. 12078 12079@node Mode Settings, Arithmetic, Stack and Trail, Top 12080@chapter Mode Settings 12081 12082@noindent 12083This chapter describes commands that set modes in the Calculator. 12084They do not affect the contents of the stack, although they may change 12085the @emph{appearance} or @emph{interpretation} of the stack's contents. 12086 12087@menu 12088* General Mode Commands:: 12089* Precision:: 12090* Inverse and Hyperbolic:: 12091* Calculation Modes:: 12092* Simplification Modes:: 12093* Declarations:: 12094* Display Modes:: 12095* Language Modes:: 12096* Modes Variable:: 12097* Calc Mode Line:: 12098@end menu 12099 12100@node General Mode Commands, Precision, Mode Settings, Mode Settings 12101@section General Mode Commands 12102 12103@noindent 12104@kindex m m 12105@pindex calc-save-modes 12106@cindex Continuous memory 12107@cindex Saving mode settings 12108@cindex Permanent mode settings 12109@cindex Calc init file, mode settings 12110You can save all of the current mode settings in your Calc init file 12111(the file given by the variable @code{calc-settings-file}, typically 12112@file{~/.emacs.d/calc.el}) with the @kbd{m m} (@code{calc-save-modes}) 12113command. This will cause Emacs to reestablish these modes each time 12114it starts up. The modes saved in the file include everything 12115controlled by the @kbd{m} and @kbd{d} prefix keys, the current 12116precision and binary word size, whether or not the trail is displayed, 12117the current height of the Calc window, and more. The current 12118interface (used when you type @kbd{C-x * *}) is also saved. If there 12119were already saved mode settings in the file, they are replaced. 12120Otherwise, the new mode information is appended to the end of the 12121file. 12122 12123@kindex m R 12124@pindex calc-mode-record-mode 12125The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to 12126record all the mode settings (as if by pressing @kbd{m m}) every 12127time a mode setting changes. If the modes are saved this way, then this 12128``automatic mode recording'' mode is also saved. 12129Type @kbd{m R} again to disable this method of recording the mode 12130settings. To turn it off permanently, the @kbd{m m} command will also be 12131necessary. (If Embedded mode is enabled, other options for recording 12132the modes are available; @pxref{Mode Settings in Embedded Mode}.) 12133 12134@kindex m F 12135@pindex calc-settings-file-name 12136The @kbd{m F} (@code{calc-settings-file-name}) command allows you to 12137choose a different file than the current value of @code{calc-settings-file} 12138for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information. 12139You are prompted for a file name. All Calc modes are then reset to 12140their default values, then settings from the file you named are loaded 12141if this file exists, and this file becomes the one that Calc will 12142use in the future for commands like @kbd{m m}. The default settings 12143file name is @file{~/.emacs.d/calc.el}. You can see the current file name by 12144giving a blank response to the @kbd{m F} prompt. See also the 12145discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}. 12146 12147If the file name you give is your user init file (typically 12148@file{~/.emacs}), @kbd{m F} will not automatically load the new file. This 12149is because your user init file may contain other things you don't want 12150to reread. You can give 12151a numeric prefix argument of 1 to @kbd{m F} to force it to read the 12152file no matter what. Conversely, an argument of @mathit{-1} tells 12153@kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2} 12154tells @kbd{m F} not to reset the modes to their defaults beforehand, 12155which is useful if you intend your new file to have a variant of the 12156modes present in the file you were using before. 12157 12158@kindex m x 12159@pindex calc-always-load-extensions 12160The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode 12161in which the first use of Calc loads the entire program, including all 12162extensions modules. Otherwise, the extensions modules will not be loaded 12163until the various advanced Calc features are used. Since this mode only 12164has effect when Calc is first loaded, @kbd{m x} is usually followed by 12165@kbd{m m} to make the mode-setting permanent. To load all of Calc just 12166once, rather than always in the future, you can press @kbd{C-x * L}. 12167 12168@kindex m S 12169@pindex calc-shift-prefix 12170The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which 12171all of Calc's letter prefix keys may be typed shifted as well as unshifted. 12172If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often 12173you might find it easier to turn this mode on so that you can type 12174@kbd{A S} instead. When this mode is enabled, the commands that used to 12175be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can 12176now be invoked by pressing the shifted letter twice: @kbd{A A}. Note 12177that the @kbd{v} prefix key always works both shifted and unshifted, and 12178the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h} 12179prefix is not affected by this mode. Press @kbd{m S} again to disable 12180shifted-prefix mode. 12181 12182@node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings 12183@section Precision 12184 12185@noindent 12186@kindex p 12187@pindex calc-precision 12188@cindex Precision of calculations 12189The @kbd{p} (@code{calc-precision}) command controls the precision to 12190which floating-point calculations are carried. The precision must be 12191at least 3 digits and may be arbitrarily high, within the limits of 12192memory and time. This affects only floats: Integer and rational 12193calculations are always carried out with as many digits as necessary. 12194 12195The @kbd{p} key prompts for the current precision. If you wish you 12196can instead give the precision as a numeric prefix argument. 12197 12198Many internal calculations are carried to one or two digits higher 12199precision than normal. Results are rounded down afterward to the 12200current precision. Unless a special display mode has been selected, 12201floats are always displayed with their full stored precision, i.e., 12202what you see is what you get. Reducing the current precision does not 12203round values already on the stack, but those values will be rounded 12204down before being used in any calculation. The @kbd{c 0} through 12205@kbd{c 9} commands (@pxref{Conversions}) can be used to round an 12206existing value to a new precision. 12207 12208@cindex Accuracy of calculations 12209It is important to distinguish the concepts of @dfn{precision} and 12210@dfn{accuracy}. In the normal usage of these words, the number 12211123.4567 has a precision of 7 digits but an accuracy of 4 digits. 12212The precision is the total number of digits not counting leading 12213or trailing zeros (regardless of the position of the decimal point). 12214The accuracy is simply the number of digits after the decimal point 12215(again not counting trailing zeros). In Calc you control the precision, 12216not the accuracy of computations. If you were to set the accuracy 12217instead, then calculations like @samp{exp(100)} would generate many 12218more digits than you would typically need, while @samp{exp(-100)} would 12219probably round to zero! In Calc, both these computations give you 12220exactly 12 (or the requested number of) significant digits. 12221 12222The only Calc features that deal with accuracy instead of precision 12223are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}), 12224and the rounding functions like @code{floor} and @code{round} 12225(@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9} 12226deal with both precision and accuracy depending on the magnitudes 12227of the numbers involved. 12228 12229If you need to work with a particular fixed accuracy (say, dollars and 12230cents with two digits after the decimal point), one solution is to work 12231with integers and an ``implied'' decimal point. For example, $8.99 12232divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833 12233(actually $1.49833 with our implied decimal point); pressing @kbd{R} 12234would round this to 150 cents, i.e., $1.50. 12235 12236@xref{Floats}, for still more on floating-point precision and related 12237issues. 12238 12239@node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings 12240@section Inverse and Hyperbolic Flags 12241 12242@noindent 12243@kindex I 12244@pindex calc-inverse 12245There is no single-key equivalent to the @code{calc-arcsin} function. 12246Instead, you must first press @kbd{I} (@code{calc-inverse}) to set 12247the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}). 12248The @kbd{I} key actually toggles the Inverse Flag. When this flag 12249is set, the word @samp{Inv} appears in the mode line. 12250 12251@kindex H 12252@pindex calc-hyperbolic 12253Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the 12254Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}. 12255If both of these flags are set at once, the effect will be 12256@code{calc-arcsinh}. (The Hyperbolic flag is also used by some 12257non-trigonometric commands; for example @kbd{H L} computes a base-10, 12258instead of base-@mathit{e}, logarithm.) 12259 12260Command names like @code{calc-arcsin} are provided for completeness, and 12261may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to 12262toggle the Inverse and/or Hyperbolic flags and then execute the 12263corresponding base command (@code{calc-sin} in this case). 12264 12265@kindex O 12266@pindex calc-option 12267The @kbd{O} key (@code{calc-option}) sets another flag, the 12268@dfn{Option Flag}, which also can alter the subsequent Calc command in 12269various ways. 12270 12271The Inverse, Hyperbolic and Option flags apply only to the next 12272Calculator command, after which they are automatically cleared. (They 12273are also cleared if the next keystroke is not a Calc command.) Digits 12274you type after @kbd{I}, @kbd{H} or @kbd{O} (or @kbd{K}) are treated as 12275prefix arguments for the next command, not as numeric entries. The 12276same is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means 12277to subtract and keep arguments). 12278 12279Another Calc prefix flag, @kbd{K} (keep-arguments), is discussed 12280elsewhere. @xref{Keep Arguments}. 12281 12282@node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings 12283@section Calculation Modes 12284 12285@noindent 12286The commands in this section are two-key sequences beginning with 12287the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.) 12288The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere 12289(@pxref{Algebraic Entry}). 12290 12291@menu 12292* Angular Modes:: 12293* Polar Mode:: 12294* Fraction Mode:: 12295* Infinite Mode:: 12296* Symbolic Mode:: 12297* Matrix Mode:: 12298* Automatic Recomputation:: 12299* Working Message:: 12300@end menu 12301 12302@node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes 12303@subsection Angular Modes 12304 12305@noindent 12306@cindex Angular mode 12307The Calculator supports three notations for angles: radians, degrees, 12308and degrees-minutes-seconds. When a number is presented to a function 12309like @code{sin} that requires an angle, the current angular mode is 12310used to interpret the number as either radians or degrees. If an HMS 12311form is presented to @code{sin}, it is always interpreted as 12312degrees-minutes-seconds. 12313 12314Functions that compute angles produce a number in radians, a number in 12315degrees, or an HMS form depending on the current angular mode. If the 12316result is a complex number and the current mode is HMS, the number is 12317instead expressed in degrees. (Complex-number calculations would 12318normally be done in Radians mode, though. Complex numbers are converted 12319to degrees by calculating the complex result in radians and then 12320multiplying by 180 over @cpi{}.) 12321 12322@kindex m r 12323@pindex calc-radians-mode 12324@kindex m d 12325@pindex calc-degrees-mode 12326@kindex m h 12327@pindex calc-hms-mode 12328The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}), 12329and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode. 12330The current angular mode is displayed on the Emacs mode line. 12331The default angular mode is Degrees. 12332 12333@node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes 12334@subsection Polar Mode 12335 12336@noindent 12337@cindex Polar mode 12338The Calculator normally ``prefers'' rectangular complex numbers in the 12339sense that rectangular form is used when the proper form can not be 12340decided from the input. This might happen by multiplying a rectangular 12341number by a polar one, by taking the square root of a negative real 12342number, or by entering @kbd{( 2 @key{SPC} 3 )}. 12343 12344@kindex m p 12345@pindex calc-polar-mode 12346The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number 12347preference between rectangular and polar forms. In Polar mode, all 12348of the above example situations would produce polar complex numbers. 12349 12350@node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes 12351@subsection Fraction Mode 12352 12353@noindent 12354@cindex Fraction mode 12355@cindex Division of integers 12356Division of two integers normally yields a floating-point number if the 12357result cannot be expressed as an integer. In some cases you would 12358rather get an exact fractional answer. One way to accomplish this is 12359to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which 12360divides the two integers on the top of the stack to produce a fraction: 12361@kbd{6 @key{RET} 4 :} produces @expr{3:2} even though 12362@kbd{6 @key{RET} 4 /} produces @expr{1.5}. 12363 12364@kindex m f 12365@pindex calc-frac-mode 12366To set the Calculator to produce fractional results for normal integer 12367divisions, use the @kbd{m f} (@code{calc-frac-mode}) command. 12368For example, @expr{8/4} produces @expr{2} in either mode, 12369but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in 12370Float mode. 12371 12372At any time you can use @kbd{c f} (@code{calc-float}) to convert a 12373fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a 12374float to a fraction. @xref{Conversions}. 12375 12376@node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes 12377@subsection Infinite Mode 12378 12379@noindent 12380@cindex Infinite mode 12381The Calculator normally treats results like @expr{1 / 0} as errors; 12382formulas like this are left in unsimplified form. But Calc can be 12383put into a mode where such calculations instead produce ``infinite'' 12384results. 12385 12386@kindex m i 12387@pindex calc-infinite-mode 12388The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode 12389on and off. When the mode is off, infinities do not arise except 12390in calculations that already had infinities as inputs. (One exception 12391is that infinite open intervals like @samp{[0 .. inf)} can be 12392generated; however, intervals closed at infinity (@samp{[0 .. inf]}) 12393will not be generated when Infinite mode is off.) 12394 12395With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf}, 12396an undirected infinity. @xref{Infinities}, for a discussion of the 12397difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0} 12398evaluates to @code{nan}, the ``indeterminate'' symbol. Various other 12399functions can also return infinities in this mode; for example, 12400@samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again, 12401note that @samp{exp(inf) = inf} regardless of Infinite mode because 12402this calculation has infinity as an input. 12403 12404@cindex Positive Infinite mode 12405The @kbd{m i} command with a numeric prefix argument of zero, 12406i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in 12407which zero is treated as positive instead of being directionless. 12408Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode. 12409Note that zero never actually has a sign in Calc; there are no 12410separate representations for @mathit{+0} and @mathit{-0}. Positive 12411Infinite mode merely changes the interpretation given to the 12412single symbol, @samp{0}. One consequence of this is that, while 12413you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0} 12414is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}. 12415 12416@node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes 12417@subsection Symbolic Mode 12418 12419@noindent 12420@cindex Symbolic mode 12421@cindex Inexact results 12422Calculations are normally performed numerically wherever possible. 12423For example, the @code{calc-sqrt} command, or @code{sqrt} function in an 12424algebraic expression, produces a numeric answer if the argument is a 12425number or a symbolic expression if the argument is an expression: 12426@kbd{2 Q} pushes 1.4142 but @kbd{' x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}. 12427 12428@kindex m s 12429@pindex calc-symbolic-mode 12430In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode}) 12431command, functions which would produce inexact, irrational results are 12432left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes 12433@samp{sqrt(2)}. 12434 12435@kindex N 12436@pindex calc-eval-num 12437The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically 12438the expression at the top of the stack, by temporarily disabling 12439@code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}). 12440Given a numeric prefix argument, it also 12441sets the floating-point precision to the specified value for the duration 12442of the command. 12443 12444To evaluate a formula numerically without expanding the variables it 12445contains, you can use the key sequence @kbd{m s a v m s} (this uses 12446@code{calc-alg-evaluate}, which resimplifies but doesn't evaluate 12447variables.) 12448 12449@node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes 12450@subsection Matrix and Scalar Modes 12451 12452@noindent 12453@cindex Matrix mode 12454@cindex Scalar mode 12455Calc sometimes makes assumptions during algebraic manipulation that 12456are awkward or incorrect when vectors and matrices are involved. 12457Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which 12458modify its behavior around vectors in useful ways. 12459 12460@kindex m v 12461@pindex calc-matrix-mode 12462Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode. 12463In this mode, all objects are assumed to be matrices unless provably 12464otherwise. One major effect is that Calc will no longer consider 12465multiplication to be commutative. (Recall that in matrix arithmetic, 12466@samp{A*B} is not the same as @samp{B*A}.) This assumption affects 12467rewrite rules and algebraic simplification. Another effect of this 12468mode is that calculations that would normally produce constants like 124690 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now 12470produce function calls that represent ``generic'' zero or identity 12471matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function 12472@samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n} 12473identity matrix; if @var{n} is omitted, it doesn't know what 12474dimension to use and so the @code{idn} call remains in symbolic 12475form. However, if this generic identity matrix is later combined 12476with a matrix whose size is known, it will be converted into 12477a true identity matrix of the appropriate size. On the other hand, 12478if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc 12479will assume it really was a scalar after all and produce, e.g., 3. 12480 12481Press @kbd{m v} a second time to get Scalar mode. Here, objects are 12482assumed @emph{not} to be vectors or matrices unless provably so. 12483For example, normally adding a variable to a vector, as in 12484@samp{[x, y, z] + a}, will leave the sum in symbolic form because 12485as far as Calc knows, @samp{a} could represent either a number or 12486another 3-vector. In Scalar mode, @samp{a} is assumed to be a 12487non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}. 12488 12489Press @kbd{m v} a third time to return to the normal mode of operation. 12490 12491If you press @kbd{m v} with a numeric prefix argument @var{n}, you 12492get a special ``dimensioned'' Matrix mode in which matrices of 12493unknown size are assumed to be @var{n}x@var{n} square matrices. 12494Then, the function call @samp{idn(1)} will expand into an actual 12495matrix rather than representing a ``generic'' matrix. Simply typing 12496@kbd{C-u m v} will get you a square Matrix mode, in which matrices of 12497unknown size are assumed to be square matrices of unspecified size. 12498 12499@cindex Declaring scalar variables 12500Of course these modes are approximations to the true state of 12501affairs, which is probably that some quantities will be matrices 12502and others will be scalars. One solution is to ``declare'' 12503certain variables or functions to be scalar-valued. 12504@xref{Declarations}, to see how to make declarations in Calc. 12505 12506There is nothing stopping you from declaring a variable to be 12507scalar and then storing a matrix in it; however, if you do, the 12508results you get from Calc may not be valid. Suppose you let Calc 12509get the result @samp{[x+a, y+a, z+a]} shown above, and then stored 12510@samp{[1, 2, 3]} in @samp{a}. The result would not be the same as 12511for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken 12512your earlier promise to Calc that @samp{a} would be scalar. 12513 12514Another way to mix scalars and matrices is to use selections 12515(@pxref{Selecting Subformulas}). Use Matrix mode when operating on 12516your formula normally; then, to apply Scalar mode to a certain part 12517of the formula without affecting the rest just select that part, 12518change into Scalar mode and press @kbd{=} to resimplify the part 12519under this mode, then change back to Matrix mode before deselecting. 12520 12521@node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes 12522@subsection Automatic Recomputation 12523 12524@noindent 12525The @dfn{evaluates-to} operator, @samp{=>}, has the special 12526property that any @samp{=>} formulas on the stack are recomputed 12527whenever variable values or mode settings that might affect them 12528are changed. @xref{Evaluates-To Operator}. 12529 12530@kindex m C 12531@pindex calc-auto-recompute 12532The @kbd{m C} (@code{calc-auto-recompute}) command turns this 12533automatic recomputation on and off. If you turn it off, Calc will 12534not update @samp{=>} operators on the stack (nor those in the 12535attached Embedded mode buffer, if there is one). They will not 12536be updated unless you explicitly do so by pressing @kbd{=} or until 12537you press @kbd{m C} to turn recomputation back on. (While automatic 12538recomputation is off, you can think of @kbd{m C m C} as a command 12539to update all @samp{=>} operators while leaving recomputation off.) 12540 12541To update @samp{=>} operators in an Embedded buffer while 12542automatic recomputation is off, use @w{@kbd{C-x * u}}. 12543@xref{Embedded Mode}. 12544 12545@node Working Message, , Automatic Recomputation, Calculation Modes 12546@subsection Working Messages 12547 12548@noindent 12549@cindex Performance 12550@cindex Working messages 12551Since the Calculator is written entirely in Emacs Lisp, which is not 12552designed for heavy numerical work, many operations are quite slow. 12553The Calculator normally displays the message @samp{Working...} in the 12554echo area during any command that may be slow. In addition, iterative 12555operations such as square roots and trigonometric functions display the 12556intermediate result at each step. Both of these types of messages can 12557be disabled if you find them distracting. 12558 12559@kindex m w 12560@pindex calc-working 12561Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to 12562disable all ``working'' messages. Use a numeric prefix of 1 to enable 12563only the plain @samp{Working...} message. Use a numeric prefix of 2 to 12564see intermediate results as well. With no numeric prefix this displays 12565the current mode. 12566 12567While it may seem that the ``working'' messages will slow Calc down 12568considerably, experiments have shown that their impact is actually 12569quite small. But if your terminal is slow you may find that it helps 12570to turn the messages off. 12571 12572@node Simplification Modes, Declarations, Calculation Modes, Mode Settings 12573@section Simplification Modes 12574 12575@noindent 12576The current @dfn{simplification mode} controls how numbers and formulas 12577are ``normalized'' when being taken from or pushed onto the stack. 12578Some normalizations are unavoidable, such as rounding floating-point 12579results to the current precision, and reducing fractions to simplest 12580form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}), 12581are done automatically but can be turned off when necessary. 12582 12583When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the 12584stack, Calc pops these numbers, normalizes them, creates the formula 12585@expr{2+3}, normalizes it, and pushes the result. Of course the standard 12586rules for normalizing @expr{2+3} will produce the result @expr{5}. 12587 12588Simplification mode commands consist of the lower-case @kbd{m} prefix key 12589followed by a shifted letter. 12590 12591@kindex m O 12592@pindex calc-no-simplify-mode 12593The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional 12594simplifications. These would leave a formula like @expr{2+3} alone. In 12595fact, nothing except simple numbers are ever affected by normalization 12596in this mode. Explicit simplification commands, such as @kbd{=} or 12597@kbd{a s}, can still be given to simplify any formulas. 12598@xref{Algebraic Definitions}, for a sample use of 12599No-Simplification mode. 12600 12601@kindex m N 12602@pindex calc-num-simplify-mode 12603The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification 12604of any formulas except those for which all arguments are constants. For 12605example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is 12606simplified to @expr{a+0} but no further, since one argument of the sum 12607is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified 12608because the top-level @samp{-} operator's arguments are not both 12609constant numbers (one of them is the formula @expr{a+2}). 12610A constant is a number or other numeric object (such as a constant 12611error form or modulo form), or a vector all of whose 12612elements are constant. 12613 12614@kindex m I 12615@pindex calc-basic-simplify-mode 12616The @kbd{m I} (@code{calc-basic-simplify-mode}) command does some basic 12617simplifications for all formulas. This includes many easy and 12618fast algebraic simplifications such as @expr{a+0} to @expr{a}, and 12619@expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like 12620@expr{@tfn{deriv}(x^2, x)} to @expr{2 x}. 12621 12622@kindex m B 12623@pindex calc-bin-simplify-mode 12624The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the basic 12625simplifications to a result and then, if the result is an integer, 12626uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according 12627to the current binary word size. @xref{Binary Functions}. Real numbers 12628are rounded to the nearest integer and then clipped; other kinds of 12629results (after the basic simplifications) are left alone. 12630 12631@kindex m A 12632@pindex calc-alg-simplify-mode 12633The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does standard 12634algebraic simplifications. @xref{Algebraic Simplifications}. 12635 12636@kindex m E 12637@pindex calc-ext-simplify-mode 12638The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended'', or 12639``unsafe'', algebraic simplification. @xref{Unsafe Simplifications}. 12640 12641@kindex m U 12642@pindex calc-units-simplify-mode 12643The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units 12644simplification. @xref{Simplification of Units}. These include the 12645algebraic simplifications, plus variable names which 12646are identifiable as unit names (like @samp{mm} for ``millimeters'') 12647are simplified with their unit definitions in mind. 12648 12649A common technique is to set the simplification mode down to the lowest 12650amount of simplification you will allow to be applied automatically, then 12651use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to 12652perform higher types of simplifications on demand. 12653@node Declarations, Display Modes, Simplification Modes, Mode Settings 12654@section Declarations 12655 12656@noindent 12657A @dfn{declaration} is a statement you make that promises you will 12658use a certain variable or function in a restricted way. This may 12659give Calc the freedom to do things that it couldn't do if it had to 12660take the fully general situation into account. 12661 12662@menu 12663* Declaration Basics:: 12664* Kinds of Declarations:: 12665* Functions for Declarations:: 12666@end menu 12667 12668@node Declaration Basics, Kinds of Declarations, Declarations, Declarations 12669@subsection Declaration Basics 12670 12671@noindent 12672@kindex s d 12673@pindex calc-declare-variable 12674The @kbd{s d} (@code{calc-declare-variable}) command is the easiest 12675way to make a declaration for a variable. This command prompts for 12676the variable name, then prompts for the declaration. The default 12677at the declaration prompt is the previous declaration, if any. 12678You can edit this declaration, or press @kbd{C-k} to erase it and 12679type a new declaration. (Or, erase it and press @key{RET} to clear 12680the declaration, effectively ``undeclaring'' the variable.) 12681 12682A declaration is in general a vector of @dfn{type symbols} and 12683@dfn{range} values. If there is only one type symbol or range value, 12684you can write it directly rather than enclosing it in a vector. 12685For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to 12686be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}} 12687declares @code{bar} to be a constant integer between 1 and 6. 12688(Actually, you can omit the outermost brackets and Calc will 12689provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.) 12690 12691@cindex @code{Decls} variable 12692@vindex Decls 12693Declarations in Calc are kept in a special variable called @code{Decls}. 12694This variable encodes the set of all outstanding declarations in 12695the form of a matrix. Each row has two elements: A variable or 12696vector of variables declared by that row, and the declaration 12697specifier as described above. You can use the @kbd{s D} command to 12698edit this variable if you wish to see all the declarations at once. 12699@xref{Operations on Variables}, for a description of this command 12700and the @kbd{s p} command that allows you to save your declarations 12701permanently if you wish. 12702 12703Items being declared can also be function calls. The arguments in 12704the call are ignored; the effect is to say that this function returns 12705values of the declared type for any valid arguments. The @kbd{s d} 12706command declares only variables, so if you wish to make a function 12707declaration you will have to edit the @code{Decls} matrix yourself. 12708 12709For example, the declaration matrix 12710 12711@smallexample 12712@group 12713[ [ foo, real ] 12714 [ [j, k, n], int ] 12715 [ f(1,2,3), [0 .. inf) ] ] 12716@end group 12717@end smallexample 12718 12719@noindent 12720declares that @code{foo} represents a real number, @code{j}, @code{k} 12721and @code{n} represent integers, and the function @code{f} always 12722returns a real number in the interval shown. 12723 12724@vindex All 12725If there is a declaration for the variable @code{All}, then that 12726declaration applies to all variables that are not otherwise declared. 12727It does not apply to function names. For example, using the row 12728@samp{[All, real]} says that all your variables are real unless they 12729are explicitly declared without @code{real} in some other row. 12730The @kbd{s d} command declares @code{All} if you give a blank 12731response to the variable-name prompt. 12732 12733@node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations 12734@subsection Kinds of Declarations 12735 12736@noindent 12737The type-specifier part of a declaration (that is, the second prompt 12738in the @kbd{s d} command) can be a type symbol, an interval, or a 12739vector consisting of zero or more type symbols followed by zero or 12740more intervals or numbers that represent the set of possible values 12741for the variable. 12742 12743@smallexample 12744@group 12745[ [ a, [1, 2, 3, 4, 5] ] 12746 [ b, [1 .. 5] ] 12747 [ c, [int, 1 .. 5] ] ] 12748@end group 12749@end smallexample 12750 12751Here @code{a} is declared to contain one of the five integers shown; 12752@code{b} is any number in the interval from 1 to 5 (any real number 12753since we haven't specified), and @code{c} is any integer in that 12754interval. Thus the declarations for @code{a} and @code{c} are 12755nearly equivalent (see below). 12756 12757The type-specifier can be the empty vector @samp{[]} to say that 12758nothing is known about a given variable's value. This is the same 12759as not declaring the variable at all except that it overrides any 12760@code{All} declaration which would otherwise apply. 12761 12762The initial value of @code{Decls} is the empty vector @samp{[]}. 12763If @code{Decls} has no stored value or if the value stored in it 12764is not valid, it is ignored and there are no declarations as far 12765as Calc is concerned. (The @kbd{s d} command will replace such a 12766malformed value with a fresh empty matrix, @samp{[]}, before recording 12767the new declaration.) Unrecognized type symbols are ignored. 12768 12769The following type symbols describe what sorts of numbers will be 12770stored in a variable: 12771 12772@table @code 12773@item int 12774Integers. 12775@item numint 12776Numerical integers. (Integers or integer-valued floats.) 12777@item frac 12778Fractions. (Rational numbers which are not integers.) 12779@item rat 12780Rational numbers. (Either integers or fractions.) 12781@item float 12782Floating-point numbers. 12783@item real 12784Real numbers. (Integers, fractions, or floats. Actually, 12785intervals and error forms with real components also count as 12786reals here.) 12787@item pos 12788Positive real numbers. (Strictly greater than zero.) 12789@item nonneg 12790Nonnegative real numbers. (Greater than or equal to zero.) 12791@item number 12792Numbers. (Real or complex.) 12793@end table 12794 12795Calc uses this information to determine when certain simplifications 12796of formulas are safe. For example, @samp{(x^y)^z} cannot be 12797simplified to @samp{x^(y z)} in general; for example, 12798@samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}. 12799However, this simplification @emph{is} safe if @code{z} is known 12800to be an integer, or if @code{x} is known to be a nonnegative 12801real number. If you have given declarations that allow Calc to 12802deduce either of these facts, Calc will perform this simplification 12803of the formula. 12804 12805Calc can apply a certain amount of logic when using declarations. 12806For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n} 12807has been declared @code{int}; Calc knows that an integer times an 12808integer, plus an integer, must always be an integer. (In fact, 12809Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since 12810it is able to determine that @samp{2n+1} must be an odd integer.) 12811 12812Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)} 12813because Calc knows that the @code{abs} function always returns a 12814nonnegative real. If you had a @code{myabs} function that also had 12815this property, you could get Calc to recognize it by adding the row 12816@samp{[myabs(), nonneg]} to the @code{Decls} matrix. 12817 12818One instance of this simplification is @samp{sqrt(x^2)} (since the 12819@code{sqrt} function is effectively a one-half power). Normally 12820Calc leaves this formula alone. After the command 12821@kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to 12822@samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can 12823simplify this formula all the way to @samp{x}. 12824 12825If there are any intervals or real numbers in the type specifier, 12826they comprise the set of possible values that the variable or 12827function being declared can have. In particular, the type symbol 12828@code{real} is effectively the same as the range @samp{[-inf .. inf]} 12829(note that infinity is included in the range of possible values); 12830@code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is 12831the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is 12832redundant because the fact that the variable is real can be 12833deduced just from the interval, but @samp{[int, [-5 .. 5]]} and 12834@samp{[rat, [-5 .. 5]]} are useful combinations. 12835 12836Note that the vector of intervals or numbers is in the same format 12837used by Calc's set-manipulation commands. @xref{Set Operations}. 12838 12839The type specifier @samp{[1, 2, 3]} is equivalent to 12840@samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}. 12841In other words, the range of possible values means only that 12842the variable's value must be numerically equal to a number in 12843that range, but not that it must be equal in type as well. 12844Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])} 12845and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.'' 12846 12847If you use a conflicting combination of type specifiers, the 12848results are unpredictable. An example is @samp{[pos, [0 .. 5]]}, 12849where the interval does not lie in the range described by the 12850type symbol. 12851 12852``Real'' declarations mostly affect simplifications involving powers 12853like the one described above. Another case where they are used 12854is in the @kbd{a P} command which returns a list of all roots of a 12855polynomial; if the variable has been declared real, only the real 12856roots (if any) will be included in the list. 12857 12858``Integer'' declarations are used for simplifications which are valid 12859only when certain values are integers (such as @samp{(x^y)^z} 12860shown above). 12861 12862Calc's algebraic simplifications also make use of declarations when 12863simplifying equations and inequalities. They will cancel @code{x} 12864from both sides of @samp{a x = b x} only if it is sure @code{x} 12865is non-zero, say, because it has a @code{pos} declaration. 12866To declare specifically that @code{x} is real and non-zero, 12867use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the 12868current notation to say that @code{x} is nonzero but not necessarily 12869real.) The @kbd{a e} command does ``unsafe'' simplifications, 12870including canceling @samp{x} from the equation when @samp{x} is 12871not known to be nonzero. 12872 12873Another set of type symbols distinguish between scalars and vectors. 12874 12875@table @code 12876@item scalar 12877The value is not a vector. 12878@item vector 12879The value is a vector. 12880@item matrix 12881The value is a matrix (a rectangular vector of vectors). 12882@item sqmatrix 12883The value is a square matrix. 12884@end table 12885 12886These type symbols can be combined with the other type symbols 12887described above; @samp{[int, matrix]} describes an object which 12888is a matrix of integers. 12889 12890Scalar/vector declarations are used to determine whether certain 12891algebraic operations are safe. For example, @samp{[a, b, c] + x} 12892is normally not simplified to @samp{[a + x, b + x, c + x]}, but 12893it will be if @code{x} has been declared @code{scalar}. On the 12894other hand, multiplication is usually assumed to be commutative, 12895but the terms in @samp{x y} will never be exchanged if both @code{x} 12896and @code{y} are known to be vectors or matrices. (Calc currently 12897never distinguishes between @code{vector} and @code{matrix} 12898declarations.) 12899 12900@xref{Matrix Mode}, for a discussion of Matrix mode and 12901Scalar mode, which are similar to declaring @samp{[All, matrix]} 12902or @samp{[All, scalar]} but much more convenient. 12903 12904One more type symbol that is recognized is used with the @kbd{H a d} 12905command for taking total derivatives of a formula. @xref{Calculus}. 12906 12907@table @code 12908@item const 12909The value is a constant with respect to other variables. 12910@end table 12911 12912Calc does not check the declarations for a variable when you store 12913a value in it. However, storing @mathit{-3.5} in a variable that has 12914been declared @code{pos}, @code{int}, or @code{matrix} may have 12915unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5} 12916if it substitutes the value first, or to @expr{-3.5} if @code{x} 12917was declared @code{pos} and the formula @samp{sqrt(x^2)} is 12918simplified to @samp{x} before the value is substituted. Before 12919using a variable for a new purpose, it is best to use @kbd{s d} 12920or @kbd{s D} to check to make sure you don't still have an old 12921declaration for the variable that will conflict with its new meaning. 12922 12923@node Functions for Declarations, , Kinds of Declarations, Declarations 12924@subsection Functions for Declarations 12925 12926@noindent 12927Calc has a set of functions for accessing the current declarations 12928in a convenient manner. These functions return 1 if the argument 12929can be shown to have the specified property, or 0 if the argument 12930can be shown @emph{not} to have that property; otherwise they are 12931left unevaluated. These functions are suitable for use with rewrite 12932rules (@pxref{Conditional Rewrite Rules}) or programming constructs 12933(@pxref{Conditionals in Macros}). They can be entered only using 12934algebraic notation. @xref{Logical Operations}, for functions 12935that perform other tests not related to declarations. 12936 12937For example, @samp{dint(17)} returns 1 because 17 is an integer, as 12938do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared 12939@code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0. 12940Calc consults knowledge of its own built-in functions as well as your 12941own declarations: @samp{dint(floor(x))} returns 1. 12942 12943@ignore 12944@starindex 12945@end ignore 12946@tindex dint 12947@ignore 12948@starindex 12949@end ignore 12950@tindex dnumint 12951@ignore 12952@starindex 12953@end ignore 12954@tindex dnatnum 12955The @code{dint} function checks if its argument is an integer. 12956The @code{dnatnum} function checks if its argument is a natural 12957number, i.e., a nonnegative integer. The @code{dnumint} function 12958checks if its argument is numerically an integer, i.e., either an 12959integer or an integer-valued float. Note that these and the other 12960data type functions also accept vectors or matrices composed of 12961suitable elements, and that real infinities @samp{inf} and @samp{-inf} 12962are considered to be integers for the purposes of these functions. 12963 12964@ignore 12965@starindex 12966@end ignore 12967@tindex drat 12968The @code{drat} function checks if its argument is rational, i.e., 12969an integer or fraction. Infinities count as rational, but intervals 12970and error forms do not. 12971 12972@ignore 12973@starindex 12974@end ignore 12975@tindex dreal 12976The @code{dreal} function checks if its argument is real. This 12977includes integers, fractions, floats, real error forms, and intervals. 12978 12979@ignore 12980@starindex 12981@end ignore 12982@tindex dimag 12983The @code{dimag} function checks if its argument is imaginary, 12984i.e., is mathematically equal to a real number times @expr{i}. 12985 12986@ignore 12987@starindex 12988@end ignore 12989@tindex dpos 12990@ignore 12991@starindex 12992@end ignore 12993@tindex dneg 12994@ignore 12995@starindex 12996@end ignore 12997@tindex dnonneg 12998The @code{dpos} function checks for positive (but nonzero) reals. 12999The @code{dneg} function checks for negative reals. The @code{dnonneg} 13000function checks for nonnegative reals, i.e., reals greater than or 13001equal to zero. Note that Calc's algebraic simplifications, which are 13002effectively applied to all conditions in rewrite rules, can simplify 13003an expression like @expr{x > 0} to 1 or 0 using @code{dpos}. 13004So the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg} 13005are rarely necessary. 13006 13007@ignore 13008@starindex 13009@end ignore 13010@tindex dnonzero 13011The @code{dnonzero} function checks that its argument is nonzero. 13012This includes all nonzero real or complex numbers, all intervals that 13013do not include zero, all nonzero modulo forms, vectors all of whose 13014elements are nonzero, and variables or formulas whose values can be 13015deduced to be nonzero. It does not include error forms, since they 13016represent values which could be anything including zero. (This is 13017also the set of objects considered ``true'' in conditional contexts.) 13018 13019@ignore 13020@starindex 13021@end ignore 13022@tindex deven 13023@ignore 13024@starindex 13025@end ignore 13026@tindex dodd 13027The @code{deven} function returns 1 if its argument is known to be 13028an even integer (or integer-valued float); it returns 0 if its argument 13029is known not to be even (because it is known to be odd or a non-integer). 13030Calc's algebraic simplifications use this to simplify a test of the form 13031@samp{x % 2 = 0}. There is also an analogous @code{dodd} function. 13032 13033@ignore 13034@starindex 13035@end ignore 13036@tindex drange 13037The @code{drange} function returns a set (an interval or a vector 13038of intervals and/or numbers; @pxref{Set Operations}) that describes 13039the set of possible values of its argument. If the argument is 13040a variable or a function with a declaration, the range is copied 13041from the declaration. Otherwise, the possible signs of the 13042expression are determined using a method similar to @code{dpos}, 13043etc., and a suitable set like @samp{[0 .. inf]} is returned. If 13044the expression is not provably real, the @code{drange} function 13045remains unevaluated. 13046 13047@ignore 13048@starindex 13049@end ignore 13050@tindex dscalar 13051The @code{dscalar} function returns 1 if its argument is provably 13052scalar, or 0 if its argument is provably non-scalar. It is left 13053unevaluated if this cannot be determined. (If Matrix mode or Scalar 13054mode is in effect, this function returns 1 or 0, respectively, 13055if it has no other information.) When Calc interprets a condition 13056(say, in a rewrite rule) it considers an unevaluated formula to be 13057``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is 13058provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a} 13059is provably non-scalar; both are ``false'' if there is insufficient 13060information to tell. 13061 13062@node Display Modes, Language Modes, Declarations, Mode Settings 13063@section Display Modes 13064 13065@noindent 13066The commands in this section are two-key sequences beginning with the 13067@kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b} 13068(@code{calc-line-breaking}) commands are described elsewhere; 13069@pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively. 13070Display formats for vectors and matrices are also covered elsewhere; 13071@pxref{Vector and Matrix Formats}. 13072 13073One thing all display modes have in common is their treatment of the 13074@kbd{H} prefix. This prefix causes any mode command that would normally 13075refresh the stack to leave the stack display alone. The word ``Dirty'' 13076will appear in the mode line when Calc thinks the stack display may not 13077reflect the latest mode settings. 13078 13079@kindex d RET 13080@pindex calc-refresh-top 13081The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the 13082top stack entry according to all the current modes. Positive prefix 13083arguments reformat the top @var{n} entries; negative prefix arguments 13084reformat the specified entry, and a prefix of zero is equivalent to 13085@kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack. 13086For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation 13087but reformats only the top two stack entries in the new mode. 13088 13089The @kbd{I} prefix has another effect on the display modes. The mode 13090is set only temporarily; the top stack entry is reformatted according 13091to that mode, then the original mode setting is restored. In other 13092words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}. 13093 13094@menu 13095* Radix Modes:: 13096* Grouping Digits:: 13097* Float Formats:: 13098* Complex Formats:: 13099* Fraction Formats:: 13100* HMS Formats:: 13101* Date Formats:: 13102* Truncating the Stack:: 13103* Justification:: 13104* Labels:: 13105@end menu 13106 13107@node Radix Modes, Grouping Digits, Display Modes, Display Modes 13108@subsection Radix Modes 13109 13110@noindent 13111@cindex Radix display 13112@cindex Non-decimal numbers 13113@cindex Decimal and non-decimal numbers 13114Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10}) 13115notation. Calc can actually display in any radix from two (binary) to 36. 13116When the radix is above 10, the letters @code{A} to @code{Z} are used as 13117digits. When entering such a number, letter keys are interpreted as 13118potential digits rather than terminating numeric entry mode. 13119 13120@kindex d 2 13121@kindex d 8 13122@kindex d 6 13123@kindex d 0 13124@cindex Hexadecimal integers 13125@cindex Octal integers 13126The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select 13127binary, octal, hexadecimal, and decimal as the current display radix, 13128respectively. Numbers can always be entered in any radix, though the 13129current radix is used as a default if you press @kbd{#} without any initial 13130digits. A number entered without a @kbd{#} is @emph{always} interpreted 13131as decimal. 13132 13133@kindex d r 13134@pindex calc-radix 13135To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter 13136an integer from 2 to 36. You can specify the radix as a numeric prefix 13137argument; otherwise you will be prompted for it. 13138 13139@kindex d z 13140@pindex calc-leading-zeros 13141@cindex Leading zeros 13142Integers normally are displayed with however many digits are necessary to 13143represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros}) 13144command causes integers to be padded out with leading zeros according to the 13145current binary word size. (@xref{Binary Functions}, for a discussion of 13146word size.) If the absolute value of the word size is @expr{w}, all integers 13147are displayed with at least enough digits to represent 13148@texline @math{2^w-1} 13149@infoline @expr{(2^w)-1} 13150in the current radix. (Larger integers will still be displayed in their 13151entirety.) 13152 13153@cindex Two's complements 13154Calc can display @expr{w}-bit integers using two's complement 13155notation, although this is most useful with the binary, octal and 13156hexadecimal display modes. This option is selected by using the 13157@kbd{O} option prefix before setting the display radix, and a negative word 13158size might be appropriate (@pxref{Binary Functions}). In two's 13159complement notation, the integers in the (nearly) symmetric interval 13160from 13161@texline @math{-2^{w-1}} 13162@infoline @expr{-2^(w-1)} 13163to 13164@texline @math{2^{w-1}-1} 13165@infoline @expr{2^(w-1)-1} 13166are represented by the integers from @expr{0} to @expr{2^w-1}: 13167the integers from @expr{0} to 13168@texline @math{2^{w-1}-1} 13169@infoline @expr{2^(w-1)-1} 13170are represented by themselves and the integers from 13171@texline @math{-2^{w-1}} 13172@infoline @expr{-2^(w-1)} 13173to @expr{-1} are represented by the integers from 13174@texline @math{2^{w-1}} 13175@infoline @expr{2^(w-1)} 13176to @expr{2^w-1} (the integer @expr{k} is represented by @expr{k+2^w}). 13177Calc will display a two's complement integer by the radix (either 13178@expr{2}, @expr{8} or @expr{16}), two @kbd{#} symbols, and then its 13179representation (including any leading zeros necessary to include all 13180@expr{w} bits). In a two's complement display mode, numbers that 13181are not displayed in two's complement notation (i.e., that aren't 13182integers from 13183@texline @math{-2^{w-1}} 13184@infoline @expr{-2^(w-1)} 13185to 13186@c ( 13187@texline @math{2^{w-1}-1}) 13188@infoline @expr{2^(w-1)-1}) 13189will be represented using Calc's usual notation (in the appropriate 13190radix). 13191 13192@node Grouping Digits, Float Formats, Radix Modes, Display Modes 13193@subsection Grouping Digits 13194 13195@noindent 13196@kindex d g 13197@pindex calc-group-digits 13198@cindex Grouping digits 13199@cindex Digit grouping 13200Long numbers can be hard to read if they have too many digits. For 13201example, the factorial of 30 is 33 digits long! Press @kbd{d g} 13202(@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits 13203are displayed in clumps of 3 or 4 (depending on the current radix) 13204separated by commas. 13205 13206The @kbd{d g} command toggles grouping on and off. 13207With a numeric prefix of 0, this command displays the current state of 13208the grouping flag; with an argument of minus one it disables grouping; 13209with a positive argument @expr{N} it enables grouping on every @expr{N} 13210digits. For floating-point numbers, grouping normally occurs only 13211before the decimal point. A negative prefix argument @expr{-N} enables 13212grouping every @expr{N} digits both before and after the decimal point. 13213 13214@kindex d , 13215@pindex calc-group-char 13216The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any 13217character as the grouping separator. The default is the comma character. 13218If you find it difficult to read vectors of large integers grouped with 13219commas, you may wish to use spaces or some other character instead. 13220This command takes the next character you type, whatever it is, and 13221uses it as the digit separator. As a special case, @kbd{d , \} selects 13222@samp{\,} (@TeX{}'s thin-space symbol) as the digit separator. 13223 13224Please note that grouped numbers will not generally be parsed correctly 13225if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}. 13226(@xref{Kill and Yank}, for details on these commands.) One exception is 13227the @samp{\,} separator, which doesn't interfere with parsing because it 13228is ignored by @TeX{} language mode. 13229 13230@node Float Formats, Complex Formats, Grouping Digits, Display Modes 13231@subsection Float Formats 13232 13233@noindent 13234Floating-point quantities are normally displayed in standard decimal 13235form, with scientific notation used if the exponent is especially high 13236or low. All significant digits are normally displayed. The commands 13237in this section allow you to choose among several alternative display 13238formats for floats. 13239 13240@kindex d n 13241@pindex calc-normal-notation 13242The @kbd{d n} (@code{calc-normal-notation}) command selects the normal 13243display format. All significant figures in a number are displayed. 13244With a positive numeric prefix, numbers are rounded if necessary to 13245that number of significant digits. With a negative numerix prefix, 13246the specified number of significant digits less than the current 13247precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the 13248current precision is 12.) 13249 13250@kindex d f 13251@pindex calc-fix-notation 13252The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point 13253notation. The numeric argument is the number of digits after the 13254decimal point, zero or more. This format will relax into scientific 13255notation if a nonzero number would otherwise have been rounded all the 13256way to zero. Specifying a negative number of digits is the same as 13257for a positive number, except that small nonzero numbers will be rounded 13258to zero rather than switching to scientific notation. 13259 13260@kindex d s 13261@pindex calc-sci-notation 13262@cindex Scientific notation, display of 13263The @kbd{d s} (@code{calc-sci-notation}) command selects scientific 13264notation. A positive argument sets the number of significant figures 13265displayed, of which one will be before and the rest after the decimal 13266point. A negative argument works the same as for @kbd{d n} format. 13267The default is to display all significant digits. 13268 13269@kindex d e 13270@pindex calc-eng-notation 13271@cindex Engineering notation, display of 13272The @kbd{d e} (@code{calc-eng-notation}) command selects engineering 13273notation. This is similar to scientific notation except that the 13274exponent is rounded down to a multiple of three, with from one to three 13275digits before the decimal point. An optional numeric prefix sets the 13276number of significant digits to display, as for @kbd{d s}. 13277 13278It is important to distinguish between the current @emph{precision} and 13279the current @emph{display format}. After the commands @kbd{C-u 10 p} 13280and @kbd{C-u 6 d n} the Calculator computes all results to ten 13281significant figures but displays only six. (In fact, intermediate 13282calculations are often carried to one or two more significant figures, 13283but values placed on the stack will be rounded down to ten figures.) 13284Numbers are never actually rounded to the display precision for storage, 13285except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the 13286actual displayed text in the Calculator buffer. 13287 13288@kindex d . 13289@pindex calc-point-char 13290The @kbd{d .} (@code{calc-point-char}) command selects the character used 13291as a decimal point. Normally this is a period; users in some countries 13292may wish to change this to a comma. Note that this is only a display 13293style; on entry, periods must always be used to denote floating-point 13294numbers, and commas to separate elements in a list. 13295 13296@node Complex Formats, Fraction Formats, Float Formats, Display Modes 13297@subsection Complex Formats 13298 13299@noindent 13300@kindex d c 13301@pindex calc-complex-notation 13302There are three supported notations for complex numbers in rectangular 13303form. The default is as a pair of real numbers enclosed in parentheses 13304and separated by a comma: @samp{(a,b)}. The @kbd{d c} 13305(@code{calc-complex-notation}) command selects this style. 13306 13307@kindex d i 13308@pindex calc-i-notation 13309@kindex d j 13310@pindex calc-j-notation 13311The other notations are @kbd{d i} (@code{calc-i-notation}), in which 13312numbers are displayed in @samp{a+bi} form, and @kbd{d j} 13313(@code{calc-j-notation}) which displays the form @samp{a+bj} preferred 13314in some disciplines. 13315 13316@cindex @code{i} variable 13317@vindex i 13318Complex numbers are normally entered in @samp{(a,b)} format. 13319If you enter @samp{2+3i} as an algebraic formula, it will be stored as 13320the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate 13321this formula and you have not changed the variable @samp{i}, the @samp{i} 13322will be interpreted as @samp{(0,1)} and the formula will be simplified 13323to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not} 13324interpret the formula @samp{2 + 3 * i} as a complex number. 13325@xref{Variables}, under ``special constants.'' 13326 13327@node Fraction Formats, HMS Formats, Complex Formats, Display Modes 13328@subsection Fraction Formats 13329 13330@noindent 13331@kindex d o 13332@pindex calc-over-notation 13333Display of fractional numbers is controlled by the @kbd{d o} 13334(@code{calc-over-notation}) command. By default, a number like 13335eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command 13336prompts for a one- or two-character format. If you give one character, 13337that character is used as the fraction separator. Common separators are 13338@samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be 13339used regardless of the display format; in particular, the @kbd{/} is used 13340for RPN-style division, @emph{not} for entering fractions.) 13341 13342If you give two characters, fractions use ``integer-plus-fractional-part'' 13343notation. For example, the format @samp{+/} would display eight thirds 13344as @samp{2+2/3}. If two colons are present in a number being entered, 13345the number is interpreted in this form (so that the entries @kbd{2:2:3} 13346and @kbd{8:3} are equivalent). 13347 13348It is also possible to follow the one- or two-character format with 13349a number. For example: @samp{:10} or @samp{+/3}. In this case, 13350Calc adjusts all fractions that are displayed to have the specified 13351denominator, if possible. Otherwise it adjusts the denominator to 13352be a multiple of the specified value. For example, in @samp{:6} mode 13353the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be 13354displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6}, 13355and @expr{1:8} will be displayed as @expr{3:24}. Integers are also 13356affected by this mode: 3 is displayed as @expr{18:6}. Note that the 13357format @samp{:1} writes fractions the same as @samp{:}, but it writes 13358integers as @expr{n:1}. 13359 13360The fraction format does not affect the way fractions or integers are 13361stored, only the way they appear on the screen. The fraction format 13362never affects floats. 13363 13364@node HMS Formats, Date Formats, Fraction Formats, Display Modes 13365@subsection HMS Formats 13366 13367@noindent 13368@kindex d h 13369@pindex calc-hms-notation 13370The @kbd{d h} (@code{calc-hms-notation}) command controls the display of 13371HMS (hours-minutes-seconds) forms. It prompts for a string which 13372consists basically of an ``hours'' marker, optional punctuation, a 13373``minutes'' marker, more optional punctuation, and a ``seconds'' marker. 13374Punctuation is zero or more spaces, commas, or semicolons. The hours 13375marker is one or more non-punctuation characters. The minutes and 13376seconds markers must be single non-punctuation characters. 13377 13378The default HMS format is @samp{@@ ' "}, producing HMS values of the form 13379@samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same 13380value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o} 13381keys are recognized as synonyms for @kbd{@@} regardless of display format. 13382The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and 13383@kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has 13384already been typed; otherwise, they have their usual meanings 13385(@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and 13386@kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.'' 13387The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or 13388@kbd{o}) has already been pressed; otherwise it means to switch to algebraic 13389entry. 13390 13391@node Date Formats, Truncating the Stack, HMS Formats, Display Modes 13392@subsection Date Formats 13393 13394@noindent 13395@kindex d d 13396@pindex calc-date-notation 13397The @kbd{d d} (@code{calc-date-notation}) command controls the display 13398of date forms (@pxref{Date Forms}). It prompts for a string which 13399contains letters that represent the various parts of a date and time. 13400To show which parts should be omitted when the form represents a pure 13401date with no time, parts of the string can be enclosed in @samp{< >} 13402marks. If you don't include @samp{< >} markers in the format, Calc 13403guesses at which parts, if any, should be omitted when formatting 13404pure dates. 13405 13406The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}. 13407An example string in this format is @samp{3:32pm Wed Jan 9, 1991}. 13408If you enter a blank format string, this default format is 13409reestablished. 13410 13411Calc uses @samp{< >} notation for nameless functions as well as for 13412dates. @xref{Specifying Operators}. To avoid confusion with nameless 13413functions, your date formats should avoid using the @samp{#} character. 13414 13415@menu 13416* ISO 8601:: 13417* Date Formatting Codes:: 13418* Free-Form Dates:: 13419* Standard Date Formats:: 13420@end menu 13421 13422@node ISO 8601, Date Formatting Codes, Date Formats, Date Formats 13423@subsubsection ISO 8601 13424 13425@noindent 13426@cindex ISO 8601 13427The same date can be written down in different formats and Calc tries 13428to allow you to choose your preferred format. Some common formats are 13429ambiguous, however; for example, 10/11/2012 means October 11, 134302012 in the United States but it means November 10, 2012 in 13431Europe. To help avoid such ambiguities, the International Organization 13432for Standardization (ISO) provides the ISO 8601 standard, which 13433provides three different but easily distinguishable and unambiguous 13434ways to represent a date. 13435 13436The ISO 8601 calendar date representation is 13437 13438@example 13439 @var{YYYY}-@var{MM}-@var{DD} 13440@end example 13441 13442@noindent 13443where @var{YYYY} is the four digit year, @var{MM} is the two-digit month 13444number (01 for January to 12 for December), and @var{DD} is the 13445two-digit day of the month (01 to 31). (Note that @var{YYYY} does not 13446correspond to Calc's date formatting code, which will be introduced 13447later.) The year, which should be padded with zeros to ensure it has at 13448least four digits, is the Gregorian year, except that the year before 134490001 (1 AD) is the year 0000 (1 BC). The date October 11, 2012 is 13450written 2012-10-11 in this representation and November 10, 2012 is 13451written 2012-11-10. 13452 13453The ISO 8601 ordinal date representation is 13454 13455@example 13456 @var{YYYY}-@var{DDD} 13457@end example 13458 13459@noindent 13460where @var{YYYY} is the year, as above, and @var{DDD} is the day of the year. 13461The date December 31, 2011 is written 2011-365 in this representation 13462and January 1, 2012 is written 2012-001. 13463 13464The ISO 8601 week date representation is 13465 13466@example 13467 @var{YYYY}-W@var{ww}-@var{D} 13468@end example 13469 13470@noindent 13471where @var{YYYY} is the ISO week-numbering year, @var{ww} is the two 13472digit week number (preceded by a literal ``W''), and @var{D} is the day 13473of the week (1 for Monday through 7 for Sunday). The ISO week-numbering 13474year is based on the Gregorian year but can differ slightly. The first 13475week of an ISO week-numbering year is the week with the Gregorian year's 13476first Thursday in it (equivalently, the week containing January 4); 13477any day of that week (Monday through Sunday) is part of the same ISO 13478week-numbering year, any day from the previous week is part of the 13479previous year. For example, January 4, 2013 is on a Friday, and so 13480the first week for the ISO week-numbering year 2013 starts on 13481Monday, December 31, 2012. The day December 31, 2012 is then part of the 13482Gregorian year 2012 but ISO week-numbering year 2013. In the week 13483date representation, this week goes from 2013-W01-1 (December 31, 134842012) to 2013-W01-7 (January 6, 2013). 13485 13486All three ISO 8601 representations arrange the numbers from most 13487significant to least significant; as well as being unambiguous 13488representations, they are easy to sort since chronological order in 13489this formats corresponds to lexicographical order. The hyphens are 13490sometimes omitted. 13491 13492The ISO 8601 standard uses a 24 hour clock; a particular time is 13493represented by @var{hh}:@var{mm}:@var{ss} where @var{hh} is the 13494two-digit hour (from 00 to 24), @var{mm} is the two-digit minute (from 1349500 to 59) and @var{ss} is the two-digit second. The seconds or minutes 13496and seconds can be omitted, and decimals can be added. If a date with a 13497time is represented, they should be separated by a literal ``T'', so noon 13498on December 13, 2012 can be represented as 2012-12-13T12:00. 13499 13500@node Date Formatting Codes, Free-Form Dates, ISO 8601, Date Formats 13501@subsubsection Date Formatting Codes 13502 13503@noindent 13504When displaying a date, the current date format is used. All 13505characters except for letters and @samp{<} and @samp{>} are 13506copied literally when dates are formatted. The portion between 13507@samp{< >} markers is omitted for pure dates, or included for 13508date/time forms. Letters are interpreted according to the table 13509below. 13510 13511When dates are read in during algebraic entry, Calc first tries to 13512match the input string to the current format either with or without 13513the time part. The punctuation characters (including spaces) must 13514match exactly; letter fields must correspond to suitable text in 13515the input. If this doesn't work, Calc checks if the input is a 13516simple number; if so, the number is interpreted as a number of days 13517since Dec 31, 1 BC@. Otherwise, Calc tries a much more relaxed and 13518flexible algorithm which is described in the next section. 13519 13520Weekday names are ignored during reading. 13521 13522Two-digit year numbers are interpreted as lying in the range 13523from 1941 to 2039. Years outside that range are always 13524entered and displayed in full. Year numbers with a leading 13525@samp{+} sign are always interpreted exactly, allowing the 13526entry and display of the years 1 through 99 AD. 13527 13528Here is a complete list of the formatting codes for dates: 13529 13530@table @asis 13531@item Y 13532Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD. 13533@item YY 13534Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD. 13535@item BY 13536Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD. 13537@item YYY 13538Year: ``1991'' for 1991, ``23'' for 23 AD. 13539@item YYYY 13540Year: ``1991'' for 1991, ``+23'' for 23 AD. 13541@item ZYYY 13542Year: ``1991'' for 1991, ``0023'' for 23 AD, ``0000'' for 1 BC. 13543@item IYYY 13544Year: ISO 8601 week-numbering year. 13545@item aa 13546Year: ``ad'' or blank. 13547@item AA 13548Year: ``AD'' or blank. 13549@item aaa 13550Year: ``ad '' or blank. (Note trailing space.) 13551@item AAA 13552Year: ``AD '' or blank. 13553@item aaaa 13554Year: ``a.d.@:'' or blank. 13555@item AAAA 13556Year: ``A.D.'' or blank. 13557@item bb 13558Year: ``bc'' or blank. 13559@item BB 13560Year: ``BC'' or blank. 13561@item bbb 13562Year: `` bc'' or blank. (Note leading space.) 13563@item BBB 13564Year: `` BC'' or blank. 13565@item bbbb 13566Year: ``b.c.@:'' or blank. 13567@item BBBB 13568Year: ``B.C.'' or blank. 13569@item M 13570Month: ``8'' for August. 13571@item MM 13572Month: ``08'' for August. 13573@item BM 13574Month: `` 8'' for August. 13575@item MMM 13576Month: ``AUG'' for August. 13577@item Mmm 13578Month: ``Aug'' for August. 13579@item mmm 13580Month: ``aug'' for August. 13581@item MMMM 13582Month: ``AUGUST'' for August. 13583@item Mmmm 13584Month: ``August'' for August. 13585@item D 13586Day: ``7'' for 7th day of month. 13587@item DD 13588Day: ``07'' for 7th day of month. 13589@item BD 13590Day: `` 7'' for 7th day of month. 13591@item W 13592Weekday: ``0'' for Sunday, ``6'' for Saturday. 13593@item w 13594Weekday: ``1'' for Monday, ``7'' for Sunday. 13595@item WWW 13596Weekday: ``SUN'' for Sunday. 13597@item Www 13598Weekday: ``Sun'' for Sunday. 13599@item www 13600Weekday: ``sun'' for Sunday. 13601@item WWWW 13602Weekday: ``SUNDAY'' for Sunday. 13603@item Wwww 13604Weekday: ``Sunday'' for Sunday. 13605@item Iww 13606Week number: ISO 8601 week number, ``W01'' for week 1. 13607@item d 13608Day of year: ``34'' for Feb.@: 3. 13609@item ddd 13610Day of year: ``034'' for Feb.@: 3. 13611@item bdd 13612Day of year: `` 34'' for Feb.@: 3. 13613@item T 13614Letter: Literal ``T''. 13615@item h 13616Hour: ``5'' for 5 AM; ``17'' for 5 PM. 13617@item hh 13618Hour: ``05'' for 5 AM; ``17'' for 5 PM. 13619@item bh 13620Hour: `` 5'' for 5 AM; ``17'' for 5 PM. 13621@item H 13622Hour: ``5'' for 5 AM and 5 PM. 13623@item HH 13624Hour: ``05'' for 5 AM and 5 PM. 13625@item BH 13626Hour: `` 5'' for 5 AM and 5 PM. 13627@item p 13628AM/PM: ``a'' or ``p''. 13629@item P 13630AM/PM: ``A'' or ``P''. 13631@item pp 13632AM/PM: ``am'' or ``pm''. 13633@item PP 13634AM/PM: ``AM'' or ``PM''. 13635@item pppp 13636AM/PM: ``a.m.@:'' or ``p.m.''. 13637@item PPPP 13638AM/PM: ``A.M.'' or ``P.M.''. 13639@item m 13640Minutes: ``7'' for 7. 13641@item mm 13642Minutes: ``07'' for 7. 13643@item bm 13644Minutes: `` 7'' for 7. 13645@item s 13646Seconds: ``7'' for 7; ``7.23'' for 7.23. 13647@item ss 13648Seconds: ``07'' for 7; ``07.23'' for 7.23. 13649@item bs 13650Seconds: `` 7'' for 7; `` 7.23'' for 7.23. 13651@item SS 13652Optional seconds: ``07'' for 7; blank for 0. 13653@item BS 13654Optional seconds: `` 7'' for 7; blank for 0. 13655@item N 13656Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991. 13657@item n 13658Numeric date: ``726842'' for any time on Wed Jan 9, 1991. 13659@item J 13660Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991. 13661@item j 13662Julian date: ``2448266'' for any time on Wed Jan 9, 1991. 13663@item U 13664Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991. 13665@item X 13666Brackets suppression. An ``X'' at the front of the format 13667causes the surrounding @w{@samp{< >}} delimiters to be omitted 13668when formatting dates. Note that the brackets are still 13669required for algebraic entry. 13670@end table 13671 13672If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the 13673colon is also omitted if the seconds part is zero. 13674 13675If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents 13676appear in the format, then negative year numbers are displayed 13677without a minus sign. Note that ``aa'' and ``bb'' are mutually 13678exclusive. Some typical usages would be @samp{YYYY AABB}; 13679@samp{AAAYYYYBBB}; @samp{YYYYBBB}. 13680 13681The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,'' 13682``mm,'' ``ss,'' and ``SS'' actually match any number of digits during 13683reading unless several of these codes are strung together with no 13684punctuation in between, in which case the input must have exactly as 13685many digits as there are letters in the format. 13686 13687The ``j,'' ``J,'' and ``U'' formats do not make any time zone 13688adjustment. They effectively use @samp{julian(x,0)} and 13689@samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}. 13690 13691@node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats 13692@subsubsection Free-Form Dates 13693 13694@noindent 13695When reading a date form during algebraic entry, Calc falls back 13696on the algorithm described here if the input does not exactly 13697match the current date format. This algorithm generally 13698``does the right thing'' and you don't have to worry about it, 13699but it is described here in full detail for the curious. 13700 13701Calc does not distinguish between upper- and lower-case letters 13702while interpreting dates. 13703 13704First, the time portion, if present, is located somewhere in the 13705text and then removed. The remaining text is then interpreted as 13706the date. 13707 13708A time is of the form @samp{hh:mm:ss}, possibly with the seconds 13709part omitted and possibly with an AM/PM indicator added to indicate 1371012-hour time. If the AM/PM is present, the minutes may also be 13711omitted. The AM/PM part may be any of the words @samp{am}, 13712@samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be 13713abbreviated to one letter, and the alternate forms @samp{a.m.}, 13714@samp{p.m.}, and @samp{mid} are also understood. Obviously 13715@samp{noon} and @samp{midnight} are allowed only on 12:00:00. 13716The words @samp{noon}, @samp{mid}, and @samp{midnight} are also 13717recognized with no number attached. Midnight will represent the 13718beginning of a day. 13719 13720If there is no AM/PM indicator, the time is interpreted in 24-hour 13721format. 13722 13723When reading the date portion, Calc first checks to see if it is an 13724ISO 8601 week-numbering date; if the string contains an integer 13725representing the year, a ``W'' followed by two digits for the week 13726number, and an integer from 1 to 7 representing the weekday (in that 13727order), then all other characters are ignored and this information 13728determines the date. Otherwise, all words and numbers are isolated 13729from the string; other characters are ignored. All words must be 13730either month names or day-of-week names (the latter of which are 13731ignored). Names can be written in full or as three-letter 13732abbreviations. 13733 13734Large numbers, or numbers with @samp{+} or @samp{-} signs, 13735are interpreted as years. If one of the other numbers is 13736greater than 12, then that must be the day and the remaining 13737number in the input is therefore the month. Otherwise, Calc 13738assumes the month, day and year are in the same order that they 13739appear in the current date format. If the year is omitted, the 13740current year is taken from the system clock. 13741 13742If there are too many or too few numbers, or any unrecognizable 13743words, then the input is rejected. 13744 13745If there are any large numbers (of five digits or more) other than 13746the year, they are ignored on the assumption that they are something 13747like Julian dates that were included along with the traditional 13748date components when the date was formatted. 13749 13750One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.} 13751may optionally be used; the latter two are equivalent to a 13752minus sign on the year value. 13753 13754If you always enter a four-digit year, and use a name instead 13755of a number for the month, there is no danger of ambiguity. 13756 13757@node Standard Date Formats, , Free-Form Dates, Date Formats 13758@subsubsection Standard Date Formats 13759 13760@noindent 13761There are actually ten standard date formats, numbered 0 through 9. 13762Entering a blank line at the @kbd{d d} command's prompt gives 13763you format number 1, Calc's usual format. You can enter any digit 13764to select the other formats. 13765 13766To create your own standard date formats, give a numeric prefix 13767argument from 0 to 9 to the @w{@kbd{d d}} command. The format you 13768enter will be recorded as the new standard format of that 13769number, as well as becoming the new current date format. 13770You can save your formats permanently with the @w{@kbd{m m}} 13771command (@pxref{Mode Settings}). 13772 13773@table @asis 13774@item 0 13775@samp{N} (Numerical format) 13776@item 1 13777@samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format) 13778@item 2 13779@samp{D Mmm YYYY<, h:mm:SS>} (European format) 13780@item 3 13781@samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format) 13782@item 4 13783@samp{M/D/Y< H:mm:SSpp>} (American slashed format) 13784@item 5 13785@samp{D.M.Y< h:mm:SS>} (European dotted format) 13786@item 6 13787@samp{M-D-Y< H:mm:SSpp>} (American dashed format) 13788@item 7 13789@samp{D-M-Y< h:mm:SS>} (European dashed format) 13790@item 8 13791@samp{j<, h:mm:ss>} (Julian day plus time) 13792@item 9 13793@samp{YYddd< hh:mm:ss>} (Year-day format) 13794@item 10 13795@samp{ZYYY-MM-DD Www< hh:mm>} (Org mode format) 13796@item 11 13797@samp{IYYY-Iww-w<Thh:mm:ss>} (ISO 8601 week numbering format) 13798@end table 13799 13800@node Truncating the Stack, Justification, Date Formats, Display Modes 13801@subsection Truncating the Stack 13802 13803@noindent 13804@kindex d t 13805@pindex calc-truncate-stack 13806@cindex Truncating the stack 13807@cindex Narrowing the stack 13808The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@: 13809line that marks the top-of-stack up or down in the Calculator buffer. 13810The number right above that line is considered to the be at the top of 13811the stack. Any numbers below that line are ``hidden'' from all stack 13812operations (although still visible to the user). This is similar to the 13813Emacs ``narrowing'' feature, except that the values below the @samp{.} 13814are @emph{visible}, just temporarily frozen. This feature allows you to 13815keep several independent calculations running at once in different parts 13816of the stack, or to apply a certain command to an element buried deep in 13817the stack. 13818 13819Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor 13820is on. Thus, this line and all those below it become hidden. To un-hide 13821these lines, move down to the end of the buffer and press @w{@kbd{d t}}. 13822With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the 13823bottom @expr{n} values in the buffer. With a negative argument, it hides 13824all but the top @expr{n} values. With an argument of zero, it hides zero 13825values, i.e., moves the @samp{.} all the way down to the bottom. 13826 13827@kindex d [ 13828@pindex calc-truncate-up 13829@kindex d ] 13830@pindex calc-truncate-down 13831The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]} 13832(@code{calc-truncate-down}) commands move the @samp{.} up or down one 13833line at a time (or several lines with a prefix argument). 13834 13835@node Justification, Labels, Truncating the Stack, Display Modes 13836@subsection Justification 13837 13838@noindent 13839@kindex d < 13840@pindex calc-left-justify 13841@kindex d = 13842@pindex calc-center-justify 13843@kindex d > 13844@pindex calc-right-justify 13845Values on the stack are normally left-justified in the window. You can 13846control this arrangement by typing @kbd{d <} (@code{calc-left-justify}), 13847@kbd{d >} (@code{calc-right-justify}), or @kbd{d =} 13848(@code{calc-center-justify}). For example, in Right-Justification mode, 13849stack entries are displayed flush-right against the right edge of the 13850window. 13851 13852If you change the width of the Calculator window you may have to type 13853@kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered 13854text. 13855 13856Right-justification is especially useful together with fixed-point 13857notation (see @code{d f}; @code{calc-fix-notation}). With these modes 13858together, the decimal points on numbers will always line up. 13859 13860With a numeric prefix argument, the justification commands give you 13861a little extra control over the display. The argument specifies the 13862horizontal ``origin'' of a display line. It is also possible to 13863specify a maximum line width using the @kbd{d b} command (@pxref{Normal 13864Language Modes}). For reference, the precise rules for formatting and 13865breaking lines are given below. Notice that the interaction between 13866origin and line width is slightly different in each justification 13867mode. 13868 13869In Left-Justified mode, the line is indented by a number of spaces 13870given by the origin (default zero). If the result is longer than the 13871maximum line width, if given, or too wide to fit in the Calc window 13872otherwise, then it is broken into lines which will fit; each broken 13873line is indented to the origin. 13874 13875In Right-Justified mode, lines are shifted right so that the rightmost 13876character is just before the origin, or just before the current 13877window width if no origin was specified. If the line is too long 13878for this, then it is broken; the current line width is used, if 13879specified, or else the origin is used as a width if that is 13880specified, or else the line is broken to fit in the window. 13881 13882In Centering mode, the origin is the column number of the center of 13883each stack entry. If a line width is specified, lines will not be 13884allowed to go past that width; Calc will either indent less or 13885break the lines if necessary. If no origin is specified, half the 13886line width or Calc window width is used. 13887 13888Note that, in each case, if line numbering is enabled the display 13889is indented an additional four spaces to make room for the line 13890number. The width of the line number is taken into account when 13891positioning according to the current Calc window width, but not 13892when positioning by explicit origins and widths. In the latter 13893case, the display is formatted as specified, and then uniformly 13894shifted over four spaces to fit the line numbers. 13895 13896@node Labels, , Justification, Display Modes 13897@subsection Labels 13898 13899@noindent 13900@kindex d @{ 13901@pindex calc-left-label 13902The @kbd{d @{} (@code{calc-left-label}) command prompts for a string, 13903then displays that string to the left of every stack entry. If the 13904entries are left-justified (@pxref{Justification}), then they will 13905appear immediately after the label (unless you specified an origin 13906greater than the length of the label). If the entries are centered 13907or right-justified, the label appears on the far left and does not 13908affect the horizontal position of the stack entry. 13909 13910Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off. 13911 13912@kindex d @} 13913@pindex calc-right-label 13914The @kbd{d @}} (@code{calc-right-label}) command similarly adds a 13915label on the righthand side. It does not affect positioning of 13916the stack entries unless they are right-justified. Also, if both 13917a line width and an origin are given in Right-Justified mode, the 13918stack entry is justified to the origin and the righthand label is 13919justified to the line width. 13920 13921One application of labels would be to add equation numbers to 13922formulas you are manipulating in Calc and then copying into a 13923document (possibly using Embedded mode). The equations would 13924typically be centered, and the equation numbers would be on the 13925left or right as you prefer. 13926 13927@node Language Modes, Modes Variable, Display Modes, Mode Settings 13928@section Language Modes 13929 13930@noindent 13931The commands in this section change Calc to use a different notation for 13932entry and display of formulas, corresponding to the conventions of some 13933other common language such as Pascal or @LaTeX{}. Objects displayed on the 13934stack or yanked from the Calculator to an editing buffer will be formatted 13935in the current language; objects entered in algebraic entry or yanked from 13936another buffer will be interpreted according to the current language. 13937 13938The current language has no effect on things written to or read from the 13939trail buffer, nor does it affect numeric entry. Only algebraic entry is 13940affected. You can make even algebraic entry ignore the current language 13941and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}. 13942 13943For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C 13944program; elsewhere in the program you need the derivatives of this formula 13945with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C} 13946to switch to C notation. Now use @code{C-u C-x * g} to grab the formula 13947into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect 13948to the first variable, and @kbd{C-x * y} to yank the formula for the derivative 13949back into your C program. Press @kbd{U} to undo the differentiation and 13950repeat with @kbd{a d a[2] @key{RET}} for the other derivative. 13951 13952Without being switched into C mode first, Calc would have misinterpreted 13953the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that 13954@code{atan} was equivalent to Calc's built-in @code{arctan} function, 13955and would have written the formula back with notations (like implicit 13956multiplication) which would not have been valid for a C program. 13957 13958As another example, suppose you are maintaining a C program and a @LaTeX{} 13959document, each of which needs a copy of the same formula. You can grab the 13960formula from the program in C mode, switch to @LaTeX{} mode, and yank the 13961formula into the document in @LaTeX{} math-mode format. 13962 13963Language modes are selected by typing the letter @kbd{d} followed by a 13964shifted letter key. 13965 13966@menu 13967* Normal Language Modes:: 13968* C FORTRAN Pascal:: 13969* TeX and LaTeX Language Modes:: 13970* Eqn Language Mode:: 13971* Yacas Language Mode:: 13972* Maxima Language Mode:: 13973* Giac Language Mode:: 13974* Mathematica Language Mode:: 13975* Maple Language Mode:: 13976* Compositions:: 13977* Syntax Tables:: 13978@end menu 13979 13980@node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes 13981@subsection Normal Language Modes 13982 13983@noindent 13984@kindex d N 13985@pindex calc-normal-language 13986The @kbd{d N} (@code{calc-normal-language}) command selects the usual 13987notation for Calc formulas, as described in the rest of this manual. 13988Matrices are displayed in a multi-line tabular format, but all other 13989objects are written in linear form, as they would be typed from the 13990keyboard. 13991 13992@kindex d O 13993@pindex calc-flat-language 13994@cindex Matrix display 13995The @kbd{d O} (@code{calc-flat-language}) command selects a language 13996identical with the normal one, except that matrices are written in 13997one-line form along with everything else. In some applications this 13998form may be more suitable for yanking data into other buffers. 13999 14000@kindex d b 14001@pindex calc-line-breaking 14002@cindex Line breaking 14003@cindex Breaking up long lines 14004Even in one-line mode, long formulas or vectors will still be split 14005across multiple lines if they exceed the width of the Calculator window. 14006The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking 14007feature on and off. (It works independently of the current language.) 14008If you give a numeric prefix argument of five or greater to the @kbd{d b} 14009command, that argument will specify the line width used when breaking 14010long lines. 14011 14012@kindex d B 14013@pindex calc-big-language 14014The @kbd{d B} (@code{calc-big-language}) command selects a language 14015which uses textual approximations to various mathematical notations, 14016such as powers, quotients, and square roots: 14017 14018@example 14019 ____________ 14020 | a + 1 2 14021 | ----- + c 14022\| b 14023@end example 14024 14025@noindent 14026in place of @samp{sqrt((a+1)/b + c^2)}. 14027 14028Subscripts like @samp{a_i} are displayed as actual subscripts in Big 14029mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)}) 14030are displayed as @samp{a} with subscripts separated by commas: 14031@samp{i, j}. They must still be entered in the usual underscore 14032notation. 14033 14034One slight ambiguity of Big notation is that 14035 14036@example 14037 3 14038- - 14039 4 14040@end example 14041 14042@noindent 14043can represent either the negative rational number @expr{-3:4}, or the 14044actual expression @samp{-(3/4)}; but the latter formula would normally 14045never be displayed because it would immediately be evaluated to 14046@expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in 14047typical use. 14048 14049Non-decimal numbers are displayed with subscripts. Thus there is no 14050way to tell the difference between @samp{16#C2} and @samp{C2_16}, 14051though generally you will know which interpretation is correct. 14052Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts 14053in Big mode. 14054 14055In Big mode, stack entries often take up several lines. To aid 14056readability, stack entries are separated by a blank line in this mode. 14057You may find it useful to expand the Calc window's height using 14058@kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only 14059one on the screen with @kbd{C-x 1} (@code{delete-other-windows}). 14060 14061Long lines are currently not rearranged to fit the window width in 14062Big mode, so you may need to use the @kbd{<} and @kbd{>} keys 14063to scroll across a wide formula. For really big formulas, you may 14064even need to use @kbd{@{} and @kbd{@}} to scroll up and down. 14065 14066@kindex d U 14067@pindex calc-unformatted-language 14068The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables 14069the use of operator notation in formulas. In this mode, the formula 14070shown above would be displayed: 14071 14072@example 14073sqrt(add(div(add(a, 1), b), pow(c, 2))) 14074@end example 14075 14076These four modes differ only in display format, not in the format 14077expected for algebraic entry. The standard Calc operators work in 14078all four modes, and unformatted notation works in any language mode 14079(except that Mathematica mode expects square brackets instead of 14080parentheses). 14081 14082@node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes 14083@subsection C, FORTRAN, and Pascal Modes 14084 14085@noindent 14086@kindex d C 14087@pindex calc-c-language 14088@cindex C language 14089The @kbd{d C} (@code{calc-c-language}) command selects the conventions 14090of the C language for display and entry of formulas. This differs from 14091the normal language mode in a variety of (mostly minor) ways. In 14092particular, C language operators and operator precedences are used in 14093place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)} 14094in C mode; a value raised to a power is written as a function call, 14095@samp{pow(a,b)}. 14096 14097In C mode, vectors and matrices use curly braces instead of brackets. 14098Octal and hexadecimal values are written with leading @samp{0} or @samp{0x} 14099rather than using the @samp{#} symbol. Array subscripting is 14100translated into @code{subscr} calls, so that @samp{a[i]} in C 14101mode is the same as @samp{a_i} in Normal mode. Assignments 14102turn into the @code{assign} function, which Calc normally displays 14103using the @samp{:=} symbol. 14104 14105The variables @code{pi} and @code{e} would be displayed @samp{pi} 14106and @samp{e} in Normal mode, but in C mode they are displayed as 14107@samp{M_PI} and @samp{M_E}, corresponding to the names of constants 14108typically provided in the @file{<math.h>} header. Functions whose 14109names are different in C are translated automatically for entry and 14110display purposes. For example, entering @samp{asin(x)} will push the 14111formula @samp{arcsin(x)} onto the stack; this formula will be displayed 14112as @samp{asin(x)} as long as C mode is in effect. 14113 14114@kindex d P 14115@pindex calc-pascal-language 14116@cindex Pascal language 14117The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal 14118conventions. Like C mode, Pascal mode interprets array brackets and uses 14119a different table of operators. Hexadecimal numbers are entered and 14120displayed with a preceding dollar sign. (Thus the regular meaning of 14121@kbd{$2} during algebraic entry does not work in Pascal mode, though 14122@kbd{$} (and @kbd{$$}, etc.)@: not followed by digits works the same as 14123always.) No special provisions are made for other non-decimal numbers, 14124vectors, and so on, since there is no universally accepted standard way 14125of handling these in Pascal. 14126 14127@kindex d F 14128@pindex calc-fortran-language 14129@cindex FORTRAN language 14130The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN 14131conventions. Various function names are transformed into FORTRAN 14132equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be 14133entered this way or using square brackets. Since FORTRAN uses round 14134parentheses for both function calls and array subscripts, Calc displays 14135both in the same way; @samp{a(i)} is interpreted as a function call 14136upon reading, and subscripts must be entered as @samp{subscr(a, i)}. 14137If the variable @code{a} has been declared to have type 14138@code{vector} or @code{matrix}, however, then @samp{a(i)} will be 14139parsed as a subscript. (@xref{Declarations}.) Usually it doesn't 14140matter, though; if you enter the subscript expression @samp{a(i)} and 14141Calc interprets it as a function call, you'll never know the difference 14142unless you switch to another language mode or replace @code{a} with an 14143actual vector (or unless @code{a} happens to be the name of a built-in 14144function!). 14145 14146Underscores are allowed in variable and function names in all of these 14147language modes. The underscore here is equivalent to the @samp{#} in 14148Normal mode, or to hyphens in the underlying Emacs Lisp variable names. 14149 14150FORTRAN and Pascal modes normally do not adjust the case of letters in 14151formulas. Most built-in Calc names use lower-case letters. If you use a 14152positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these 14153modes will use upper-case letters exclusively for display, and will 14154convert to lower-case on input. With a negative prefix, these modes 14155convert to lower-case for display and input. 14156 14157@node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes 14158@subsection @TeX{} and @LaTeX{} Language Modes 14159 14160@noindent 14161@kindex d T 14162@pindex calc-tex-language 14163@cindex TeX language 14164@kindex d L 14165@pindex calc-latex-language 14166@cindex LaTeX language 14167The @kbd{d T} (@code{calc-tex-language}) command selects the conventions 14168of ``math mode'' in Donald Knuth's @TeX{} typesetting language, 14169and the @kbd{d L} (@code{calc-latex-language}) command selects the 14170conventions of ``math mode'' in @LaTeX{}, a typesetting language that 14171uses @TeX{} as its formatting engine. Calc's @LaTeX{} language mode can 14172read any formula that the @TeX{} language mode can, although @LaTeX{} 14173mode may display it differently. 14174 14175Formulas are entered and displayed in the appropriate notation; 14176@texline @math{\sin(a/b)} 14177@infoline @expr{sin(a/b)} 14178will appear as @samp{\sin\left( @{a \over b@} \right)} in @TeX{} mode and 14179@samp{\sin\left(\frac@{a@}@{b@}\right)} in @LaTeX{} mode. 14180Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and 14181@LaTeX{}; these should be omitted when interfacing with Calc. To Calc, 14182the @samp{$} sign has the same meaning it always does in algebraic 14183formulas (a reference to an existing entry on the stack). 14184 14185Complex numbers are displayed as in @samp{3 + 4i}. Fractions and 14186quotients are written using @code{\over} in @TeX{} mode (as in 14187@code{@{a \over b@}}) and @code{\frac} in @LaTeX{} mode (as in 14188@code{\frac@{a@}@{b@}}); binomial coefficients are written with 14189@code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and 14190@code{\binom} in @LaTeX{} mode (as in @code{\binom@{a@}@{b@}}). 14191Interval forms are written with @code{\ldots}, and error forms are 14192written with @code{\pm}. Absolute values are written as in 14193@samp{|x + 1|}, and the floor and ceiling functions are written with 14194@code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and 14195@code{\right} are ignored when reading formulas in @TeX{} and @LaTeX{} 14196modes. Both @code{inf} and @code{uinf} are written as @code{\infty}; 14197when read, @code{\infty} always translates to @code{inf}. 14198 14199Function calls are written the usual way, with the function name followed 14200by the arguments in parentheses. However, functions for which @TeX{} 14201and @LaTeX{} have special names (like @code{\sin}) will use curly braces 14202instead of parentheses for very simple arguments. During input, curly 14203braces and parentheses work equally well for grouping, but when the 14204document is formatted the curly braces will be invisible. Thus the 14205printed result is 14206@texline @math{\sin{2 x}} 14207@infoline @expr{sin 2x} 14208but 14209@texline @math{\sin(2 + x)}. 14210@infoline @expr{sin(2 + x)}. 14211 14212The @TeX{} specific unit names (@pxref{Predefined Units}) will not use 14213the @samp{tex} prefix; the unit name for a @TeX{} point will be 14214@samp{pt} instead of @samp{texpt}, for example. 14215 14216Function and variable names not treated specially by @TeX{} and @LaTeX{} 14217are simply written out as-is, which will cause them to come out in 14218italic letters in the printed document. If you invoke @kbd{d T} or 14219@kbd{d L} with a positive numeric prefix argument, names of more than 14220one character will instead be enclosed in a protective commands that 14221will prevent them from being typeset in the math italics; they will be 14222written @samp{\hbox@{@var{name}@}} in @TeX{} mode and 14223@samp{\text@{@var{name}@}} in @LaTeX{} mode. The 14224@samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during 14225reading. If you use a negative prefix argument, such function names are 14226written @samp{\@var{name}}, and function names that begin with @code{\} during 14227reading have the @code{\} removed. (Note that in this mode, long 14228variable names are still written with @code{\hbox} or @code{\text}. 14229However, you can always make an actual variable name like @code{\bar} in 14230any @TeX{} mode.) 14231 14232During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced 14233by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and 14234@code{\bmatrix}. In @LaTeX{} mode this also applies to 14235@samp{\begin@{matrix@} ... \end@{matrix@}}, 14236@samp{\begin@{bmatrix@} ... \end@{bmatrix@}}, 14237@samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as 14238@samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}. 14239The symbol @samp{&} is interpreted as a comma, 14240and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons. 14241During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}} 14242format in @TeX{} mode and in 14243@samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in 14244@LaTeX{} mode; you may need to edit this afterwards to change to your 14245preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an 14246argument of 2 or @minus{}2, then matrices will be displayed in two-dimensional 14247form, such as 14248 14249@example 14250\begin@{pmatrix@} 14251a & b \\ 14252c & d 14253\end@{pmatrix@} 14254@end example 14255 14256@noindent 14257This may be convenient for isolated matrices, but could lead to 14258expressions being displayed like 14259 14260@example 14261\begin@{pmatrix@} \times x 14262a & b \\ 14263c & d 14264\end@{pmatrix@} 14265@end example 14266 14267@noindent 14268While this wouldn't bother Calc, it is incorrect @LaTeX{}. 14269(Similarly for @TeX{}.) 14270 14271Accents like @code{\tilde} and @code{\bar} translate into function 14272calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline} 14273sequence is treated as an accent. The @code{\vec} accent corresponds 14274to the function name @code{Vec}, because @code{vec} is the name of 14275a built-in Calc function. The following table shows the accents 14276in Calc, @TeX{}, @LaTeX{} and @dfn{eqn} (described in the next section): 14277 14278@ignore 14279@iftex 14280@begingroup 14281@let@calcindexershow=@calcindexernoshow @c Suppress marginal notes 14282@let@calcindexersh=@calcindexernoshow 14283@end iftex 14284@starindex 14285@end ignore 14286@tindex acute 14287@ignore 14288@starindex 14289@end ignore 14290@tindex Acute 14291@ignore 14292@starindex 14293@end ignore 14294@tindex bar 14295@ignore 14296@starindex 14297@end ignore 14298@tindex Bar 14299@ignore 14300@starindex 14301@end ignore 14302@tindex breve 14303@ignore 14304@starindex 14305@end ignore 14306@tindex Breve 14307@ignore 14308@starindex 14309@end ignore 14310@tindex check 14311@ignore 14312@starindex 14313@end ignore 14314@tindex Check 14315@ignore 14316@starindex 14317@end ignore 14318@tindex dddot 14319@ignore 14320@starindex 14321@end ignore 14322@tindex ddddot 14323@ignore 14324@starindex 14325@end ignore 14326@tindex dot 14327@ignore 14328@starindex 14329@end ignore 14330@tindex Dot 14331@ignore 14332@starindex 14333@end ignore 14334@tindex dotdot 14335@ignore 14336@starindex 14337@end ignore 14338@tindex DotDot 14339@ignore 14340@starindex 14341@end ignore 14342@tindex dyad 14343@ignore 14344@starindex 14345@end ignore 14346@tindex grave 14347@ignore 14348@starindex 14349@end ignore 14350@tindex Grave 14351@ignore 14352@starindex 14353@end ignore 14354@tindex hat 14355@ignore 14356@starindex 14357@end ignore 14358@tindex Hat 14359@ignore 14360@starindex 14361@end ignore 14362@tindex Prime 14363@ignore 14364@starindex 14365@end ignore 14366@tindex tilde 14367@ignore 14368@starindex 14369@end ignore 14370@tindex Tilde 14371@ignore 14372@starindex 14373@end ignore 14374@tindex under 14375@ignore 14376@starindex 14377@end ignore 14378@tindex Vec 14379@ignore 14380@starindex 14381@end ignore 14382@tindex VEC 14383@ignore 14384@iftex 14385@endgroup 14386@end iftex 14387@end ignore 14388@example 14389Calc TeX LaTeX eqn 14390---- --- ----- --- 14391acute \acute \acute 14392Acute \Acute 14393bar \bar \bar bar 14394Bar \Bar 14395breve \breve \breve 14396Breve \Breve 14397check \check \check 14398Check \Check 14399dddot \dddot 14400ddddot \ddddot 14401dot \dot \dot dot 14402Dot \Dot 14403dotdot \ddot \ddot dotdot 14404DotDot \Ddot 14405dyad dyad 14406grave \grave \grave 14407Grave \Grave 14408hat \hat \hat hat 14409Hat \Hat 14410Prime prime 14411tilde \tilde \tilde tilde 14412Tilde \Tilde 14413under \underline \underline under 14414Vec \vec \vec vec 14415VEC \Vec 14416@end example 14417 14418The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol: 14419@samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an 14420alias for @code{\rightarrow}. However, if the @samp{=>} is the 14421top-level expression being formatted, a slightly different notation 14422is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto} 14423word is ignored by Calc's input routines, and is undefined in @TeX{}. 14424You will typically want to include one of the following definitions 14425at the top of a @TeX{} file that uses @code{\evalto}: 14426 14427@example 14428\def\evalto@{@} 14429\def\evalto#1\to@{@} 14430@end example 14431 14432The first definition formats evaluates-to operators in the usual 14433way. The second causes only the @var{b} part to appear in the 14434printed document; the @var{a} part and the arrow are hidden. 14435Another definition you may wish to use is @samp{\let\to=\Rightarrow} 14436which causes @code{\to} to appear more like Calc's @samp{=>} symbol. 14437@xref{Evaluates-To Operator}, for a discussion of @code{evalto}. 14438 14439The complete set of @TeX{} control sequences that are ignored during 14440reading is: 14441 14442@example 14443\hbox \mbox \text \left \right 14444\, \> \: \; \! \quad \qquad \hfil \hfill 14445\displaystyle \textstyle \dsize \tsize 14446\scriptstyle \scriptscriptstyle \ssize \ssize 14447\rm \bf \it \sl \roman \bold \italic \slanted 14448\cal \mit \Cal \Bbb \frak \goth 14449\evalto 14450@end example 14451 14452Note that, because these symbols are ignored, reading a @TeX{} or 14453@LaTeX{} formula into Calc and writing it back out may lose spacing and 14454font information. 14455 14456Also, the ``discretionary multiplication sign'' @samp{\*} is read 14457the same as @samp{*}. 14458 14459@ifnottex 14460The @TeX{} version of this manual includes some printed examples at the 14461end of this section. 14462@end ifnottex 14463@iftex 14464Here are some examples of how various Calc formulas are formatted in @TeX{}: 14465 14466@example 14467@group 14468sin(a^2 / b_i) 14469\sin\left( {a^2 \over b_i} \right) 14470@end group 14471@end example 14472@tex 14473$$ \sin\left( a^2 \over b_i \right) $$ 14474@end tex 14475@sp 1 14476 14477@example 14478@group 14479[(3, 4), 3:4, 3 +/- 4, [3 .. inf)] 14480[3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)] 14481@end group 14482@end example 14483@tex 14484$$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$ 14485@end tex 14486@sp 1 14487 14488@example 14489@group 14490[abs(a), abs(a / b), floor(a), ceil(a / b)] 14491[|a|, \left| a \over b \right|, 14492 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] 14493@end group 14494@end example 14495@tex 14496$$ [|a|, \left| a \over b \right|, 14497 \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$ 14498@end tex 14499@sp 1 14500 14501@example 14502@group 14503[sin(a), sin(2 a), sin(2 + a), sin(a / b)] 14504[\sin@{a@}, \sin@{2 a@}, \sin(2 + a), 14505 \sin\left( @{a \over b@} \right)] 14506@end group 14507@end example 14508@tex 14509$$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$ 14510@end tex 14511@sp 2 14512 14513First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with 14514@kbd{C-u - d T} (using the example definition 14515@samp{\def\foo#1@{\tilde F(#1)@}}: 14516 14517@example 14518@group 14519[f(a), foo(bar), sin(pi)] 14520[f(a), foo(bar), \sin{\pi}] 14521[f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}] 14522[f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}] 14523@end group 14524@end example 14525@tex 14526$$ [f(a), foo(bar), \sin{\pi}] $$ 14527$$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$ 14528$$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$ 14529@end tex 14530@sp 2 14531 14532First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}: 14533 14534@example 14535@group 145362 + 3 => 5 14537\evalto 2 + 3 \to 5 14538@end group 14539@end example 14540@tex 14541$$ 2 + 3 \to 5 $$ 14542$$ 5 $$ 14543@end tex 14544@sp 2 14545 14546First with standard @code{\to}, then with @samp{\let\to\Rightarrow}: 14547 14548@example 14549@group 14550[2 + 3 => 5, a / 2 => (b + c) / 2] 14551[@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}] 14552@end group 14553@end example 14554@tex 14555$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$ 14556{\let\to\Rightarrow 14557$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$} 14558@end tex 14559@sp 2 14560 14561Matrices normally, then changing @code{\matrix} to @code{\pmatrix}: 14562 14563@example 14564@group 14565[ [ a / b, 0 ], [ 0, 2^(x + 1) ] ] 14566\matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} 14567\pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} 14568@end group 14569@end example 14570@tex 14571$$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ 14572$$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ 14573@end tex 14574@sp 2 14575@end iftex 14576 14577@node Eqn Language Mode, Yacas Language Mode, TeX and LaTeX Language Modes, Language Modes 14578@subsection Eqn Language Mode 14579 14580@noindent 14581@kindex d E 14582@pindex calc-eqn-language 14583@dfn{Eqn} is another popular formatter for math formulas. It is 14584designed for use with the TROFF text formatter, and comes standard 14585with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language}) 14586command selects @dfn{eqn} notation. 14587 14588The @dfn{eqn} language's main idiosyncrasy is that whitespace plays 14589a significant part in the parsing of the language. For example, 14590@samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the 14591@code{sqrt} operator. @dfn{Eqn} also understands more conventional 14592grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are 14593required only when the argument contains spaces. 14594 14595In Calc's @dfn{eqn} mode, however, curly braces are required to 14596delimit arguments of operators like @code{sqrt}. The first of the 14597above examples would treat only the @samp{x} as the argument of 14598@code{sqrt}, and in fact @samp{sin x+1} would be interpreted as 14599@samp{sin * x + 1}, because @code{sin} is not a special operator 14600in the @dfn{eqn} language. If you always surround the argument 14601with curly braces, Calc will never misunderstand. 14602 14603Calc also understands parentheses as grouping characters. Another 14604peculiarity of @dfn{eqn}'s syntax makes it advisable to separate 14605words with spaces from any surrounding characters that aren't curly 14606braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode. 14607(The spaces around @code{sin} are important to make @dfn{eqn} 14608recognize that @code{sin} should be typeset in a roman font, and 14609the spaces around @code{x} and @code{y} are a good idea just in 14610case the @dfn{eqn} document has defined special meanings for these 14611names, too.) 14612 14613Powers and subscripts are written with the @code{sub} and @code{sup} 14614operators, respectively. Note that the caret symbol @samp{^} is 14615treated the same as a space in @dfn{eqn} mode, as is the @samp{~} 14616symbol (these are used to introduce spaces of various widths into 14617the typeset output of @dfn{eqn}). 14618 14619As in @LaTeX{} mode, Calc's formatter omits parentheses around the 14620arguments of functions like @code{ln} and @code{sin} if they are 14621``simple-looking''; in this case Calc surrounds the argument with 14622braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}. 14623 14624Font change codes (like @samp{roman @var{x}}) and positioning codes 14625(like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the 14626@dfn{eqn} reader. Also ignored are the words @code{left}, @code{right}, 14627@code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input 14628are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to 14629@samp{sqrt @{1+x@}}; this is only an approximation to the true meaning 14630of quotes in @dfn{eqn}, but it is good enough for most uses. 14631 14632Accent codes (@samp{@var{x} dot}) are handled by treating them as 14633function calls (@samp{dot(@var{x})}) internally. 14634@xref{TeX and LaTeX Language Modes}, for a table of these accent 14635functions. The @code{prime} accent is treated specially if it occurs on 14636a variable or function name: @samp{f prime prime @w{( x prime )}} is 14637stored internally as @samp{f'@w{'}(x')}. For example, taking the 14638derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2 14639x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}. 14640 14641Assignments are written with the @samp{<-} (left-arrow) symbol, 14642and @code{evalto} operators are written with @samp{->} or 14643@samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion 14644of this). The regular Calc symbols @samp{:=} and @samp{=>} are also 14645recognized for these operators during reading. 14646 14647Vectors in @dfn{eqn} mode use regular Calc square brackets, but 14648matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}. 14649The words @code{lcol} and @code{rcol} are recognized as synonyms 14650for @code{ccol} during input, and are generated instead of @code{ccol} 14651if the matrix justification mode so specifies. 14652 14653@node Yacas Language Mode, Maxima Language Mode, Eqn Language Mode, Language Modes 14654@subsection Yacas Language Mode 14655 14656@noindent 14657@kindex d Y 14658@pindex calc-yacas-language 14659@cindex Yacas language 14660The @kbd{d Y} (@code{calc-yacas-language}) command selects the 14661conventions of Yacas, a free computer algebra system. While the 14662operators and functions in Yacas are similar to those of Calc, the names 14663of built-in functions in Yacas are capitalized. The Calc formula 14664@samp{sin(2 x)}, for example, is entered and displayed @samp{Sin(2 x)} 14665in Yacas mode, and @samp{arcsin(x^2)} is @samp{ArcSin(x^2)} in Yacas 14666mode. Complex numbers are written are written @samp{3 + 4 I}. 14667The standard special constants are written @code{Pi}, @code{E}, 14668@code{I}, @code{GoldenRatio} and @code{Gamma}. @code{Infinity} 14669represents both @code{inf} and @code{uinf}, and @code{Undefined} 14670represents @code{nan}. 14671 14672Certain operators on functions, such as @code{D} for differentiation 14673and @code{Integrate} for integration, take a prefix form in Yacas. For 14674example, the derivative of @w{@samp{e^x sin(x)}} can be computed with 14675@w{@samp{D(x) Exp(x)*Sin(x)}}. 14676 14677Other notable differences between Yacas and standard Calc expressions 14678are that vectors and matrices use curly braces in Yacas, and subscripts 14679use square brackets. If, for example, @samp{A} represents the list 14680@samp{@{a,2,c,4@}}, then @samp{A[3]} would equal @samp{c}. 14681 14682 14683@node Maxima Language Mode, Giac Language Mode, Yacas Language Mode, Language Modes 14684@subsection Maxima Language Mode 14685 14686@noindent 14687@kindex d X 14688@pindex calc-maxima-language 14689@cindex Maxima language 14690The @kbd{d X} (@code{calc-maxima-language}) command selects the 14691conventions of Maxima, another free computer algebra system. The 14692function names in Maxima are similar, but not always identical, to Calc. 14693For example, instead of @samp{arcsin(x)}, Maxima will use 14694@samp{asin(x)}. Complex numbers are written @samp{3 + 4 %i}. The 14695standard special constants are written @code{%pi}, @code{%e}, 14696@code{%i}, @code{%phi} and @code{%gamma}. In Maxima, @code{inf} means 14697the same as in Calc, but @code{infinity} represents Calc's @code{uinf}. 14698 14699Underscores as well as percent signs are allowed in function and 14700variable names in Maxima mode. The underscore again is equivalent to 14701the @samp{#} in Normal mode, and the percent sign is equivalent to 14702@samp{o'o}. 14703 14704Maxima uses square brackets for lists and vectors, and matrices are 14705written as calls to the function @code{matrix}, given the row vectors of 14706the matrix as arguments. Square brackets are also used as subscripts. 14707 14708@node Giac Language Mode, Mathematica Language Mode, Maxima Language Mode, Language Modes 14709@subsection Giac Language Mode 14710 14711@noindent 14712@kindex d A 14713@pindex calc-giac-language 14714@cindex Giac language 14715The @kbd{d A} (@code{calc-giac-language}) command selects the 14716conventions of Giac, another free computer algebra system. The function 14717names in Giac are similar to Maxima. Complex numbers are written 14718@samp{3 + 4 i}. The standard special constants in Giac are the same as 14719in Calc, except that @code{infinity} represents both Calc's @code{inf} 14720and @code{uinf}. 14721 14722Underscores are allowed in function and variable names in Giac mode. 14723Brackets are used for subscripts. In Giac, indexing of lists begins at 147240, instead of 1 as in Calc. So if @samp{A} represents the list 14725@samp{[a,2,c,4]}, then @samp{A[2]} would equal @samp{c}. In general, 14726@samp{A[n]} in Giac mode corresponds to @samp{A_(n+1)} in Normal mode. 14727 14728The Giac interval notation @samp{2 .. 3} has no surrounding brackets; 14729Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]} and 14730writes any kind of interval as @samp{2 .. 3}. This means you cannot see 14731the difference between an open and a closed interval while in Giac mode. 14732 14733@node Mathematica Language Mode, Maple Language Mode, Giac Language Mode, Language Modes 14734@subsection Mathematica Language Mode 14735 14736@noindent 14737@kindex d M 14738@pindex calc-mathematica-language 14739@cindex Mathematica language 14740The @kbd{d M} (@code{calc-mathematica-language}) command selects the 14741conventions of Mathematica. Notable differences in Mathematica mode 14742are that the names of built-in functions are capitalized, and function 14743calls use square brackets instead of parentheses. Thus the Calc 14744formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in 14745Mathematica mode. 14746 14747Vectors and matrices use curly braces in Mathematica. Complex numbers 14748are written @samp{3 + 4 I}. The standard special constants in Calc are 14749written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma}, 14750@code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in 14751Mathematica mode. 14752Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point 14753numbers in scientific notation are written @samp{1.23*10.^3}. 14754Subscripts use double square brackets: @samp{a[[i]]}. 14755 14756@node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes 14757@subsection Maple Language Mode 14758 14759@noindent 14760@kindex d W 14761@pindex calc-maple-language 14762@cindex Maple language 14763The @kbd{d W} (@code{calc-maple-language}) command selects the 14764conventions of Maple. 14765 14766Maple's language is much like C@. Underscores are allowed in symbol 14767names; square brackets are used for subscripts; explicit @samp{*}s for 14768multiplications are required. Use either @samp{^} or @samp{**} to 14769denote powers. 14770 14771Maple uses square brackets for lists and curly braces for sets. Calc 14772interprets both notations as vectors, and displays vectors with square 14773brackets. This means Maple sets will be converted to lists when they 14774pass through Calc. As a special case, matrices are written as calls 14775to the function @code{matrix}, given a list of lists as the argument, 14776and can be read in this form or with all-capitals @code{MATRIX}. 14777 14778The Maple interval notation @samp{2 .. 3} is like Giac's interval 14779notation, and is handled the same by Calc. 14780 14781Maple writes complex numbers as @samp{3 + 4*I}. Its special constants 14782are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of 14783@code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}). 14784Floating-point numbers are written @samp{1.23*10.^3}. 14785 14786Among things not currently handled by Calc's Maple mode are the 14787various quote symbols, procedures and functional operators, and 14788inert (@samp{&}) operators. 14789 14790@node Compositions, Syntax Tables, Maple Language Mode, Language Modes 14791@subsection Compositions 14792 14793@noindent 14794@cindex Compositions 14795There are several @dfn{composition functions} which allow you to get 14796displays in a variety of formats similar to those in Big language 14797mode. Most of these functions do not evaluate to anything; they are 14798placeholders which are left in symbolic form by Calc's evaluator but 14799are recognized by Calc's display formatting routines. 14800 14801Two of these, @code{string} and @code{bstring}, are described elsewhere. 14802@xref{Strings}. For example, @samp{string("ABC")} is displayed as 14803@samp{ABC}. When viewed on the stack it will be indistinguishable from 14804the variable @code{ABC}, but internally it will be stored as 14805@samp{string([65, 66, 67])} and can still be manipulated this way; for 14806example, the selection and vector commands @kbd{j 1 v v j u} would 14807select the vector portion of this object and reverse the elements, then 14808deselect to reveal a string whose characters had been reversed. 14809 14810The composition functions do the same thing in all language modes 14811(although their components will of course be formatted in the current 14812language mode). The one exception is Unformatted mode (@kbd{d U}), 14813which does not give the composition functions any special treatment. 14814The functions are discussed here because of their relationship to 14815the language modes. 14816 14817@menu 14818* Composition Basics:: 14819* Horizontal Compositions:: 14820* Vertical Compositions:: 14821* Other Compositions:: 14822* Information about Compositions:: 14823* User-Defined Compositions:: 14824@end menu 14825 14826@node Composition Basics, Horizontal Compositions, Compositions, Compositions 14827@subsubsection Composition Basics 14828 14829@noindent 14830Compositions are generally formed by stacking formulas together 14831horizontally or vertically in various ways. Those formulas are 14832themselves compositions. @TeX{} users will find this analogous 14833to @TeX{}'s ``boxes.'' Each multi-line composition has a 14834@dfn{baseline}; horizontal compositions use the baselines to 14835decide how formulas should be positioned relative to one another. 14836For example, in the Big mode formula 14837 14838@example 14839@group 14840 2 14841 a + b 1484217 + ------ 14843 c 14844@end group 14845@end example 14846 14847@noindent 14848the second term of the sum is four lines tall and has line three as 14849its baseline. Thus when the term is combined with 17, line three 14850is placed on the same level as the baseline of 17. 14851 14852@tex 14853\bigskip 14854@end tex 14855 14856Another important composition concept is @dfn{precedence}. This is 14857an integer that represents the binding strength of various operators. 14858For example, @samp{*} has higher precedence (195) than @samp{+} (180), 14859which means that @samp{(a * b) + c} will be formatted without the 14860parentheses, but @samp{a * (b + c)} will keep the parentheses. 14861 14862The operator table used by normal and Big language modes has the 14863following precedences: 14864 14865@example 14866_ 1200 @r{(subscripts)} 14867% 1100 @r{(as in n}%@r{)} 14868! 1000 @r{(as in }!@r{n)} 14869mod 400 14870+/- 300 14871!! 210 @r{(as in n}!!@r{)} 14872! 210 @r{(as in n}!@r{)} 14873^ 200 14874- 197 @r{(as in }-@r{n)} 14875* 195 @r{(or implicit multiplication)} 14876/ % \ 190 14877+ - 180 @r{(as in a}+@r{b)} 14878| 170 14879< = 160 @r{(and other relations)} 14880&& 110 14881|| 100 14882? : 90 14883!!! 85 14884&&& 80 14885||| 75 14886:= 50 14887:: 45 14888=> 40 14889@end example 14890 14891The general rule is that if an operator with precedence @expr{n} 14892occurs as an argument to an operator with precedence @expr{m}, then 14893the argument is enclosed in parentheses if @expr{n < m}. Top-level 14894expressions and expressions which are function arguments, vector 14895components, etc., are formatted with precedence zero (so that they 14896normally never get additional parentheses). 14897 14898For binary left-associative operators like @samp{+}, the righthand 14899argument is actually formatted with one-higher precedence than shown 14900in the table. This makes sure @samp{(a + b) + c} omits the parentheses, 14901but the unnatural form @samp{a + (b + c)} keeps its parentheses. 14902Right-associative operators like @samp{^} format the lefthand argument 14903with one-higher precedence. 14904 14905@ignore 14906@starindex 14907@end ignore 14908@tindex cprec 14909The @code{cprec} function formats an expression with an arbitrary 14910precedence. For example, @samp{cprec(abc, 185)} will combine into 14911sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because 14912this @code{cprec} form has higher precedence than addition, but lower 14913precedence than multiplication). 14914 14915@tex 14916\bigskip 14917@end tex 14918 14919A final composition issue is @dfn{line breaking}. Calc uses two 14920different strategies for ``flat'' and ``non-flat'' compositions. 14921A non-flat composition is anything that appears on multiple lines 14922(not counting line breaking). Examples would be matrices and Big 14923mode powers and quotients. Non-flat compositions are displayed 14924exactly as specified. If they come out wider than the current 14925window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to 14926view them. 14927 14928Flat compositions, on the other hand, will be broken across several 14929lines if they are too wide to fit the window. Certain points in a 14930composition are noted internally as @dfn{break points}. Calc's 14931general strategy is to fill each line as much as possible, then to 14932move down to the next line starting at the first break point that 14933didn't fit. However, the line breaker understands the hierarchical 14934structure of formulas. It will not break an ``inner'' formula if 14935it can use an earlier break point from an ``outer'' formula instead. 14936For example, a vector of sums might be formatted as: 14937 14938@example 14939@group 14940[ a + b + c, d + e + f, 14941 g + h + i, j + k + l, m ] 14942@end group 14943@end example 14944 14945@noindent 14946If the @samp{m} can fit, then so, it seems, could the @samp{g}. 14947But Calc prefers to break at the comma since the comma is part 14948of a ``more outer'' formula. Calc would break at a plus sign 14949only if it had to, say, if the very first sum in the vector had 14950itself been too large to fit. 14951 14952Of the composition functions described below, only @code{choriz} 14953generates break points. The @code{bstring} function (@pxref{Strings}) 14954also generates breakable items: A break point is added after every 14955space (or group of spaces) except for spaces at the very beginning or 14956end of the string. 14957 14958Composition functions themselves count as levels in the formula 14959hierarchy, so a @code{choriz} that is a component of a larger 14960@code{choriz} will be less likely to be broken. As a special case, 14961if a @code{bstring} occurs as a component of a @code{choriz} or 14962@code{choriz}-like object (such as a vector or a list of arguments 14963in a function call), then the break points in that @code{bstring} 14964will be on the same level as the break points of the surrounding 14965object. 14966 14967@node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions 14968@subsubsection Horizontal Compositions 14969 14970@noindent 14971@ignore 14972@starindex 14973@end ignore 14974@tindex choriz 14975The @code{choriz} function takes a vector of objects and composes 14976them horizontally. For example, @samp{choriz([17, a b/c, d])} formats 14977as @w{@samp{17a b / cd}} in Normal language mode, or as 14978 14979@example 14980@group 14981 a b 1498217---d 14983 c 14984@end group 14985@end example 14986 14987@noindent 14988in Big language mode. This is actually one case of the general 14989function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where 14990either or both of @var{sep} and @var{prec} may be omitted. 14991@var{Prec} gives the @dfn{precedence} to use when formatting 14992each of the components of @var{vec}. The default precedence is 14993the precedence from the surrounding environment. 14994 14995@var{Sep} is a string (i.e., a vector of character codes as might 14996be entered with @code{" "} notation) which should separate components 14997of the composition. Also, if @var{sep} is given, the line breaker 14998will allow lines to be broken after each occurrence of @var{sep}. 14999If @var{sep} is omitted, the composition will not be breakable 15000(unless any of its component compositions are breakable). 15001 15002For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is 15003formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz} 15004to have precedence 180 ``outwards'' as well as ``inwards,'' 15005enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)} 15006formats as @samp{2 (a + b c + (d = e))}. 15007 15008The baseline of a horizontal composition is the same as the 15009baselines of the component compositions, which are all aligned. 15010 15011@node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions 15012@subsubsection Vertical Compositions 15013 15014@noindent 15015@ignore 15016@starindex 15017@end ignore 15018@tindex cvert 15019The @code{cvert} function makes a vertical composition. Each 15020component of the vector is centered in a column. The baseline of 15021the result is by default the top line of the resulting composition. 15022For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))} 15023formats in Big mode as 15024 15025@example 15026@group 15027f( a , 2 ) 15028 bb a + 1 15029 ccc 2 15030 b 15031@end group 15032@end example 15033 15034@ignore 15035@starindex 15036@end ignore 15037@tindex cbase 15038There are several special composition functions that work only as 15039components of a vertical composition. The @code{cbase} function 15040controls the baseline of the vertical composition; the baseline 15041will be the same as the baseline of whatever component is enclosed 15042in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]), 15043cvert([a^2 + 1, cbase(b^2)]))} displays as 15044 15045@example 15046@group 15047 2 15048 a + 1 15049 a 2 15050f(bb , b ) 15051 ccc 15052@end group 15053@end example 15054 15055@ignore 15056@starindex 15057@end ignore 15058@tindex ctbase 15059@ignore 15060@starindex 15061@end ignore 15062@tindex cbbase 15063There are also @code{ctbase} and @code{cbbase} functions which 15064make the baseline of the vertical composition equal to the top 15065or bottom line (rather than the baseline) of that component. 15066Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) + 15067cvert([cbbase(a / b)])} gives 15068 15069@example 15070@group 15071 a 15072a - 15073- + a + b 15074b - 15075 b 15076@end group 15077@end example 15078 15079There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase} 15080function in a given vertical composition. These functions can also 15081be written with no arguments: @samp{ctbase()} is a zero-height object 15082which means the baseline is the top line of the following item, and 15083@samp{cbbase()} means the baseline is the bottom line of the preceding 15084item. 15085 15086@ignore 15087@starindex 15088@end ignore 15089@tindex crule 15090The @code{crule} function builds a ``rule,'' or horizontal line, 15091across a vertical composition. By itself @samp{crule()} uses @samp{-} 15092characters to build the rule. You can specify any other character, 15093e.g., @samp{crule("=")}. The argument must be a character code or 15094vector of exactly one character code. It is repeated to match the 15095width of the widest item in the stack. For example, a quotient 15096with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}: 15097 15098@example 15099@group 15100a + 1 15101===== 15102 2 15103 b 15104@end group 15105@end example 15106 15107@ignore 15108@starindex 15109@end ignore 15110@tindex clvert 15111@ignore 15112@starindex 15113@end ignore 15114@tindex crvert 15115Finally, the functions @code{clvert} and @code{crvert} act exactly 15116like @code{cvert} except that the items are left- or right-justified 15117in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])} 15118gives: 15119 15120@example 15121@group 15122a + a 15123bb bb 15124ccc ccc 15125@end group 15126@end example 15127 15128Like @code{choriz}, the vertical compositions accept a second argument 15129which gives the precedence to use when formatting the components. 15130Vertical compositions do not support separator strings. 15131 15132@node Other Compositions, Information about Compositions, Vertical Compositions, Compositions 15133@subsubsection Other Compositions 15134 15135@noindent 15136@ignore 15137@starindex 15138@end ignore 15139@tindex csup 15140The @code{csup} function builds a superscripted expression. For 15141example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big 15142language mode. This is essentially a horizontal composition of 15143@samp{a} and @samp{b}, where @samp{b} is shifted up so that its 15144bottom line is one above the baseline. 15145 15146@ignore 15147@starindex 15148@end ignore 15149@tindex csub 15150Likewise, the @code{csub} function builds a subscripted expression. 15151This shifts @samp{b} down so that its top line is one below the 15152bottom line of @samp{a} (note that this is not quite analogous to 15153@code{csup}). Other arrangements can be obtained by using 15154@code{choriz} and @code{cvert} directly. 15155 15156@ignore 15157@starindex 15158@end ignore 15159@tindex cflat 15160The @code{cflat} function formats its argument in ``flat'' mode, 15161as obtained by @samp{d O}, if the current language mode is normal 15162or Big. It has no effect in other language modes. For example, 15163@samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))} 15164to improve its readability. 15165 15166@ignore 15167@starindex 15168@end ignore 15169@tindex cspace 15170The @code{cspace} function creates horizontal space. For example, 15171@samp{cspace(4)} is effectively the same as @samp{string(" ")}. 15172A second string (i.e., vector of characters) argument is repeated 15173instead of the space character. For example, @samp{cspace(4, "ab")} 15174looks like @samp{abababab}. If the second argument is not a string, 15175it is formatted in the normal way and then several copies of that 15176are composed together: @samp{cspace(4, a^2)} yields 15177 15178@example 15179@group 15180 2 2 2 2 15181a a a a 15182@end group 15183@end example 15184 15185@noindent 15186If the number argument is zero, this is a zero-width object. 15187 15188@ignore 15189@starindex 15190@end ignore 15191@tindex cvspace 15192The @code{cvspace} function creates vertical space, or a vertical 15193stack of copies of a certain string or formatted object. The 15194baseline is the center line of the resulting stack. A numerical 15195argument of zero will produce an object which contributes zero 15196height if used in a vertical composition. 15197 15198@ignore 15199@starindex 15200@end ignore 15201@tindex ctspace 15202@ignore 15203@starindex 15204@end ignore 15205@tindex cbspace 15206There are also @code{ctspace} and @code{cbspace} functions which 15207create vertical space with the baseline the same as the baseline 15208of the top or bottom copy, respectively, of the second argument. 15209Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)} 15210displays as: 15211 15212@example 15213@group 15214 a 15215 - 15216a b 15217- a a 15218b + - + - 15219a b b 15220- a 15221b - 15222 b 15223@end group 15224@end example 15225 15226@node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions 15227@subsubsection Information about Compositions 15228 15229@noindent 15230The functions in this section are actual functions; they compose their 15231arguments according to the current language and other display modes, 15232then return a certain measurement of the composition as an integer. 15233 15234@ignore 15235@starindex 15236@end ignore 15237@tindex cwidth 15238The @code{cwidth} function measures the width, in characters, of a 15239composition. For example, @samp{cwidth(a + b)} is 5, and 15240@samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in 15241@TeX{} mode (for @samp{@{a \over b@}}). The argument may involve 15242the composition functions described in this section. 15243 15244@ignore 15245@starindex 15246@end ignore 15247@tindex cheight 15248The @code{cheight} function measures the height of a composition. 15249This is the total number of lines in the argument's printed form. 15250 15251@ignore 15252@starindex 15253@end ignore 15254@tindex cascent 15255@ignore 15256@starindex 15257@end ignore 15258@tindex cdescent 15259The functions @code{cascent} and @code{cdescent} measure the amount 15260of the height that is above (and including) the baseline, or below 15261the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})} 15262always equals @samp{cheight(@var{x})}. For a one-line formula like 15263@samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0. 15264For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent} 15265returns 1. The only formula for which @code{cascent} will return zero 15266is @samp{cvspace(0)} or equivalents. 15267 15268@node User-Defined Compositions, , Information about Compositions, Compositions 15269@subsubsection User-Defined Compositions 15270 15271@noindent 15272@kindex Z C 15273@pindex calc-user-define-composition 15274The @kbd{Z C} (@code{calc-user-define-composition}) command lets you 15275define the display format for any algebraic function. You provide a 15276formula containing a certain number of argument variables on the stack. 15277Any time Calc formats a call to the specified function in the current 15278language mode and with that number of arguments, Calc effectively 15279replaces the function call with that formula with the arguments 15280replaced. 15281 15282Calc builds the default argument list by sorting all the variable names 15283that appear in the formula into alphabetical order. You can edit this 15284argument list before pressing @key{RET} if you wish. Any variables in 15285the formula that do not appear in the argument list will be displayed 15286literally; any arguments that do not appear in the formula will not 15287affect the display at all. 15288 15289You can define formats for built-in functions, for functions you have 15290defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions 15291which have no definitions but are being used as purely syntactic objects. 15292You can define different formats for each language mode, and for each 15293number of arguments, using a succession of @kbd{Z C} commands. When 15294Calc formats a function call, it first searches for a format defined 15295for the current language mode (and number of arguments); if there is 15296none, it uses the format defined for the Normal language mode. If 15297neither format exists, Calc uses its built-in standard format for that 15298function (usually just @samp{@var{func}(@var{args})}). 15299 15300If you execute @kbd{Z C} with the number 0 on the stack instead of a 15301formula, any defined formats for the function in the current language 15302mode will be removed. The function will revert to its standard format. 15303 15304For example, the default format for the binomial coefficient function 15305@samp{choose(n, m)} in the Big language mode is 15306 15307@example 15308@group 15309 n 15310( ) 15311 m 15312@end group 15313@end example 15314 15315@noindent 15316You might prefer the notation, 15317 15318@example 15319@group 15320 C 15321n m 15322@end group 15323@end example 15324 15325@noindent 15326To define this notation, first make sure you are in Big mode, 15327then put the formula 15328 15329@smallexample 15330choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])]) 15331@end smallexample 15332 15333@noindent 15334on the stack and type @kbd{Z C}. Answer the first prompt with 15335@code{choose}. The second prompt will be the default argument list 15336of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press 15337@key{RET}. Now, try it out: For example, turn simplification 15338off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)} 15339as an algebraic entry. 15340 15341@example 15342@group 15343 C + C 15344a b 7 3 15345@end group 15346@end example 15347 15348As another example, let's define the usual notation for Stirling 15349numbers of the first kind, @samp{stir1(n, m)}. This is just like 15350the regular format for binomial coefficients but with square brackets 15351instead of parentheses. 15352 15353@smallexample 15354choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")]) 15355@end smallexample 15356 15357Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to 15358@samp{(n m)}, and type @key{RET}. 15359 15360The formula provided to @kbd{Z C} usually will involve composition 15361functions, but it doesn't have to. Putting the formula @samp{a + b + c} 15362onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define 15363the function @samp{foo(x,y,z)} to display like @samp{x + y + z}. 15364This ``sum'' will act exactly like a real sum for all formatting 15365purposes (it will be parenthesized the same, and so on). However 15366it will be computationally unrelated to a sum. For example, the 15367formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}. 15368Operator precedences have caused the ``sum'' to be written in 15369parentheses, but the arguments have not actually been summed. 15370(Generally a display format like this would be undesirable, since 15371it can easily be confused with a real sum.) 15372 15373The special function @code{eval} can be used inside a @kbd{Z C} 15374composition formula to cause all or part of the formula to be 15375evaluated at display time. For example, if the formula is 15376@samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed 15377as @samp{1 + 5}. Evaluation will use the default simplifications, 15378regardless of the current simplification mode. There are also 15379@code{evalsimp} and @code{evalextsimp} which simplify as if by 15380@kbd{a s} and @kbd{a e} (respectively). Note that these ``functions'' 15381operate only in the context of composition formulas (and also in 15382rewrite rules, where they serve a similar purpose; @pxref{Rewrite 15383Rules}). On the stack, a call to @code{eval} will be left in 15384symbolic form. 15385 15386It is not a good idea to use @code{eval} except as a last resort. 15387It can cause the display of formulas to be extremely slow. For 15388example, while @samp{eval(a + b)} might seem quite fast and simple, 15389there are several situations where it could be slow. For example, 15390@samp{a} and/or @samp{b} could be polar complex numbers, in which 15391case doing the sum requires trigonometry. Or, @samp{a} could be 15392the factorial @samp{fact(100)} which is unevaluated because you 15393have typed @kbd{m O}; @code{eval} will evaluate it anyway to 15394produce a large, unwieldy integer. 15395 15396You can save your display formats permanently using the @kbd{Z P} 15397command (@pxref{Creating User Keys}). 15398 15399@node Syntax Tables, , Compositions, Language Modes 15400@subsection Syntax Tables 15401 15402@noindent 15403@cindex Syntax tables 15404@cindex Parsing formulas, customized 15405Syntax tables do for input what compositions do for output: They 15406allow you to teach custom notations to Calc's formula parser. 15407Calc keeps a separate syntax table for each language mode. 15408 15409(Note that the Calc ``syntax tables'' discussed here are completely 15410unrelated to the syntax tables described in the Emacs manual.) 15411 15412@kindex Z S 15413@pindex calc-edit-user-syntax 15414The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the 15415syntax table for the current language mode. If you want your 15416syntax to work in any language, define it in the Normal language 15417mode. Type @kbd{C-c C-c} to finish editing the syntax table, or 15418@kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all 15419the syntax tables along with the other mode settings; 15420@pxref{General Mode Commands}. 15421 15422@menu 15423* Syntax Table Basics:: 15424* Precedence in Syntax Tables:: 15425* Advanced Syntax Patterns:: 15426* Conditional Syntax Rules:: 15427@end menu 15428 15429@node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables 15430@subsubsection Syntax Table Basics 15431 15432@noindent 15433@dfn{Parsing} is the process of converting a raw string of characters, 15434such as you would type in during algebraic entry, into a Calc formula. 15435Calc's parser works in two stages. First, the input is broken down 15436into @dfn{tokens}, such as words, numbers, and punctuation symbols 15437like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is 15438ignored (except when it serves to separate adjacent words). Next, 15439the parser matches this string of tokens against various built-in 15440syntactic patterns, such as ``an expression followed by @samp{+} 15441followed by another expression'' or ``a name followed by @samp{(}, 15442zero or more expressions separated by commas, and @samp{)}.'' 15443 15444A @dfn{syntax table} is a list of user-defined @dfn{syntax rules}, 15445which allow you to specify new patterns to define your own 15446favorite input notations. Calc's parser always checks the syntax 15447table for the current language mode, then the table for the Normal 15448language mode, before it uses its built-in rules to parse an 15449algebraic formula you have entered. Each syntax rule should go on 15450its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol, 15451and a Calc formula with an optional @dfn{condition}. (Syntax rules 15452resemble algebraic rewrite rules, but the notation for patterns is 15453completely different.) 15454 15455A syntax pattern is a list of tokens, separated by spaces. 15456Except for a few special symbols, tokens in syntax patterns are 15457matched literally, from left to right. For example, the rule, 15458 15459@example 15460foo ( ) := 2+3 15461@end example 15462 15463@noindent 15464would cause Calc to parse the formula @samp{4+foo()*5} as if it 15465were @samp{4+(2+3)*5}. Notice that the parentheses were written 15466as two separate tokens in the rule. As a result, the rule works 15467for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written 15468the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()} 15469as a single, indivisible token, so that @w{@samp{foo( )}} would 15470not be recognized by the rule. (It would be parsed as a regular 15471zero-argument function call instead.) In fact, this rule would 15472also make trouble for the rest of Calc's parser: An unrelated 15473formula like @samp{bar()} would now be tokenized into @samp{bar ()} 15474instead of @samp{bar ( )}, so that the standard parser for function 15475calls would no longer recognize it! 15476 15477While it is possible to make a token with a mixture of letters 15478and punctuation symbols, this is not recommended. It is better to 15479break it into several tokens, as we did with @samp{foo()} above. 15480 15481The symbol @samp{#} in a syntax pattern matches any Calc expression. 15482On the righthand side, the things that matched the @samp{#}s can 15483be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1} 15484matches the leftmost @samp{#} in the pattern). For example, these 15485rules match a user-defined function, prefix operator, infix operator, 15486and postfix operator, respectively: 15487 15488@example 15489foo ( # ) := myfunc(#1) 15490foo # := myprefix(#1) 15491# foo # := myinfix(#1,#2) 15492# foo := mypostfix(#1) 15493@end example 15494 15495Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo} 15496will parse as @samp{mypostfix(2+3)}. 15497 15498It is important to write the first two rules in the order shown, 15499because Calc tries rules in order from first to last. If the 15500pattern @samp{foo #} came first, it would match anything that could 15501match the @samp{foo ( # )} rule, since an expression in parentheses 15502is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would 15503never get to match anything. Likewise, the last two rules must be 15504written in the order shown or else @samp{3 foo 4} will be parsed as 15505@samp{mypostfix(3) * 4}. (Of course, the best way to avoid these 15506ambiguities is not to use the same symbol in more than one way at 15507the same time! In case you're not convinced, try the following 15508exercise: How will the above rules parse the input @samp{foo(3,4)}, 15509if at all? Work it out for yourself, then try it in Calc and see.) 15510 15511Calc is quite flexible about what sorts of patterns are allowed. 15512The only rule is that every pattern must begin with a literal 15513token (like @samp{foo} in the first two patterns above), or with 15514a @samp{#} followed by a literal token (as in the last two 15515patterns). After that, any mixture is allowed, although putting 15516two @samp{#}s in a row will not be very useful since two 15517expressions with nothing between them will be parsed as one 15518expression that uses implicit multiplication. 15519 15520As a more practical example, Maple uses the notation 15521@samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't 15522recognize at present. To handle this syntax, we simply add the 15523rule, 15524 15525@example 15526sum ( # , # = # .. # ) := sum(#1,#2,#3,#4) 15527@end example 15528 15529@noindent 15530to the Maple mode syntax table. As another example, C mode can't 15531read assignment operators like @samp{++} and @samp{*=}. We can 15532define these operators quite easily: 15533 15534@example 15535# *= # := muleq(#1,#2) 15536# ++ := postinc(#1) 15537++ # := preinc(#1) 15538@end example 15539 15540@noindent 15541To complete the job, we would use corresponding composition functions 15542and @kbd{Z C} to cause these functions to display in their respective 15543Maple and C notations. (Note that the C example ignores issues of 15544operator precedence, which are discussed in the next section.) 15545 15546You can enclose any token in quotes to prevent its usual 15547interpretation in syntax patterns: 15548 15549@example 15550# ":=" # := becomes(#1,#2) 15551@end example 15552 15553Quotes also allow you to include spaces in a token, although once 15554again it is generally better to use two tokens than one token with 15555an embedded space. To include an actual quotation mark in a quoted 15556token, precede it with a backslash. (This also works to include 15557backslashes in tokens.) 15558 15559@example 15560# "bad token" # "/\"\\" # := silly(#1,#2,#3) 15561@end example 15562 15563@noindent 15564This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}. 15565 15566The token @kbd{#} has a predefined meaning in Calc's formula parser; 15567it is not valid to use @samp{"#"} in a syntax rule. However, longer 15568tokens that include the @samp{#} character are allowed. Also, while 15569@samp{"$"} and @samp{"\""} are allowed as tokens, their presence in 15570the syntax table will prevent those characters from working in their 15571usual ways (referring to stack entries and quoting strings, 15572respectively). 15573 15574Finally, the notation @samp{%%} anywhere in a syntax table causes 15575the rest of the line to be ignored as a comment. 15576 15577@node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables 15578@subsubsection Precedence 15579 15580@noindent 15581Different operators are generally assigned different @dfn{precedences}. 15582By default, an operator defined by a rule like 15583 15584@example 15585# foo # := foo(#1,#2) 15586@end example 15587 15588@noindent 15589will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6} 15590will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the 15591precedence of an operator, use the notation @samp{#/@var{p}} in 15592place of @samp{#}, where @var{p} is an integer precedence level. 15593For example, 185 lies between the precedences for @samp{+} and 15594@samp{*}, so if we change this rule to 15595 15596@example 15597#/185 foo #/186 := foo(#1,#2) 15598@end example 15599 15600@noindent 15601then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}. 15602Also, because we've given the righthand expression slightly higher 15603precedence, our new operator will be left-associative: 15604@samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}. 15605By raising the precedence of the lefthand expression instead, we 15606can create a right-associative operator. 15607 15608@xref{Composition Basics}, for a table of precedences of the 15609standard Calc operators. For the precedences of operators in other 15610language modes, look in the Calc source file @file{calc-lang.el}. 15611 15612@node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables 15613@subsubsection Advanced Syntax Patterns 15614 15615@noindent 15616To match a function with a variable number of arguments, you could 15617write 15618 15619@example 15620foo ( # ) := myfunc(#1) 15621foo ( # , # ) := myfunc(#1,#2) 15622foo ( # , # , # ) := myfunc(#1,#2,#3) 15623@end example 15624 15625@noindent 15626but this isn't very elegant. To match variable numbers of items, 15627Calc uses some notations inspired regular expressions and the 15628``extended BNF'' style used by some language designers. 15629 15630@example 15631foo ( @{ # @}*, ) := apply(myfunc,#1) 15632@end example 15633 15634The token @samp{@{} introduces a repeated or optional portion. 15635One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?} 15636ends the portion. These will match zero or more, one or more, 15637or zero or one copies of the enclosed pattern, respectively. 15638In addition, @samp{@}*} and @samp{@}+} can be followed by a 15639separator token (with no space in between, as shown above). 15640Thus @samp{@{ # @}*,} matches nothing, or one expression, or 15641several expressions separated by commas. 15642 15643A complete @samp{@{ ... @}} item matches as a vector of the 15644items that matched inside it. For example, the above rule will 15645match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}. 15646The Calc @code{apply} function takes a function name and a vector 15647of arguments and builds a call to the function with those 15648arguments, so the net result is the formula @samp{myfunc(1,2,3)}. 15649 15650If the body of a @samp{@{ ... @}} contains several @samp{#}s 15651(or nested @samp{@{ ... @}} constructs), then the items will be 15652strung together into the resulting vector. If the body 15653does not contain anything but literal tokens, the result will 15654always be an empty vector. 15655 15656@example 15657foo ( @{ # , # @}+, ) := bar(#1) 15658foo ( @{ @{ # @}*, @}*; ) := matrix(#1) 15659@end example 15660 15661@noindent 15662will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and 15663@samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after 15664some thought it's easy to see how this pair of rules will parse 15665@samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first 15666rule will only match an even number of arguments. The rule 15667 15668@example 15669foo ( # @{ , # , # @}? ) := bar(#1,#2) 15670@end example 15671 15672@noindent 15673will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and 15674@samp{foo(2)} as @samp{bar(2,[])}. 15675 15676The notation @samp{@{ ... @}?.} (note the trailing period) works 15677just the same as regular @samp{@{ ... @}?}, except that it does not 15678count as an argument; the following two rules are equivalent: 15679 15680@example 15681foo ( # , @{ also @}? # ) := bar(#1,#3) 15682foo ( # , @{ also @}?. # ) := bar(#1,#2) 15683@end example 15684 15685@noindent 15686Note that in the first case the optional text counts as @samp{#2}, 15687which will always be an empty vector, but in the second case no 15688empty vector is produced. 15689 15690Another variant is @samp{@{ ... @}?$}, which means the body is 15691optional only at the end of the input formula. All built-in syntax 15692rules in Calc use this for closing delimiters, so that during 15693algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting 15694the closing parenthesis and bracket. Calc does this automatically 15695for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax 15696rules, but you can use @samp{@{ ... @}?$} explicitly to get 15697this effect with any token (such as @samp{"@}"} or @samp{end}). 15698Like @samp{@{ ... @}?.}, this notation does not count as an 15699argument. Conversely, you can use quotes, as in @samp{")"}, to 15700prevent a closing-delimiter token from being automatically treated 15701as optional. 15702 15703Calc's parser does not have full backtracking, which means some 15704patterns will not work as you might expect: 15705 15706@example 15707foo ( @{ # , @}? # , # ) := bar(#1,#2,#3) 15708@end example 15709 15710@noindent 15711Here we are trying to make the first argument optional, so that 15712@samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc 15713first tries to match @samp{2,} against the optional part of the 15714pattern, finds a match, and so goes ahead to match the rest of the 15715pattern. Later on it will fail to match the second comma, but it 15716doesn't know how to go back and try the other alternative at that 15717point. One way to get around this would be to use two rules: 15718 15719@example 15720foo ( # , # , # ) := bar([#1],#2,#3) 15721foo ( # , # ) := bar([],#1,#2) 15722@end example 15723 15724More precisely, when Calc wants to match an optional or repeated 15725part of a pattern, it scans forward attempting to match that part. 15726If it reaches the end of the optional part without failing, it 15727``finalizes'' its choice and proceeds. If it fails, though, it 15728backs up and tries the other alternative. Thus Calc has ``partial'' 15729backtracking. A fully backtracking parser would go on to make sure 15730the rest of the pattern matched before finalizing the choice. 15731 15732@node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables 15733@subsubsection Conditional Syntax Rules 15734 15735@noindent 15736It is possible to attach a @dfn{condition} to a syntax rule. For 15737example, the rules 15738 15739@example 15740foo ( # ) := ifoo(#1) :: integer(#1) 15741foo ( # ) := gfoo(#1) 15742@end example 15743 15744@noindent 15745will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse 15746@samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any 15747number of conditions may be attached; all must be true for the 15748rule to succeed. A condition is ``true'' if it evaluates to a 15749nonzero number. @xref{Logical Operations}, for a list of Calc 15750functions like @code{integer} that perform logical tests. 15751 15752The exact sequence of events is as follows: When Calc tries a 15753rule, it first matches the pattern as usual. It then substitutes 15754@samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the 15755conditions are simplified and evaluated in order from left to right, 15756using the algebraic simplifications (@pxref{Simplifying Formulas}). 15757Each result is true if it is a nonzero number, or an expression 15758that can be proven to be nonzero (@pxref{Declarations}). If the 15759results of all conditions are true, the expression (such as 15760@samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the 15761result of the parse. If the result of any condition is false, Calc 15762goes on to try the next rule in the syntax table. 15763 15764Syntax rules also support @code{let} conditions, which operate in 15765exactly the same way as they do in algebraic rewrite rules. 15766@xref{Other Features of Rewrite Rules}, for details. A @code{let} 15767condition is always true, but as a side effect it defines a 15768variable which can be used in later conditions, and also in the 15769expression after the @samp{:=} sign: 15770 15771@example 15772foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x) 15773@end example 15774 15775@noindent 15776The @code{dnumint} function tests if a value is numerically an 15777integer, i.e., either a true integer or an integer-valued float. 15778This rule will parse @code{foo} with a half-integer argument, 15779like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}. 15780 15781The lefthand side of a syntax rule @code{let} must be a simple 15782variable, not the arbitrary pattern that is allowed in rewrite 15783rules. 15784 15785The @code{matches} function is also treated specially in syntax 15786rule conditions (again, in the same way as in rewrite rules). 15787@xref{Matching Commands}. If the matching pattern contains 15788meta-variables, then those meta-variables may be used in later 15789conditions and in the result expression. The arguments to 15790@code{matches} are not evaluated in this situation. 15791 15792@example 15793sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c]) 15794@end example 15795 15796@noindent 15797This is another way to implement the Maple mode @code{sum} notation. 15798In this approach, we allow @samp{#2} to equal the whole expression 15799@samp{i=1..10}. Then, we use @code{matches} to break it apart into 15800its components. If the expression turns out not to match the pattern, 15801the syntax rule will fail. Note that @kbd{Z S} always uses Calc's 15802Normal language mode for editing expressions in syntax rules, so we 15803must use regular Calc notation for the interval @samp{[b..c]} that 15804will correspond to the Maple mode interval @samp{1..10}. 15805 15806@node Modes Variable, Calc Mode Line, Language Modes, Mode Settings 15807@section The @code{Modes} Variable 15808 15809@noindent 15810@kindex m g 15811@pindex calc-get-modes 15812The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack 15813a vector of numbers that describes the various mode settings that 15814are in effect. With a numeric prefix argument, it pushes only the 15815@var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard 15816macros can use the @kbd{m g} command to modify their behavior based 15817on the current mode settings. 15818 15819@cindex @code{Modes} variable 15820@vindex Modes 15821The modes vector is also available in the special variable 15822@code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}. 15823It will not work to store into this variable; in fact, if you do, 15824@code{Modes} will cease to track the current modes. (The @kbd{m g} 15825command will continue to work, however.) 15826 15827In general, each number in this vector is suitable as a numeric 15828prefix argument to the associated mode-setting command. (Recall 15829that the @kbd{~} key takes a number from the stack and gives it as 15830a numeric prefix to the next command.) 15831 15832The elements of the modes vector are as follows: 15833 15834@enumerate 15835@item 15836Current precision. Default is 12; associated command is @kbd{p}. 15837 15838@item 15839Binary word size. Default is 32; associated command is @kbd{b w}. 15840 15841@item 15842Stack size (not counting the value about to be pushed by @kbd{m g}). 15843This is zero if @kbd{m g} is executed with an empty stack. 15844 15845@item 15846Number radix. Default is 10; command is @kbd{d r}. 15847 15848@item 15849Floating-point format. This is the number of digits, plus the 15850constant 0 for normal notation, 10000 for scientific notation, 1585120000 for engineering notation, or 30000 for fixed-point notation. 15852These codes are acceptable as prefix arguments to the @kbd{d n} 15853command, but note that this may lose information: For example, 15854@kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite 15855identical) effects if the current precision is 12, but they both 15856produce a code of 10012, which will be treated by @kbd{d n} as 15857@kbd{C-u 12 d s}. If the precision then changes, the float format 15858will still be frozen at 12 significant figures. 15859 15860@item 15861Angular mode. Default is 1 (degrees). Other values are 2 (radians) 15862and 3 (HMS). The @kbd{m d} command accepts these prefixes. 15863 15864@item 15865Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}. 15866 15867@item 15868Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}. 15869 15870@item 15871Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0. 15872Command is @kbd{m p}. 15873 15874@item 15875Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar 15876mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode, 15877or @var{N} for 15878@texline @math{N\times N} 15879@infoline @var{N}x@var{N} 15880Matrix mode. Command is @kbd{m v}. 15881 15882@item 15883Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}), 158840 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E}, 15885or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes. 15886 15887@item 15888Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on, 15889or 0 if the mode is on with positive zeros. Command is @kbd{m i}. 15890@end enumerate 15891 15892For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the 15893precision by two, leaving a copy of the old precision on the stack. 15894Later, @kbd{~ p} will restore the original precision using that 15895stack value. (This sequence might be especially useful inside a 15896keyboard macro.) 15897 15898As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the 15899oldest (bottommost) stack entry. 15900 15901Yet another example: The HP-48 ``round'' command rounds a number 15902to the current displayed precision. You could roughly emulate this 15903in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This 15904would not work for fixed-point mode, but it wouldn't be hard to 15905do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]} 15906programming commands. @xref{Conditionals in Macros}.) 15907 15908@node Calc Mode Line, , Modes Variable, Mode Settings 15909@section The Calc Mode Line 15910 15911@noindent 15912@cindex Mode line indicators 15913This section is a summary of all symbols that can appear on the 15914Calc mode line, the highlighted bar that appears under the Calc 15915stack window (or under an editing window in Embedded mode). 15916 15917The basic mode line format is: 15918 15919@example 15920--%*-Calc: 12 Deg @var{other modes} (Calculator) 15921@end example 15922 15923The @samp{%*} indicates that the buffer is ``read-only''; it shows that 15924regular Emacs commands are not allowed to edit the stack buffer 15925as if it were text. 15926 15927The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode 15928is enabled. The words after this describe the various Calc modes 15929that are in effect. 15930 15931The first mode is always the current precision, an integer. 15932The second mode is always the angular mode, either @code{Deg}, 15933@code{Rad}, or @code{Hms}. 15934 15935Here is a complete list of the remaining symbols that can appear 15936on the mode line: 15937 15938@table @code 15939@item Alg 15940Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}). 15941 15942@item Alg[( 15943Incomplete algebraic mode (@kbd{C-u m a}). 15944 15945@item Alg* 15946Total algebraic mode (@kbd{m t}). 15947 15948@item Symb 15949Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}). 15950 15951@item Matrix 15952Matrix mode (@kbd{m v}; @pxref{Matrix Mode}). 15953 15954@item Matrix@var{n} 15955Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}). 15956 15957@item SqMatrix 15958Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}). 15959 15960@item Scalar 15961Scalar mode (@kbd{m v}; @pxref{Matrix Mode}). 15962 15963@item Polar 15964Polar complex mode (@kbd{m p}; @pxref{Polar Mode}). 15965 15966@item Frac 15967Fraction mode (@kbd{m f}; @pxref{Fraction Mode}). 15968 15969@item Inf 15970Infinite mode (@kbd{m i}; @pxref{Infinite Mode}). 15971 15972@item +Inf 15973Positive Infinite mode (@kbd{C-u 0 m i}). 15974 15975@item NoSimp 15976Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}). 15977 15978@item NumSimp 15979Default simplifications for numeric arguments only (@kbd{m N}). 15980 15981@item BinSimp@var{w} 15982Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}). 15983 15984@item BasicSimp 15985Basic simplification mode (@kbd{m I}). 15986 15987@item ExtSimp 15988Extended algebraic simplification mode (@kbd{m E}). 15989 15990@item UnitSimp 15991Units simplification mode (@kbd{m U}). 15992 15993@item Bin 15994Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}). 15995 15996@item Oct 15997Current radix is 8 (@kbd{d 8}). 15998 15999@item Hex 16000Current radix is 16 (@kbd{d 6}). 16001 16002@item Radix@var{n} 16003Current radix is @var{n} (@kbd{d r}). 16004 16005@item Zero 16006Leading zeros (@kbd{d z}; @pxref{Radix Modes}). 16007 16008@item Big 16009Big language mode (@kbd{d B}; @pxref{Normal Language Modes}). 16010 16011@item Flat 16012One-line normal language mode (@kbd{d O}). 16013 16014@item Unform 16015Unformatted language mode (@kbd{d U}). 16016 16017@item C 16018C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}). 16019 16020@item Pascal 16021Pascal language mode (@kbd{d P}). 16022 16023@item Fortran 16024FORTRAN language mode (@kbd{d F}). 16025 16026@item TeX 16027@TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}). 16028 16029@item LaTeX 16030@LaTeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}). 16031 16032@item Eqn 16033@dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}). 16034 16035@item Math 16036Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}). 16037 16038@item Maple 16039Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}). 16040 16041@item Norm@var{n} 16042Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}). 16043 16044@item Fix@var{n} 16045Fixed point mode with @var{n} digits after the point (@kbd{d f}). 16046 16047@item Sci 16048Scientific notation mode (@kbd{d s}). 16049 16050@item Sci@var{n} 16051Scientific notation with @var{n} digits (@kbd{d s}). 16052 16053@item Eng 16054Engineering notation mode (@kbd{d e}). 16055 16056@item Eng@var{n} 16057Engineering notation with @var{n} digits (@kbd{d e}). 16058 16059@item Left@var{n} 16060Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}). 16061 16062@item Right 16063Right-justified display (@kbd{d >}). 16064 16065@item Right@var{n} 16066Right-justified display with width @var{n} (@kbd{d >}). 16067 16068@item Center 16069Centered display (@kbd{d =}). 16070 16071@item Center@var{n} 16072Centered display with center column @var{n} (@kbd{d =}). 16073 16074@item Wid@var{n} 16075Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}). 16076 16077@item Wide 16078No line breaking (@kbd{d b}). 16079 16080@item Break 16081Selections show deep structure (@kbd{j b}; @pxref{Making Selections}). 16082 16083@item Save 16084Record modes in @file{~/.emacs.d/calc.el} (@kbd{m R}; @pxref{General Mode Commands}). 16085 16086@item Local 16087Record modes in Embedded buffer (@kbd{m R}). 16088 16089@item LocEdit 16090Record modes as editing-only in Embedded buffer (@kbd{m R}). 16091 16092@item LocPerm 16093Record modes as permanent-only in Embedded buffer (@kbd{m R}). 16094 16095@item Global 16096Record modes as global in Embedded buffer (@kbd{m R}). 16097 16098@item Manual 16099Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic 16100Recomputation}). 16101 16102@item Graph 16103GNUPLOT process is alive in background (@pxref{Graphics}). 16104 16105@item Sel 16106Top-of-stack has a selection (Embedded only; @pxref{Making Selections}). 16107 16108@item Dirty 16109The stack display may not be up-to-date (@pxref{Display Modes}). 16110 16111@item Inv 16112``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}). 16113 16114@item Hyp 16115``Hyperbolic'' prefix was pressed (@kbd{H}). 16116 16117@item Keep 16118``Keep-arguments'' prefix was pressed (@kbd{K}). 16119 16120@item Narrow 16121Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}). 16122@end table 16123 16124In addition, the symbols @code{Active} and @code{~Active} can appear 16125as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}. 16126 16127@node Arithmetic, Scientific Functions, Mode Settings, Top 16128@chapter Arithmetic Functions 16129 16130@noindent 16131This chapter describes the Calc commands for doing simple calculations 16132on numbers, such as addition, absolute value, and square roots. These 16133commands work by removing the top one or two values from the stack, 16134performing the desired operation, and pushing the result back onto the 16135stack. If the operation cannot be performed, the result pushed is a 16136formula instead of a number, such as @samp{2/0} (because division by zero 16137is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula). 16138 16139Most of the commands described here can be invoked by a single keystroke. 16140Some of the more obscure ones are two-letter sequences beginning with 16141the @kbd{f} (``functions'') prefix key. 16142 16143@xref{Prefix Arguments}, for a discussion of the effect of numeric 16144prefix arguments on commands in this chapter which do not otherwise 16145interpret a prefix argument. 16146 16147@menu 16148* Basic Arithmetic:: 16149* Integer Truncation:: 16150* Complex Number Functions:: 16151* Conversions:: 16152* Date Arithmetic:: 16153* Financial Functions:: 16154* Binary Functions:: 16155@end menu 16156 16157@node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic 16158@section Basic Arithmetic 16159 16160@noindent 16161@kindex + 16162@pindex calc-plus 16163@ignore 16164@mindex @null 16165@end ignore 16166@tindex + 16167The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may 16168be any of the standard Calc data types. The resulting sum is pushed back 16169onto the stack. 16170 16171If both arguments of @kbd{+} are vectors or matrices (of matching dimensions), 16172the result is a vector or matrix sum. If one argument is a vector and the 16173other a scalar (i.e., a non-vector), the scalar is added to each of the 16174elements of the vector to form a new vector. If the scalar is not a 16175number, the operation is left in symbolic form: Suppose you added @samp{x} 16176to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or 16177you may plan to substitute a 2-vector for @samp{x} in the future. Since 16178the Calculator can't tell which interpretation you want, it makes the 16179safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x} 16180to every element of a vector. 16181 16182If either argument of @kbd{+} is a complex number, the result will in general 16183be complex. If one argument is in rectangular form and the other polar, 16184the current Polar mode determines the form of the result. If Symbolic 16185mode is enabled, the sum may be left as a formula if the necessary 16186conversions for polar addition are non-trivial. 16187 16188If both arguments of @kbd{+} are HMS forms, the forms are added according to 16189the usual conventions of hours-minutes-seconds notation. If one argument 16190is an HMS form and the other is a number, that number is converted from 16191degrees or radians (depending on the current Angular mode) to HMS format 16192and then the two HMS forms are added. 16193 16194If one argument of @kbd{+} is a date form, the other can be either a 16195real number, which advances the date by a certain number of days, or 16196an HMS form, which advances the date by a certain amount of time. 16197Subtracting two date forms yields the number of days between them. 16198Adding two date forms is meaningless, but Calc interprets it as the 16199subtraction of one date form and the negative of the other. (The 16200negative of a date form can be understood by remembering that dates 16201are stored as the number of days before or after Jan 1, 1 AD.) 16202 16203If both arguments of @kbd{+} are error forms, the result is an error form 16204with an appropriately computed standard deviation. If one argument is an 16205error form and the other is a number, the number is taken to have zero error. 16206Error forms may have symbolic formulas as their mean and/or error parts; 16207adding these will produce a symbolic error form result. However, adding an 16208error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not 16209work, for the same reasons just mentioned for vectors. Instead you must 16210write @samp{(a +/- b) + (c +/- 0)}. 16211 16212If both arguments of @kbd{+} are modulo forms with equal values of @expr{M}, 16213or if one argument is a modulo form and the other a plain number, the 16214result is a modulo form which represents the sum, modulo @expr{M}, of 16215the two values. 16216 16217If both arguments of @kbd{+} are intervals, the result is an interval 16218which describes all possible sums of the possible input values. If 16219one argument is a plain number, it is treated as the interval 16220@w{@samp{[x ..@: x]}}. 16221 16222If one argument of @kbd{+} is an infinity and the other is not, the 16223result is that same infinity. If both arguments are infinite and in 16224the same direction, the result is the same infinity, but if they are 16225infinite in different directions the result is @code{nan}. 16226 16227@kindex - 16228@pindex calc-minus 16229@ignore 16230@mindex @null 16231@end ignore 16232@tindex - 16233The @kbd{-} (@code{calc-minus}) command subtracts two values. The top 16234number on the stack is subtracted from the one behind it, so that the 16235computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options 16236available for @kbd{+} are available for @kbd{-} as well. 16237 16238@kindex * 16239@pindex calc-times 16240@ignore 16241@mindex @null 16242@end ignore 16243@tindex * 16244The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one 16245argument is a vector and the other a scalar, the scalar is multiplied by 16246the elements of the vector to produce a new vector. If both arguments 16247are vectors, the interpretation depends on the dimensions of the 16248vectors: If both arguments are matrices, a matrix multiplication is 16249done. If one argument is a matrix and the other a plain vector, the 16250vector is interpreted as a row vector or column vector, whichever is 16251dimensionally correct. If both arguments are plain vectors, the result 16252is a single scalar number which is the dot product of the two vectors. 16253 16254If one argument of @kbd{*} is an HMS form and the other a number, the 16255HMS form is multiplied by that amount. It is an error to multiply two 16256HMS forms together, or to attempt any multiplication involving date 16257forms. Error forms, modulo forms, and intervals can be multiplied; 16258see the comments for addition of those forms. When two error forms 16259or intervals are multiplied they are considered to be statistically 16260independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]}, 16261whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}. 16262 16263@kindex / 16264@pindex calc-divide 16265@ignore 16266@mindex @null 16267@end ignore 16268@tindex / 16269The @kbd{/} (@code{calc-divide}) command divides two numbers. 16270 16271When combining multiplication and division in an algebraic formula, it 16272is good style to use parentheses to distinguish between possible 16273interpretations; the expression @samp{a/b*c} should be written 16274@samp{(a/b)*c} or @samp{a/(b*c)}, as appropriate. Without the 16275parentheses, Calc will interpret @samp{a/b*c} as @samp{a/(b*c)}, since 16276in algebraic entry Calc gives division a lower precedence than 16277multiplication. (This is not standard across all computer languages, and 16278Calc may change the precedence depending on the language mode being used. 16279@xref{Language Modes}.) This default ordering can be changed by setting 16280the customizable variable @code{calc-multiplication-has-precedence} to 16281@code{nil} (@pxref{Customizing Calc}); this will give multiplication and 16282division equal precedences. Note that Calc's default choice of 16283precedence allows @samp{a b / c d} to be used as a shortcut for 16284@smallexample 16285@group 16286a b 16287---. 16288c d 16289@end group 16290@end smallexample 16291 16292When dividing a scalar @expr{B} by a square matrix @expr{A}, the 16293computation performed is @expr{B} times the inverse of @expr{A}. This 16294also occurs if @expr{B} is itself a vector or matrix, in which case the 16295effect is to solve the set of linear equations represented by @expr{B}. 16296If @expr{B} is a matrix with the same number of rows as @expr{A}, or a 16297plain vector (which is interpreted here as a column vector), then the 16298equation @expr{A X = B} is solved for the vector or matrix @expr{X}. 16299Otherwise, if @expr{B} is a non-square matrix with the same number of 16300@emph{columns} as @expr{A}, the equation @expr{X A = B} is solved. If 16301you wish a vector @expr{B} to be interpreted as a row vector to be 16302solved as @expr{X A = B}, make it into a one-row matrix with @kbd{C-u 1 16303v p} first. To force a left-handed solution with a square matrix 16304@expr{B}, transpose @expr{A} and @expr{B} before dividing, then 16305transpose the result. 16306 16307HMS forms can be divided by real numbers or by other HMS forms. Error 16308forms can be divided in any combination of ways. Modulo forms where both 16309values and the modulo are integers can be divided to get an integer modulo 16310form result. Intervals can be divided; dividing by an interval that 16311encompasses zero or has zero as a limit will result in an infinite 16312interval. 16313 16314@kindex ^ 16315@pindex calc-power 16316@ignore 16317@mindex @null 16318@end ignore 16319@tindex ^ 16320The @kbd{^} (@code{calc-power}) command raises a number to a power. If 16321the power is an integer, an exact result is computed using repeated 16322multiplications. For non-integer powers, Calc uses Newton's method or 16323logarithms and exponentials. Square matrices can be raised to integer 16324powers. If either argument is an error (or interval or modulo) form, 16325the result is also an error (or interval or modulo) form. 16326 16327@kindex I ^ 16328@tindex nroot 16329If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command 16330computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5. 16331(This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.) 16332 16333@kindex \ 16334@pindex calc-idiv 16335@tindex idiv 16336@ignore 16337@mindex @null 16338@end ignore 16339@tindex \ 16340The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack 16341to produce an integer result. It is equivalent to dividing with 16342@kbd{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit 16343more convenient and efficient. Also, since it is an all-integer 16344operation when the arguments are integers, it avoids problems that 16345@kbd{/ F} would have with floating-point roundoff. 16346 16347@kindex % 16348@pindex calc-mod 16349@ignore 16350@mindex @null 16351@end ignore 16352@tindex % 16353The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'') 16354operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined 16355for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For 16356positive @expr{b}, the result will always be between 0 (inclusive) and 16357@expr{b} (exclusive). Modulo does not work for HMS forms and error forms. 16358If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which 16359must be positive real number. 16360 16361@kindex : 16362@pindex calc-fdiv 16363@tindex fdiv 16364The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command 16365divides the two integers on the top of the stack to produce a fractional 16366result. This is a convenient shorthand for enabling Fraction mode (with 16367@kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry 16368the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6 16369you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in 16370this case, it would be much easier simply to enter the fraction directly 16371as @kbd{8:6 @key{RET}}!) 16372 16373@kindex n 16374@pindex calc-change-sign 16375The @kbd{n} (@code{calc-change-sign}) command negates the number on the top 16376of the stack. It works on numbers, vectors and matrices, HMS forms, date 16377forms, error forms, intervals, and modulo forms. 16378 16379@kindex A 16380@pindex calc-abs 16381@tindex abs 16382The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute 16383value of a number. The result of @code{abs} is always a nonnegative 16384real number: With a complex argument, it computes the complex magnitude. 16385With a vector or matrix argument, it computes the Frobenius norm, i.e., 16386the square root of the sum of the squares of the absolute values of the 16387elements. The absolute value of an error form is defined by replacing 16388the mean part with its absolute value and leaving the error part the same. 16389The absolute value of a modulo form is undefined. The absolute value of 16390an interval is defined in the obvious way. 16391 16392@kindex f A 16393@pindex calc-abssqr 16394@tindex abssqr 16395The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the 16396absolute value squared of a number, vector or matrix, or error form. 16397 16398@kindex f s 16399@pindex calc-sign 16400@tindex sign 16401The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its 16402argument is positive, @mathit{-1} if its argument is negative, or 0 if its 16403argument is zero. In algebraic form, you can also write @samp{sign(a,x)} 16404which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or 16405zero depending on the sign of @samp{a}. 16406 16407@kindex & 16408@pindex calc-inv 16409@tindex inv 16410@cindex Reciprocal 16411The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the 16412reciprocal of a number, i.e., @expr{1 / x}. Operating on a square 16413matrix, it computes the inverse of that matrix. 16414 16415@kindex Q 16416@pindex calc-sqrt 16417@tindex sqrt 16418The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square 16419root of a number. For a negative real argument, the result will be a 16420complex number whose form is determined by the current Polar mode. 16421 16422@kindex f h 16423@pindex calc-hypot 16424@tindex hypot 16425The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square 16426root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)} 16427is the length of the hypotenuse of a right triangle with sides @expr{a} 16428and @expr{b}. If the arguments are complex numbers, their squared 16429magnitudes are used. 16430 16431@kindex f Q 16432@pindex calc-isqrt 16433@tindex isqrt 16434The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the 16435integer square root of an integer. This is the true square root of the 16436number, rounded down to an integer. For example, @samp{isqrt(10)} 16437produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact 16438integer arithmetic throughout to avoid roundoff problems. If the input 16439is a floating-point number or other non-integer value, this is exactly 16440the same as @samp{floor(sqrt(x))}. 16441 16442@kindex f n 16443@kindex f x 16444@pindex calc-min 16445@tindex min 16446@pindex calc-max 16447@tindex max 16448The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max}) 16449[@code{max}] commands take the minimum or maximum of two real numbers, 16450respectively. These commands also work on HMS forms, date forms, 16451intervals, and infinities. (In algebraic expressions, these functions 16452take any number of arguments and return the maximum or minimum among 16453all the arguments.) 16454 16455@kindex f M 16456@kindex f X 16457@pindex calc-mant-part 16458@tindex mant 16459@pindex calc-xpon-part 16460@tindex xpon 16461The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts 16462the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X} 16463(@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part 16464@expr{e}. The original number is equal to 16465@texline @math{m \times 10^e}, 16466@infoline @expr{m * 10^e}, 16467where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that 16468@expr{m=e=0} if the original number is zero. For integers 16469and fractions, @code{mant} returns the number unchanged and @code{xpon} 16470returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be 16471used to ``unpack'' a floating-point number; this produces an integer 16472mantissa and exponent, with the constraint that the mantissa is not 16473a multiple of ten (again except for the @expr{m=e=0} case). 16474 16475@kindex f S 16476@pindex calc-scale-float 16477@tindex scf 16478The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number 16479by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any 16480real @samp{x}. The second argument must be an integer, but the first 16481may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05} 16482or @samp{1:20} depending on the current Fraction mode. 16483 16484@kindex f [ 16485@kindex f ] 16486@pindex calc-decrement 16487@pindex calc-increment 16488@tindex decr 16489@tindex incr 16490The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]} 16491(@code{calc-increment}) [@code{incr}] functions decrease or increase 16492a number by one unit. For integers, the effect is obvious. For 16493floating-point numbers, the change is by one unit in the last place. 16494For example, incrementing @samp{12.3456} when the current precision 16495is 6 digits yields @samp{12.3457}. If the current precision had been 164968 digits, the result would have been @samp{12.345601}. Incrementing 16497@samp{0.0} produces 16498@texline @math{10^{-p}}, 16499@infoline @expr{10^-p}, 16500where @expr{p} is the current 16501precision. These operations are defined only on integers and floats. 16502With numeric prefix arguments, they change the number by @expr{n} units. 16503 16504Note that incrementing followed by decrementing, or vice-versa, will 16505almost but not quite always cancel out. Suppose the precision is 165066 digits and the number @samp{9.99999} is on the stack. Incrementing 16507will produce @samp{10.0000}; decrementing will produce @samp{9.9999}. 16508One digit has been dropped. This is an unavoidable consequence of the 16509way floating-point numbers work. 16510 16511Incrementing a date/time form adjusts it by a certain number of seconds. 16512Incrementing a pure date form adjusts it by a certain number of days. 16513 16514@node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic 16515@section Integer Truncation 16516 16517@noindent 16518There are four commands for truncating a real number to an integer, 16519differing mainly in their treatment of negative numbers. All of these 16520commands have the property that if the argument is an integer, the result 16521is the same integer. An integer-valued floating-point argument is converted 16522to integer form. 16523 16524If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be 16525expressed as an integer-valued floating-point number. 16526 16527@cindex Integer part of a number 16528@kindex F 16529@pindex calc-floor 16530@tindex floor 16531@tindex ffloor 16532@ignore 16533@mindex @null 16534@end ignore 16535@kindex H F 16536The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command 16537truncates a real number to the next lower integer, i.e., toward minus 16538infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces 16539@mathit{-4}. 16540 16541@kindex I F 16542@pindex calc-ceiling 16543@tindex ceil 16544@tindex fceil 16545@ignore 16546@mindex @null 16547@end ignore 16548@kindex H I F 16549The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}] 16550command truncates toward positive infinity. Thus @kbd{3.6 I F} produces 165514, and @kbd{_3.6 I F} produces @mathit{-3}. 16552 16553@kindex R 16554@pindex calc-round 16555@tindex round 16556@tindex fround 16557@ignore 16558@mindex @null 16559@end ignore 16560@kindex H R 16561The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command 16562rounds to the nearest integer. When the fractional part is .5 exactly, 16563this command rounds away from zero. (All other rounding in the 16564Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4 16565but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}. 16566 16567@kindex I R 16568@pindex calc-trunc 16569@tindex trunc 16570@tindex ftrunc 16571@ignore 16572@mindex @null 16573@end ignore 16574@kindex H I R 16575The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}] 16576command truncates toward zero. In other words, it ``chops off'' 16577everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and 16578@kbd{_3.6 I R} produces @mathit{-3}. 16579 16580These functions may not be applied meaningfully to error forms, but they 16581do work for intervals. As a convenience, applying @code{floor} to a 16582modulo form floors the value part of the form. Applied to a vector, 16583these functions operate on all elements of the vector one by one. 16584Applied to a date form, they operate on the internal numerical 16585representation of dates, converting a date/time form into a pure date. 16586 16587@ignore 16588@starindex 16589@end ignore 16590@tindex rounde 16591@ignore 16592@starindex 16593@end ignore 16594@tindex roundu 16595@ignore 16596@starindex 16597@end ignore 16598@tindex frounde 16599@ignore 16600@starindex 16601@end ignore 16602@tindex froundu 16603There are two more rounding functions which can only be entered in 16604algebraic notation. The @code{roundu} function is like @code{round} 16605except that it rounds up, toward plus infinity, when the fractional 16606part is .5. This distinction matters only for negative arguments. 16607Also, @code{rounde} rounds to an even number in the case of a tie, 16608rounding up or down as necessary. For example, @samp{rounde(3.5)} and 16609@samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6. 16610The advantage of round-to-even is that the net error due to rounding 16611after a long calculation tends to cancel out to zero. An important 16612subtle point here is that the number being fed to @code{rounde} will 16613already have been rounded to the current precision before @code{rounde} 16614begins. For example, @samp{rounde(2.500001)} with a current precision 16615of 6 will incorrectly, or at least surprisingly, yield 2 because the 16616argument will first have been rounded down to @expr{2.5} (which 16617@code{rounde} sees as an exact tie between 2 and 3). 16618 16619Each of these functions, when written in algebraic formulas, allows 16620a second argument which specifies the number of digits after the 16621decimal point to keep. For example, @samp{round(123.4567, 2)} will 16622produce the answer 123.46, and @samp{round(123.4567, -1)} will 16623produce 120 (i.e., the cutoff is one digit to the @emph{left} of 16624the decimal point). A second argument of zero is equivalent to 16625no second argument at all. 16626 16627@cindex Fractional part of a number 16628To compute the fractional part of a number (i.e., the amount which, when 16629added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n} 16630modulo 1 using the @code{%} command. 16631 16632Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm), 16633and @kbd{f Q} (integer square root) commands, which are analogous to 16634@kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer 16635arguments and return the result rounded down to an integer. 16636 16637@node Complex Number Functions, Conversions, Integer Truncation, Arithmetic 16638@section Complex Number Functions 16639 16640@noindent 16641@kindex J 16642@pindex calc-conj 16643@tindex conj 16644The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the 16645complex conjugate of a number. For complex number @expr{a+bi}, the 16646complex conjugate is @expr{a-bi}. If the argument is a real number, 16647this command leaves it the same. If the argument is a vector or matrix, 16648this command replaces each element by its complex conjugate. 16649 16650@kindex G 16651@pindex calc-argument 16652@tindex arg 16653The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the 16654``argument'' or polar angle of a complex number. For a number in polar 16655notation, this is simply the second component of the pair 16656@texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'. 16657@infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'. 16658The result is expressed according to the current angular mode and will 16659be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees 16660(inclusive), or the equivalent range in radians. 16661 16662@pindex calc-imaginary 16663The @code{calc-imaginary} command multiplies the number on the 16664top of the stack by the imaginary number @expr{i = (0,1)}. This 16665command is not normally bound to a key in Calc, but it is available 16666on the @key{IMAG} button in Keypad mode. 16667 16668@kindex f r 16669@pindex calc-re 16670@tindex re 16671The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number 16672by its real part. This command has no effect on real numbers. (As an 16673added convenience, @code{re} applied to a modulo form extracts 16674the value part.) 16675 16676@kindex f i 16677@pindex calc-im 16678@tindex im 16679The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number 16680by its imaginary part; real numbers are converted to zero. With a vector 16681or matrix argument, these functions operate element-wise. 16682 16683@ignore 16684@mindex v p 16685@end ignore 16686@kindex v p @r{(complex)} 16687@kindex V p @r{(complex)} 16688@pindex calc-pack 16689The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on 16690the stack into a composite object such as a complex number. With 16691a prefix argument of @mathit{-1}, it produces a rectangular complex number; 16692with an argument of @mathit{-2}, it produces a polar complex number. 16693(Also, @pxref{Building Vectors}.) 16694 16695@ignore 16696@mindex v u 16697@end ignore 16698@kindex v u @r{(complex)} 16699@kindex V u @r{(complex)} 16700@pindex calc-unpack 16701The @kbd{v u} (@code{calc-unpack}) command takes the complex number 16702(or other composite object) on the top of the stack and unpacks it 16703into its separate components. 16704 16705@node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic 16706@section Conversions 16707 16708@noindent 16709The commands described in this section convert numbers from one form 16710to another; they are two-key sequences beginning with the letter @kbd{c}. 16711 16712@kindex c f 16713@pindex calc-float 16714@tindex pfloat 16715The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the 16716number on the top of the stack to floating-point form. For example, 16717@expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to 16718@expr{1.5}, and @expr{2.3} is left the same. If the value is a composite 16719object such as a complex number or vector, each of the components is 16720converted to floating-point. If the value is a formula, all numbers 16721in the formula are converted to floating-point. Note that depending 16722on the current floating-point precision, conversion to floating-point 16723format may lose information. 16724 16725As a special exception, integers which appear as powers or subscripts 16726are not floated by @kbd{c f}. If you really want to float a power, 16727you can use a @kbd{j s} command to select the power followed by @kbd{c f}. 16728Because @kbd{c f} cannot examine the formula outside of the selection, 16729it does not notice that the thing being floated is a power. 16730@xref{Selecting Subformulas}. 16731 16732The normal @kbd{c f} command is ``pervasive'' in the sense that it 16733applies to all numbers throughout the formula. The @code{pfloat} 16734algebraic function never stays around in a formula; @samp{pfloat(a + 1)} 16735changes to @samp{a + 1.0} as soon as it is evaluated. 16736 16737@kindex H c f 16738@tindex float 16739With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates 16740only on the number or vector of numbers at the top level of its 16741argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)} 16742is left unevaluated because its argument is not a number. 16743 16744You should use @kbd{H c f} if you wish to guarantee that the final 16745value, once all the variables have been assigned, is a float; you 16746would use @kbd{c f} if you wish to do the conversion on the numbers 16747that appear right now. 16748 16749@kindex c F 16750@pindex calc-fraction 16751@tindex pfrac 16752The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a 16753floating-point number into a fractional approximation. By default, it 16754produces a fraction whose decimal representation is the same as the 16755input number, to within the current precision. You can also give a 16756numeric prefix argument to specify a tolerance, either directly, or, 16757if the prefix argument is zero, by using the number on top of the stack 16758as the tolerance. If the tolerance is a positive integer, the fraction 16759is correct to within that many significant figures. If the tolerance is 16760a non-positive integer, it specifies how many digits fewer than the current 16761precision to use. If the tolerance is a floating-point number, the 16762fraction is correct to within that absolute amount. 16763 16764@kindex H c F 16765@tindex frac 16766The @code{pfrac} function is pervasive, like @code{pfloat}. 16767There is also a non-pervasive version, @kbd{H c F} [@code{frac}], 16768which is analogous to @kbd{H c f} discussed above. 16769 16770@kindex c d 16771@pindex calc-to-degrees 16772@tindex deg 16773The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a 16774number into degrees form. The value on the top of the stack may be an 16775HMS form (interpreted as degrees-minutes-seconds), or a real number which 16776will be interpreted in radians regardless of the current angular mode. 16777 16778@kindex c r 16779@pindex calc-to-radians 16780@tindex rad 16781The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an 16782HMS form or angle in degrees into an angle in radians. 16783 16784@kindex c h 16785@pindex calc-to-hms 16786@tindex hms 16787The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real 16788number, interpreted according to the current angular mode, to an HMS 16789form describing the same angle. In algebraic notation, the @code{hms} 16790function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}. 16791(The three-argument version is independent of the current angular mode.) 16792 16793@pindex calc-from-hms 16794The @code{calc-from-hms} command converts the HMS form on the top of the 16795stack into a real number according to the current angular mode. 16796 16797@kindex c p 16798@kindex I c p 16799@pindex calc-polar 16800@tindex polar 16801@tindex rect 16802The @kbd{c p} (@code{calc-polar}) command converts the complex number on 16803the top of the stack from polar to rectangular form, or from rectangular 16804to polar form, whichever is appropriate. Real numbers are left the same. 16805This command is equivalent to the @code{rect} or @code{polar} 16806functions in algebraic formulas, depending on the direction of 16807conversion. (It uses @code{polar}, except that if the argument is 16808already a polar complex number, it uses @code{rect} instead. The 16809@kbd{I c p} command always uses @code{rect}.) 16810 16811@kindex c c 16812@pindex calc-clean 16813@tindex pclean 16814The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the 16815number on the top of the stack. Floating point numbers are re-rounded 16816according to the current precision. Polar numbers whose angular 16817components have strayed from the @mathit{-180} to @mathit{+180} degree range 16818are normalized. (Note that results will be undesirable if the current 16819angular mode is different from the one under which the number was 16820produced!) Integers and fractions are generally unaffected by this 16821operation. Vectors and formulas are cleaned by cleaning each component 16822number (i.e., pervasively). 16823 16824If the simplification mode is set below basic simplification, it is raised 16825for the purposes of this command. Thus, @kbd{c c} applies the basic 16826simplifications even if their automatic application is disabled. 16827@xref{Simplification Modes}. 16828 16829@cindex Roundoff errors, correcting 16830A numeric prefix argument to @kbd{c c} sets the floating-point precision 16831to that value for the duration of the command. A positive prefix (of at 16832least 3) sets the precision to the specified value; a negative or zero 16833prefix decreases the precision by the specified amount. 16834 16835@kindex c 0-9 16836@pindex calc-clean-num 16837The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent 16838to @kbd{c c} with the corresponding negative prefix argument. If roundoff 16839errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one 16840decimal place often conveniently does the trick. 16841 16842The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0} 16843through @kbd{c 9} commands, also ``clip'' very small floating-point 16844numbers to zero. If the exponent is less than or equal to the negative 16845of the specified precision, the number is changed to 0.0. For example, 16846if the current precision is 12, then @kbd{c 2} changes the vector 16847@samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}. 16848Numbers this small generally arise from roundoff noise. 16849 16850If the numbers you are using really are legitimately this small, 16851you should avoid using the @kbd{c 0} through @kbd{c 9} commands. 16852(The plain @kbd{c c} command rounds to the current precision but 16853does not clip small numbers.) 16854 16855One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with 16856a prefix argument, is that integer-valued floats are converted to 16857plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]} 16858produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge 16859numbers (@samp{1e100} is technically an integer-valued float, but 16860you wouldn't want it automatically converted to a 100-digit integer). 16861 16862@kindex H c 0-9 16863@kindex H c c 16864@tindex clean 16865With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9} 16866operate non-pervasively [@code{clean}]. 16867 16868@node Date Arithmetic, Financial Functions, Conversions, Arithmetic 16869@section Date Arithmetic 16870 16871@noindent 16872@cindex Date arithmetic, additional functions 16873The commands described in this section perform various conversions 16874and calculations involving date forms (@pxref{Date Forms}). They 16875use the @kbd{t} (for time/date) prefix key followed by shifted 16876letters. 16877 16878The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-} 16879commands. In particular, adding a number to a date form advances the 16880date form by a certain number of days; adding an HMS form to a date 16881form advances the date by a certain amount of time; and subtracting two 16882date forms produces a difference measured in days. The commands 16883described here provide additional, more specialized operations on dates. 16884 16885Many of these commands accept a numeric prefix argument; if you give 16886plain @kbd{C-u} as the prefix, these commands will instead take the 16887additional argument from the top of the stack. 16888 16889@menu 16890* Date Conversions:: 16891* Date Functions:: 16892* Time Zones:: 16893* Business Days:: 16894@end menu 16895 16896@node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic 16897@subsection Date Conversions 16898 16899@noindent 16900@kindex t D 16901@pindex calc-date 16902@tindex date 16903The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a 16904date form into a number, measured in days since Jan 1, 1 AD@. The 16905result will be an integer if @var{date} is a pure date form, or a 16906fraction or float if @var{date} is a date/time form. Or, if its 16907argument is a number, it converts this number into a date form. 16908 16909With a numeric prefix argument, @kbd{t D} takes that many objects 16910(up to six) from the top of the stack and interprets them in one 16911of the following ways: 16912 16913The @samp{date(@var{year}, @var{month}, @var{day})} function 16914builds a pure date form out of the specified year, month, and 16915day, which must all be integers. @var{Year} is a year number, 16916such as 1991 (@emph{not} the same as 91!). @var{Month} must be 16917an integer in the range 1 to 12; @var{day} must be in the range 169181 to 31. If the specified month has fewer than 31 days and 16919@var{day} is too large, the equivalent day in the following 16920month will be used. 16921 16922The @samp{date(@var{month}, @var{day})} function builds a 16923pure date form using the current year, as determined by the 16924real-time clock. 16925 16926The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})} 16927function builds a date/time form using an @var{hms} form. 16928 16929The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour}, 16930@var{minute}, @var{second})} function builds a date/time form. 16931@var{hour} should be an integer in the range 0 to 23; 16932@var{minute} should be an integer in the range 0 to 59; 16933@var{second} should be any real number in the range @samp{[0 .. 60)}. 16934The last two arguments default to zero if omitted. 16935 16936@kindex t J 16937@pindex calc-julian 16938@tindex julian 16939@cindex Julian day counts, conversions 16940The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts 16941a date form into a Julian day count, which is the number of days 16942since noon (GMT) on Jan 1, 4713 BC@. A pure date is converted to an 16943integer Julian count representing noon of that day. A date/time form 16944is converted to an exact floating-point Julian count, adjusted to 16945interpret the date form in the current time zone but the Julian 16946day count in Greenwich Mean Time. A numeric prefix argument allows 16947you to specify the time zone; @pxref{Time Zones}. Use a prefix of 16948zero to suppress the time zone adjustment. Note that pure date forms 16949are never time-zone adjusted. 16950 16951This command can also do the opposite conversion, from a Julian day 16952count (either an integer day, or a floating-point day and time in 16953the GMT zone), into a pure date form or a date/time form in the 16954current or specified time zone. 16955 16956@kindex t U 16957@pindex calc-unix-time 16958@tindex unixtime 16959@cindex Unix time format, conversions 16960The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command 16961converts a date form into a Unix time value, which is the number of 16962seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result 16963will be an integer if the current precision is 12 or less; for higher 16964precision, the result may be a float with (@var{precision}@minus{}12) 16965digits after the decimal. Just as for @kbd{t J}, the numeric time 16966is interpreted in the GMT time zone and the date form is interpreted 16967in the current or specified zone. Some systems use Unix-like 16968numbering but with the local time zone; give a prefix of zero to 16969suppress the adjustment if so. 16970 16971@kindex t C 16972@pindex calc-convert-time-zones 16973@tindex tzconv 16974@cindex Time Zones, converting between 16975The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}] 16976command converts a date form from one time zone to another. You 16977are prompted for each time zone name in turn; you can answer with 16978any suitable Calc time zone expression (@pxref{Time Zones}). 16979If you answer either prompt with a blank line, the local time 16980zone is used for that prompt. You can also answer the first 16981prompt with @kbd{$} to take the two time zone names from the 16982stack (and the date to be converted from the third stack level). 16983 16984@node Date Functions, Business Days, Date Conversions, Date Arithmetic 16985@subsection Date Functions 16986 16987@noindent 16988@kindex t N 16989@pindex calc-now 16990@tindex now 16991The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the 16992current date and time on the stack as a date form. The time is 16993reported in terms of the specified time zone; with no numeric prefix 16994argument, @kbd{t N} reports for the current time zone. 16995 16996@kindex t P 16997@pindex calc-date-part 16998The @kbd{t P} (@code{calc-date-part}) command extracts one part 16999of a date form. The prefix argument specifies the part; with no 17000argument, this command prompts for a part code from 1 to 9. 17001The various part codes are described in the following paragraphs. 17002 17003@tindex year 17004The @kbd{M-1 t P} [@code{year}] function extracts the year number 17005from a date form as an integer, e.g., 1991. This and the 17006following functions will also accept a real number for an 17007argument, which is interpreted as a standard Calc day number. 17008Note that this function will never return zero, since the year 170091 BC immediately precedes the year 1 AD. 17010 17011@tindex month 17012The @kbd{M-2 t P} [@code{month}] function extracts the month number 17013from a date form as an integer in the range 1 to 12. 17014 17015@tindex day 17016The @kbd{M-3 t P} [@code{day}] function extracts the day number 17017from a date form as an integer in the range 1 to 31. 17018 17019@tindex hour 17020The @kbd{M-4 t P} [@code{hour}] function extracts the hour from 17021a date form as an integer in the range 0 (midnight) to 23. Note 17022that 24-hour time is always used. This returns zero for a pure 17023date form. This function (and the following two) also accept 17024HMS forms as input. 17025 17026@tindex minute 17027The @kbd{M-5 t P} [@code{minute}] function extracts the minute 17028from a date form as an integer in the range 0 to 59. 17029 17030@tindex second 17031The @kbd{M-6 t P} [@code{second}] function extracts the second 17032from a date form. If the current precision is 12 or less, 17033the result is an integer in the range 0 to 59. For higher 17034precision, the result may instead be a floating-point number. 17035 17036@tindex weekday 17037The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday 17038number from a date form as an integer in the range 0 (Sunday) 17039to 6 (Saturday). 17040 17041@tindex yearday 17042The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year 17043number from a date form as an integer in the range 1 (January 1) 17044to 366 (December 31 of a leap year). 17045 17046@tindex time 17047The @kbd{M-9 t P} [@code{time}] function extracts the time portion 17048of a date form as an HMS form. This returns @samp{0@@ 0' 0"} 17049for a pure date form. 17050 17051@kindex t M 17052@pindex calc-new-month 17053@tindex newmonth 17054The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command 17055computes a new date form that represents the first day of the month 17056specified by the input date. The result is always a pure date 17057form; only the year and month numbers of the input are retained. 17058With a numeric prefix argument @var{n} in the range from 1 to 31, 17059@kbd{t M} computes the @var{n}th day of the month. (If @var{n} 17060is greater than the actual number of days in the month, or if 17061@var{n} is zero, the last day of the month is used.) 17062 17063@kindex t Y 17064@pindex calc-new-year 17065@tindex newyear 17066The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command 17067computes a new pure date form that represents the first day of 17068the year specified by the input. The month, day, and time 17069of the input date form are lost. With a numeric prefix argument 17070@var{n} in the range from 1 to 366, @kbd{t Y} computes the 17071@var{n}th day of the year (366 is treated as 365 in non-leap 17072years). A prefix argument of 0 computes the last day of the 17073year (December 31). A negative prefix argument from @mathit{-1} to 17074@mathit{-12} computes the first day of the @var{n}th month of the year. 17075 17076@kindex t W 17077@pindex calc-new-week 17078@tindex newweek 17079The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command 17080computes a new pure date form that represents the Sunday on or before 17081the input date. With a numeric prefix argument, it can be made to 17082use any day of the week as the starting day; the argument must be in 17083the range from 0 (Sunday) to 6 (Saturday). This function always 17084subtracts between 0 and 6 days from the input date. 17085 17086Here's an example use of @code{newweek}: Find the date of the next 17087Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)} 17088will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)} 17089will give you the following Wednesday. A further look at the definition 17090of @code{newweek} shows that if the input date is itself a Wednesday, 17091this formula will return the Wednesday one week in the future. An 17092exercise for the reader is to modify this formula to yield the same day 17093if the input is already a Wednesday. Another interesting exercise is 17094to preserve the time-of-day portion of the input (@code{newweek} resets 17095the time to midnight; hint: how can @code{newweek} be defined in terms 17096of the @code{weekday} function?). 17097 17098@ignore 17099@starindex 17100@end ignore 17101@tindex pwday 17102The @samp{pwday(@var{date})} function (not on any key) computes the 17103day-of-month number of the Sunday on or before @var{date}. With 17104two arguments, @samp{pwday(@var{date}, @var{day})} computes the day 17105number of the Sunday on or before day number @var{day} of the month 17106specified by @var{date}. The @var{day} must be in the range from 171077 to 31; if the day number is greater than the actual number of days 17108in the month, the true number of days is used instead. Thus 17109@samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and 17110@samp{pwday(@var{date}, 31)} finds the last Sunday of the month. 17111With a third @var{weekday} argument, @code{pwday} can be made to look 17112for any day of the week instead of Sunday. 17113 17114@kindex t I 17115@pindex calc-inc-month 17116@tindex incmonth 17117The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command 17118increases a date form by one month, or by an arbitrary number of 17119months specified by a numeric prefix argument. The time portion, 17120if any, of the date form stays the same. The day also stays the 17121same, except that if the new month has fewer days the day 17122number may be reduced to lie in the valid range. For example, 17123@samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}. 17124Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give 17125the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>} 17126in this case). 17127 17128@ignore 17129@starindex 17130@end ignore 17131@tindex incyear 17132The @samp{incyear(@var{date}, @var{step})} function increases 17133a date form by the specified number of years, which may be 17134any positive or negative integer. Note that @samp{incyear(d, n)} 17135is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have 17136simple equivalents in terms of day arithmetic because 17137months and years have varying lengths. If the @var{step} 17138argument is omitted, 1 year is assumed. There is no keyboard 17139command for this function; use @kbd{C-u 12 t I} instead. 17140 17141There is no @code{newday} function at all because @kbd{F} [@code{floor}] 17142serves this purpose. Similarly, instead of @code{incday} and 17143@code{incweek} simply use @expr{d + n} or @expr{d + 7 n}. 17144 17145@xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command 17146which can adjust a date/time form by a certain number of seconds. 17147 17148@node Business Days, Time Zones, Date Functions, Date Arithmetic 17149@subsection Business Days 17150 17151@noindent 17152Often time is measured in ``business days'' or ``working days,'' 17153where weekends and holidays are skipped. Calc's normal date 17154arithmetic functions use calendar days, so that subtracting two 17155consecutive Mondays will yield a difference of 7 days. By contrast, 17156subtracting two consecutive Mondays would yield 5 business days 17157(assuming two-day weekends and the absence of holidays). 17158 17159@kindex t + 17160@kindex t - 17161@tindex badd 17162@tindex bsub 17163@pindex calc-business-days-plus 17164@pindex calc-business-days-minus 17165The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}] 17166and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}] 17167commands perform arithmetic using business days. For @kbd{t +}, 17168one argument must be a date form and the other must be a real 17169number (positive or negative). If the number is not an integer, 17170then a certain amount of time is added as well as a number of 17171days; for example, adding 0.5 business days to a time in Friday 17172evening will produce a time in Monday morning. It is also 17173possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds 17174half a business day. For @kbd{t -}, the arguments are either a 17175date form and a number or HMS form, or two date forms, in which 17176case the result is the number of business days between the two 17177dates. 17178 17179@cindex @code{Holidays} variable 17180@vindex Holidays 17181By default, Calc considers any day that is not a Saturday or 17182Sunday to be a business day. You can define any number of 17183additional holidays by editing the variable @code{Holidays}. 17184(There is an @w{@kbd{s H}} convenience command for editing this 17185variable.) Initially, @code{Holidays} contains the vector 17186@samp{[sat, sun]}. Entries in the @code{Holidays} vector may 17187be any of the following kinds of objects: 17188 17189@itemize @bullet 17190@item 17191Date forms (pure dates, not date/time forms). These specify 17192particular days which are to be treated as holidays. 17193 17194@item 17195Intervals of date forms. These specify a range of days, all of 17196which are holidays (e.g., Christmas week). @xref{Interval Forms}. 17197 17198@item 17199Nested vectors of date forms. Each date form in the vector is 17200considered to be a holiday. 17201 17202@item 17203Any Calc formula which evaluates to one of the above three things. 17204If the formula involves the variable @expr{y}, it stands for a 17205yearly repeating holiday; @expr{y} will take on various year 17206numbers like 1992. For example, @samp{date(y, 12, 25)} specifies 17207Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies 17208Thanksgiving (which is held on the fourth Thursday of November). 17209If the formula involves the variable @expr{m}, that variable 17210takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is 17211a holiday that takes place on the 15th of every month. 17212 17213@item 17214A weekday name, such as @code{sat} or @code{sun}. This is really 17215a variable whose name is a three-letter, lower-case day name. 17216 17217@item 17218An interval of year numbers (integers). This specifies the span of 17219years over which this holiday list is to be considered valid. Any 17220business-day arithmetic that goes outside this range will result 17221in an error message. Use this if you are including an explicit 17222list of holidays, rather than a formula to generate them, and you 17223want to make sure you don't accidentally go beyond the last point 17224where the holidays you entered are complete. If there is no 17225limiting interval in the @code{Holidays} vector, the default 17226@samp{[1 .. 2737]} is used. (This is the absolute range of years 17227for which Calc's business-day algorithms will operate.) 17228 17229@item 17230An interval of HMS forms. This specifies the span of hours that 17231are to be considered one business day. For example, if this 17232range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then 17233the business day is only eight hours long, so that @kbd{1.5 t +} 17234on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and 17235four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}. 17236Likewise, @kbd{t -} will now express differences in time as 17237fractions of an eight-hour day. Times before 9am will be treated 17238as 9am by business date arithmetic, and times at or after 5pm will 17239be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays}, 17240the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed. 17241(Regardless of the type of bounds you specify, the interval is 17242treated as inclusive on the low end and exclusive on the high end, 17243so that the work day goes from 9am up to, but not including, 5pm.) 17244@end itemize 17245 17246If the @code{Holidays} vector is empty, then @kbd{t +} and 17247@kbd{t -} will act just like @kbd{+} and @kbd{-} because there will 17248then be no difference between business days and calendar days. 17249 17250Calc expands the intervals and formulas you give into a complete 17251list of holidays for internal use. This is done mainly to make 17252sure it can detect multiple holidays. (For example, 17253@samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but 17254Calc's algorithms take care to count it only once when figuring 17255the number of holidays between two dates.) 17256 17257Since the complete list of holidays for all the years from 1 to 172582737 would be huge, Calc actually computes only the part of the 17259list between the smallest and largest years that have been involved 17260in business-day calculations so far. Normally, you won't have to 17261worry about this. Keep in mind, however, that if you do one 17262calculation for 1992, and another for 1792, even if both involve 17263only a small range of years, Calc will still work out all the 17264holidays that fall in that 200-year span. 17265 17266If you add a (positive) number of days to a date form that falls on a 17267weekend or holiday, the date form is treated as if it were the most 17268recent business day. (Thus adding one business day to a Friday, 17269Saturday, or Sunday will all yield the following Monday.) If you 17270subtract a number of days from a weekend or holiday, the date is 17271effectively on the following business day. (So subtracting one business 17272day from Saturday, Sunday, or Monday yields the preceding Friday.) The 17273difference between two dates one or both of which fall on holidays 17274equals the number of actual business days between them. These 17275conventions are consistent in the sense that, if you add @var{n} 17276business days to any date, the difference between the result and the 17277original date will come out to @var{n} business days. (It can't be 17278completely consistent though; a subtraction followed by an addition 17279might come out a bit differently, since @kbd{t +} is incapable of 17280producing a date that falls on a weekend or holiday.) 17281 17282@ignore 17283@starindex 17284@end ignore 17285@tindex holiday 17286There is a @code{holiday} function, not on any keys, that takes 17287any date form and returns 1 if that date falls on a weekend or 17288holiday, as defined in @code{Holidays}, or 0 if the date is a 17289business day. 17290 17291@node Time Zones, , Business Days, Date Arithmetic 17292@subsection Time Zones 17293 17294@noindent 17295@cindex Time zones 17296@cindex Daylight saving time 17297Time zones and daylight saving time are a complicated business. 17298The conversions to and from Julian and Unix-style dates automatically 17299compute the correct time zone and daylight saving adjustment to use, 17300provided they can figure out this information. This section describes 17301Calc's time zone adjustment algorithm in detail, in case you want to 17302do conversions in different time zones or in case Calc's algorithms 17303can't determine the right correction to use. 17304 17305Adjustments for time zones and daylight saving time are done by 17306@kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other 17307commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates 17308to exactly 30 days even though there is a daylight-saving 17309transition in between. This is also true for Julian pure dates: 17310@samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian 17311and Unix date/times will adjust for daylight saving time: using Calc's 17312default daylight saving time rule (see the explanation below), 17313@samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)} 17314evaluates to @samp{29.95833} (that's 29 days and 23 hours) 17315because one hour was lost when daylight saving commenced on 17316April 7, 1991. 17317 17318In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})} 17319computes the actual number of 24-hour periods between two dates, whereas 17320@samp{@var{date1} - @var{date2}} computes the number of calendar 17321days between two dates without taking daylight saving into account. 17322 17323@pindex calc-time-zone 17324@ignore 17325@starindex 17326@end ignore 17327@tindex tzone 17328The @code{calc-time-zone} [@code{tzone}] command converts the time 17329zone specified by its numeric prefix argument into a number of 17330seconds difference from Greenwich mean time (GMT). If the argument 17331is a number, the result is simply that value multiplied by 3600. 17332Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If 17333Daylight Saving time is in effect, one hour should be subtracted from 17334the normal difference. 17335 17336If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other 17337date arithmetic commands that include a time zone argument) takes the 17338zone argument from the top of the stack. (In the case of @kbd{t J} 17339and @kbd{t U}, the normal argument is then taken from the second-to-top 17340stack position.) This allows you to give a non-integer time zone 17341adjustment. The time-zone argument can also be an HMS form, or 17342it can be a variable which is a time zone name in upper- or lower-case. 17343For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)} 17344(for Pacific standard and daylight saving times, respectively). 17345 17346North American and European time zone names are defined as follows; 17347note that for each time zone there is one name for standard time, 17348another for daylight saving time, and a third for ``generalized'' time 17349in which the daylight saving adjustment is computed from context. 17350 17351@smallexample 17352@group 17353YST PST MST CST EST AST NST GMT WET MET MEZ 17354 9 8 7 6 5 4 3.5 0 -1 -2 -2 17355 17356YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ 17357 8 7 6 5 4 3 2.5 -1 -2 -3 -3 17358 17359YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ 173609/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3 17361@end group 17362@end smallexample 17363 17364@vindex math-tzone-names 17365To define time zone names that do not appear in the above table, 17366you must modify the Lisp variable @code{math-tzone-names}. This 17367is a list of lists describing the different time zone names; its 17368structure is best explained by an example. The three entries for 17369Pacific Time look like this: 17370 17371@smallexample 17372@group 17373( ( "PST" 8 0 ) ; Name as an upper-case string, then standard 17374 ( "PDT" 8 -1 ) ; adjustment, then daylight saving adjustment. 17375 ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone. 17376@end group 17377@end smallexample 17378 17379@cindex @code{TimeZone} variable 17380@vindex TimeZone 17381With no arguments, @code{calc-time-zone} or @samp{tzone()} will by 17382default get the time zone and daylight saving information from the 17383calendar (@pxref{Daylight Saving,Calendar/Diary,The Calendar and the Diary, 17384emacs,The GNU Emacs Manual}). To use a different time zone, or if the 17385calendar does not give the desired result, you can set the Calc variable 17386@code{TimeZone} (which is by default @code{nil}) to an appropriate 17387time zone name. (The easiest way to do this is to edit the 17388@code{TimeZone} variable using Calc's @kbd{s T} command, then use the 17389@kbd{s p} (@code{calc-permanent-variable}) command to save the value of 17390@code{TimeZone} permanently.) 17391If the time zone given by @code{TimeZone} is a generalized time zone, 17392e.g., @code{EGT}, Calc examines the date being converted to tell whether 17393to use standard or daylight saving time. But if the current time zone 17394is explicit, e.g., @code{EST} or @code{EDT}, then that adjustment is 17395used exactly and Calc's daylight saving algorithm is not consulted. 17396The special time zone name @code{local} 17397is equivalent to no argument; i.e., it uses the information obtained 17398from the calendar. 17399 17400The @kbd{t J} and @code{t U} commands with no numeric prefix 17401arguments do the same thing as @samp{tzone()}; namely, use the 17402information from the calendar if @code{TimeZone} is @code{nil}, 17403otherwise use the time zone given by @code{TimeZone}. 17404 17405@vindex math-daylight-savings-hook 17406@findex math-std-daylight-savings 17407When Calc computes the daylight saving information itself (i.e., when 17408the @code{TimeZone} variable is set), it will by default consider 17409daylight saving time to begin at 2 a.m.@: on the second Sunday of March 17410(for years from 2007 on) or on the last Sunday in April (for years 17411before 2007), and to end at 2 a.m.@: on the first Sunday of 17412November. (for years from 2007 on) or the last Sunday in October (for 17413years before 2007). These are the rules that have been in effect in 17414much of North America since 1966 and take into account the rule change 17415that began in 2007. If you are in a country that uses different rules 17416for computing daylight saving time, you have two choices: Write your own 17417daylight saving hook, or control time zones explicitly by setting the 17418@code{TimeZone} variable and/or always giving a time-zone argument for 17419the conversion functions. 17420 17421The Lisp variable @code{math-daylight-savings-hook} holds the 17422name of a function that is used to compute the daylight saving 17423adjustment for a given date. The default is 17424@code{math-std-daylight-savings}, which computes an adjustment 17425(either 0 or @mathit{-1}) using the North American rules given above. 17426 17427The daylight saving hook function is called with four arguments: 17428The date, as a floating-point number in standard Calc format; 17429a six-element list of the date decomposed into year, month, day, 17430hour, minute, and second, respectively; a string which contains 17431the generalized time zone name in upper-case, e.g., @code{"WEGT"}; 17432and a special adjustment to be applied to the hour value when 17433converting into a generalized time zone (see below). 17434 17435@findex math-prev-weekday-in-month 17436The Lisp function @code{math-prev-weekday-in-month} is useful for 17437daylight saving computations. This is an internal version of 17438the user-level @code{pwday} function described in the previous 17439section. It takes four arguments: The floating-point date value, 17440the corresponding six-element date list, the day-of-month number, 17441and the weekday number (0--6). 17442 17443The default daylight saving hook ignores the time zone name, but a 17444more sophisticated hook could use different algorithms for different 17445time zones. It would also be possible to use different algorithms 17446depending on the year number, but the default hook always uses the 17447algorithm for 1987 and later. Here is a listing of the default 17448daylight saving hook: 17449 17450@smallexample 17451(defun math-std-daylight-savings (date dt zone bump) 17452 (cond ((< (nth 1 dt) 4) 0) 17453 ((= (nth 1 dt) 4) 17454 (let ((sunday (math-prev-weekday-in-month date dt 7 0))) 17455 (cond ((< (nth 2 dt) sunday) 0) 17456 ((= (nth 2 dt) sunday) 17457 (if (>= (nth 3 dt) (+ 3 bump)) -1 0)) 17458 (t -1)))) 17459 ((< (nth 1 dt) 10) -1) 17460 ((= (nth 1 dt) 10) 17461 (let ((sunday (math-prev-weekday-in-month date dt 31 0))) 17462 (cond ((< (nth 2 dt) sunday) -1) 17463 ((= (nth 2 dt) sunday) 17464 (if (>= (nth 3 dt) (+ 2 bump)) 0 -1)) 17465 (t 0)))) 17466 (t 0)) 17467) 17468@end smallexample 17469 17470@noindent 17471The @code{bump} parameter is equal to zero when Calc is converting 17472from a date form in a generalized time zone into a GMT date value. 17473It is @mathit{-1} when Calc is converting in the other direction. The 17474adjustments shown above ensure that the conversion behaves correctly 17475and reasonably around the 2 a.m.@: transition in each direction. 17476 17477There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the 17478beginning of daylight saving time; converting a date/time form that 17479falls in this hour results in a time value for the following hour, 17480from 3 a.m.@: to 4 a.m. At the end of daylight saving time, the 17481hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time 17482form that falls in this hour results in a time value for the first 17483manifestation of that time (@emph{not} the one that occurs one hour 17484later). 17485 17486If @code{math-daylight-savings-hook} is @code{nil}, then the 17487daylight saving adjustment is always taken to be zero. 17488 17489In algebraic formulas, @samp{tzone(@var{zone}, @var{date})} 17490computes the time zone adjustment for a given zone name at a 17491given date. The @var{date} is ignored unless @var{zone} is a 17492generalized time zone. If @var{date} is a date form, the 17493daylight saving computation is applied to it as it appears. 17494If @var{date} is a numeric date value, it is adjusted for the 17495daylight-saving version of @var{zone} before being given to 17496the daylight saving hook. This odd-sounding rule ensures 17497that the daylight-saving computation is always done in 17498local time, not in the GMT time that a numeric @var{date} 17499is typically represented in. 17500 17501@ignore 17502@starindex 17503@end ignore 17504@tindex dsadj 17505The @samp{dsadj(@var{date}, @var{zone})} function computes the 17506daylight saving adjustment that is appropriate for @var{date} in 17507time zone @var{zone}. If @var{zone} is explicitly in or not in 17508daylight saving time (e.g., @code{PDT} or @code{PST}) the 17509@var{date} is ignored. If @var{zone} is a generalized time zone, 17510the algorithms described above are used. If @var{zone} is omitted, 17511the computation is done for the current time zone. 17512 17513@node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic 17514@section Financial Functions 17515 17516@noindent 17517Calc's financial or business functions use the @kbd{b} prefix 17518key followed by a shifted letter. (The @kbd{b} prefix followed by 17519a lower-case letter is used for operations on binary numbers.) 17520 17521Note that the rate and the number of intervals given to these 17522functions must be on the same time scale, e.g., both months or 17523both years. Mixing an annual interest rate with a time expressed 17524in months will give you very wrong answers! 17525 17526It is wise to compute these functions to a higher precision than 17527you really need, just to make sure your answer is correct to the 17528last penny; also, you may wish to check the definitions at the end 17529of this section to make sure the functions have the meaning you expect. 17530 17531@menu 17532* Percentages:: 17533* Future Value:: 17534* Present Value:: 17535* Related Financial Functions:: 17536* Depreciation Functions:: 17537* Definitions of Financial Functions:: 17538@end menu 17539 17540@node Percentages, Future Value, Financial Functions, Financial Functions 17541@subsection Percentages 17542 17543@kindex M-% 17544@pindex calc-percent 17545@tindex % 17546@tindex percent 17547The @kbd{M-%} (@code{calc-percent}) command takes a percentage value, 17548say 5.4, and converts it to an equivalent actual number. For example, 17549@kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or 17550@key{ESC} key combined with @kbd{%}.) 17551 17552Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}. 17553You can enter @samp{5.4%} yourself during algebraic entry. The 17554@samp{%} operator simply means, ``the preceding value divided by 17555100.'' The @samp{%} operator has very high precedence, so that 17556@samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}. 17557(The @samp{%} operator is just a postfix notation for the 17558@code{percent} function, just like @samp{20!} is the notation for 17559@samp{fact(20)}, or twenty-factorial.) 17560 17561The formula @samp{5.4%} would normally evaluate immediately to 175620.054, but the @kbd{M-%} command suppresses evaluation as it puts 17563the formula onto the stack. However, the next Calc command that 17564uses the formula @samp{5.4%} will evaluate it as its first step. 17565The net effect is that you get to look at @samp{5.4%} on the stack, 17566but Calc commands see it as @samp{0.054}, which is what they expect. 17567 17568In particular, @samp{5.4%} and @samp{0.054} are suitable values 17569for the @var{rate} arguments of the various financial functions, 17570but the number @samp{5.4} is probably @emph{not} suitable---it 17571represents a rate of 540 percent! 17572 17573The key sequence @kbd{M-% *} effectively means ``percent-of.'' 17574For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of 1757568 (and also 68% of 25, which comes out to the same thing). 17576 17577@kindex c % 17578@pindex calc-convert-percent 17579The @kbd{c %} (@code{calc-convert-percent}) command converts the 17580value on the top of the stack from numeric to percentage form. 17581For example, if 0.08 is on the stack, @kbd{c %} converts it to 17582@samp{8%}. The quantity is the same, it's just represented 17583differently. (Contrast this with @kbd{M-%}, which would convert 17584this number to @samp{0.08%}.) The @kbd{=} key is a convenient way 17585to convert a formula like @samp{8%} back to numeric form, 0.08. 17586 17587To compute what percentage one quantity is of another quantity, 17588use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays 17589@samp{25%}. 17590 17591@kindex b % 17592@pindex calc-percent-change 17593@tindex relch 17594The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command 17595calculates the percentage change from one number to another. 17596For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%}, 17597since 50 is 25% larger than 40. A negative result represents a 17598decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is 1759920% smaller than 50. (The answers are different in magnitude 17600because, in the first case, we're increasing by 25% of 40, but 17601in the second case, we're decreasing by 20% of 50.) The effect 17602of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting 17603the answer to percentage form as if by @kbd{c %}. 17604 17605@node Future Value, Present Value, Percentages, Financial Functions 17606@subsection Future Value 17607 17608@noindent 17609@kindex b F 17610@pindex calc-fin-fv 17611@tindex fv 17612The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes 17613the future value of an investment. It takes three arguments 17614from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}. 17615If you give payments of @var{payment} every year for @var{n} 17616years, and the money you have paid earns interest at @var{rate} per 17617year, then this function tells you what your investment would be 17618worth at the end of the period. (The actual interval doesn't 17619have to be years, as long as @var{n} and @var{rate} are expressed 17620in terms of the same intervals.) This function assumes payments 17621occur at the @emph{end} of each interval. 17622 17623@kindex I b F 17624@tindex fvb 17625The @kbd{I b F} [@code{fvb}] command does the same computation, 17626but assuming your payments are at the beginning of each interval. 17627Suppose you plan to deposit $1000 per year in a savings account 17628earning 5.4% interest, starting right now. How much will be 17629in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}. 17630Thus you will have earned $870 worth of interest over the years. 17631Using the stack, this calculation would have been 17632@kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed 17633as a number between 0 and 1, @emph{not} as a percentage. 17634 17635@kindex H b F 17636@tindex fvl 17637The @kbd{H b F} [@code{fvl}] command computes the future value 17638of an initial lump sum investment. Suppose you could deposit 17639those five thousand dollars in the bank right now; how much would 17640they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}. 17641 17642The algebraic functions @code{fv} and @code{fvb} accept an optional 17643fourth argument, which is used as an initial lump sum in the sense 17644of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n}, 17645@var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment}) 17646+ fvl(@var{rate}, @var{n}, @var{initial})}. 17647 17648To illustrate the relationships between these functions, we could 17649do the @code{fvb} calculation ``by hand'' using @code{fvl}. The 17650final balance will be the sum of the contributions of our five 17651deposits at various times. The first deposit earns interest for 17652five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second 17653deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) = 176541234.13}. And so on down to the last deposit, which earns one 17655year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of 17656these five values is, sure enough, $5870.73, just as was computed 17657by @code{fvb} directly. 17658 17659What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments 17660are now at the ends of the periods. The end of one year is the same 17661as the beginning of the next, so what this really means is that we've 17662lost the payment at year zero (which contributed $1300.78), but we're 17663now counting the payment at year five (which, since it didn't have 17664a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 = 176655870.73 - 1300.78 + 1000} (give or take a bit of roundoff error). 17666 17667@node Present Value, Related Financial Functions, Future Value, Financial Functions 17668@subsection Present Value 17669 17670@noindent 17671@kindex b P 17672@pindex calc-fin-pv 17673@tindex pv 17674The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes 17675the present value of an investment. Like @code{fv}, it takes 17676three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}. 17677It computes the present value of a series of regular payments. 17678Suppose you have the chance to make an investment that will 17679pay $2000 per year over the next four years; as you receive 17680these payments you can put them in the bank at 9% interest. 17681You want to know whether it is better to make the investment, or 17682to keep the money in the bank where it earns 9% interest right 17683from the start. The calculation @code{pv(9%, 4, 2000)} gives the 17684result 6479.44. If your initial investment must be less than this, 17685say, $6000, then the investment is worthwhile. But if you had to 17686put up $7000, then it would be better just to leave it in the bank. 17687 17688Here is the interpretation of the result of @code{pv}: You are 17689trying to compare the return from the investment you are 17690considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with 17691the return from leaving the money in the bank, which is 17692@code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money 17693you would have to put up in advance. The @code{pv} function 17694finds the break-even point, @expr{x = 6479.44}, at which 17695@code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is 17696the largest amount you should be willing to invest. 17697 17698@kindex I b P 17699@tindex pvb 17700The @kbd{I b P} [@code{pvb}] command solves the same problem, 17701but with payments occurring at the beginning of each interval. 17702It has the same relationship to @code{fvb} as @code{pv} has 17703to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59}, 17704a larger number than @code{pv} produced because we get to start 17705earning interest on the return from our investment sooner. 17706 17707@kindex H b P 17708@tindex pvl 17709The @kbd{H b P} [@code{pvl}] command computes the present value of 17710an investment that will pay off in one lump sum at the end of the 17711period. For example, if we get our $8000 all at the end of the 17712four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much 17713less than @code{pv} reported, because we don't earn any interest 17714on the return from this investment. Note that @code{pvl} and 17715@code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}. 17716 17717You can give an optional fourth lump-sum argument to @code{pv} 17718and @code{pvb}; this is handled in exactly the same way as the 17719fourth argument for @code{fv} and @code{fvb}. 17720 17721@kindex b N 17722@pindex calc-fin-npv 17723@tindex npv 17724The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes 17725the net present value of a series of irregular investments. 17726The first argument is the interest rate. The second argument is 17727a vector which represents the expected return from the investment 17728at the end of each interval. For example, if the rate represents 17729a yearly interest rate, then the vector elements are the return 17730from the first year, second year, and so on. 17731 17732Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}. 17733Obviously this function is more interesting when the payments are 17734not all the same! 17735 17736The @code{npv} function can actually have two or more arguments. 17737Multiple arguments are interpreted in the same way as for the 17738vector statistical functions like @code{vsum}. 17739@xref{Single-Variable Statistics}. Basically, if there are several 17740payment arguments, each either a vector or a plain number, all these 17741values are collected left-to-right into the complete list of payments. 17742A numeric prefix argument on the @kbd{b N} command says how many 17743payment values or vectors to take from the stack. 17744 17745@kindex I b N 17746@tindex npvb 17747The @kbd{I b N} [@code{npvb}] command computes the net present 17748value where payments occur at the beginning of each interval 17749rather than at the end. 17750 17751@node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions 17752@subsection Related Financial Functions 17753 17754@noindent 17755The functions in this section are basically inverses of the 17756present value functions with respect to the various arguments. 17757 17758@kindex b M 17759@pindex calc-fin-pmt 17760@tindex pmt 17761The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes 17762the amount of periodic payment necessary to amortize a loan. 17763Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the 17764value of @var{payment} such that @code{pv(@var{rate}, @var{n}, 17765@var{payment}) = @var{amount}}. 17766 17767@kindex I b M 17768@tindex pmtb 17769The @kbd{I b M} [@code{pmtb}] command does the same computation 17770but using @code{pvb} instead of @code{pv}. Like @code{pv} and 17771@code{pvb}, these functions can also take a fourth argument which 17772represents an initial lump-sum investment. 17773 17774@kindex H b M 17775The @kbd{H b M} key just invokes the @code{fvl} function, which is 17776the inverse of @code{pvl}. There is no explicit @code{pmtl} function. 17777 17778@kindex b # 17779@pindex calc-fin-nper 17780@tindex nper 17781The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes 17782the number of regular payments necessary to amortize a loan. 17783Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals 17784the value of @var{n} such that @code{pv(@var{rate}, @var{n}, 17785@var{payment}) = @var{amount}}. If @var{payment} is too small 17786ever to amortize a loan for @var{amount} at interest rate @var{rate}, 17787the @code{nper} function is left in symbolic form. 17788 17789@kindex I b # 17790@tindex nperb 17791The @kbd{I b #} [@code{nperb}] command does the same computation 17792but using @code{pvb} instead of @code{pv}. You can give a fourth 17793lump-sum argument to these functions, but the computation will be 17794rather slow in the four-argument case. 17795 17796@kindex H b # 17797@tindex nperl 17798The @kbd{H b #} [@code{nperl}] command does the same computation 17799using @code{pvl}. By exchanging @var{payment} and @var{amount} you 17800can also get the solution for @code{fvl}. For example, 17801@code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a 17802bank account earning 8%, it will take nine years to grow to $2000. 17803 17804@kindex b T 17805@pindex calc-fin-rate 17806@tindex rate 17807The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes 17808the rate of return on an investment. This is also an inverse of @code{pv}: 17809@code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of 17810@var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) = 17811@var{amount}}. The result is expressed as a formula like @samp{6.3%}. 17812 17813@kindex I b T 17814@kindex H b T 17815@tindex rateb 17816@tindex ratel 17817The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}] 17818commands solve the analogous equations with @code{pvb} or @code{pvl} 17819in place of @code{pv}. Also, @code{rate} and @code{rateb} can 17820accept an optional fourth argument just like @code{pv} and @code{pvb}. 17821To redo the above example from a different perspective, 17822@code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an 17823interest rate of 8% in order to double your account in nine years. 17824 17825@kindex b I 17826@pindex calc-fin-irr 17827@tindex irr 17828The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the 17829analogous function to @code{rate} but for net present value. 17830Its argument is a vector of payments. Thus @code{irr(@var{payments})} 17831computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0}; 17832this rate is known as the @dfn{internal rate of return}. 17833 17834@kindex I b I 17835@tindex irrb 17836The @kbd{I b I} [@code{irrb}] command computes the internal rate of 17837return assuming payments occur at the beginning of each period. 17838 17839@node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions 17840@subsection Depreciation Functions 17841 17842@noindent 17843The functions in this section calculate @dfn{depreciation}, which is 17844the amount of value that a possession loses over time. These functions 17845are characterized by three parameters: @var{cost}, the original cost 17846of the asset; @var{salvage}, the value the asset will have at the end 17847of its expected ``useful life''; and @var{life}, the number of years 17848(or other periods) of the expected useful life. 17849 17850There are several methods for calculating depreciation that differ in 17851the way they spread the depreciation over the lifetime of the asset. 17852 17853@kindex b S 17854@pindex calc-fin-sln 17855@tindex sln 17856The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the 17857``straight-line'' depreciation. In this method, the asset depreciates 17858by the same amount every year (or period). For example, 17859@samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000 17860initially and will be worth $2000 after five years; it loses $2000 17861per year. 17862 17863@kindex b Y 17864@pindex calc-fin-syd 17865@tindex syd 17866The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the 17867accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation 17868is higher during the early years of the asset's life. Since the 17869depreciation is different each year, @kbd{b Y} takes a fourth @var{period} 17870parameter which specifies which year is requested, from 1 to @var{life}. 17871If @var{period} is outside this range, the @code{syd} function will 17872return zero. 17873 17874@kindex b D 17875@pindex calc-fin-ddb 17876@tindex ddb 17877The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an 17878accelerated depreciation using the double-declining balance method. 17879It also takes a fourth @var{period} parameter. 17880 17881For symmetry, the @code{sln} function will accept a @var{period} 17882parameter as well, although it will ignore its value except that the 17883return value will as usual be zero if @var{period} is out of range. 17884 17885For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5}) 17886and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$), 17887ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare 17888the three depreciation methods: 17889 17890@example 17891@group 17892[ [ 2000, 3333, 4800 ] 17893 [ 2000, 2667, 2880 ] 17894 [ 2000, 2000, 1728 ] 17895 [ 2000, 1333, 592 ] 17896 [ 2000, 667, 0 ] ] 17897@end group 17898@end example 17899 17900@noindent 17901(Values have been rounded to nearest integers in this figure.) 17902We see that @code{sln} depreciates by the same amount each year, 17903@kbd{syd} depreciates more at the beginning and less at the end, 17904and @kbd{ddb} weights the depreciation even more toward the beginning. 17905 17906Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]}; 17907the total depreciation in any method is (by definition) the 17908difference between the cost and the salvage value. 17909 17910@node Definitions of Financial Functions, , Depreciation Functions, Financial Functions 17911@subsection Definitions 17912 17913@noindent 17914For your reference, here are the actual formulas used to compute 17915Calc's financial functions. 17916 17917Calc will not evaluate a financial function unless the @var{rate} or 17918@var{n} argument is known. However, @var{payment} or @var{amount} can 17919be a variable. Calc expands these functions according to the 17920formulas below for symbolic arguments only when you use the @kbd{a "} 17921(@code{calc-expand-formula}) command, or when taking derivatives or 17922integrals or solving equations involving the functions. 17923 17924@ifnottex 17925These formulas are shown using the conventions of Big display 17926mode (@kbd{d B}); for example, the formula for @code{fv} written 17927linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}. 17928 17929@example 17930 n 17931 (1 + rate) - 1 17932fv(rate, n, pmt) = pmt * --------------- 17933 rate 17934 17935 n 17936 ((1 + rate) - 1) (1 + rate) 17937fvb(rate, n, pmt) = pmt * ---------------------------- 17938 rate 17939 17940 n 17941fvl(rate, n, pmt) = pmt * (1 + rate) 17942 17943 -n 17944 1 - (1 + rate) 17945pv(rate, n, pmt) = pmt * ---------------- 17946 rate 17947 17948 -n 17949 (1 - (1 + rate) ) (1 + rate) 17950pvb(rate, n, pmt) = pmt * ----------------------------- 17951 rate 17952 17953 -n 17954pvl(rate, n, pmt) = pmt * (1 + rate) 17955 17956 -1 -2 -3 17957npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate) 17958 17959 -1 -2 17960npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate) 17961 17962 -n 17963 (amt - x * (1 + rate) ) * rate 17964pmt(rate, n, amt, x) = ------------------------------- 17965 -n 17966 1 - (1 + rate) 17967 17968 -n 17969 (amt - x * (1 + rate) ) * rate 17970pmtb(rate, n, amt, x) = ------------------------------- 17971 -n 17972 (1 - (1 + rate) ) (1 + rate) 17973 17974 amt * rate 17975nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate) 17976 pmt 17977 17978 amt * rate 17979nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate) 17980 pmt * (1 + rate) 17981 17982 amt 17983nperl(rate, pmt, amt) = - log(---, 1 + rate) 17984 pmt 17985 17986 1/n 17987 pmt 17988ratel(n, pmt, amt) = ------ - 1 17989 1/n 17990 amt 17991 17992 cost - salv 17993sln(cost, salv, life) = ----------- 17994 life 17995 17996 (cost - salv) * (life - per + 1) 17997syd(cost, salv, life, per) = -------------------------------- 17998 life * (life + 1) / 2 17999 18000 book * 2 18001ddb(cost, salv, life, per) = --------, book = cost - depreciation so far 18002 life 18003@end example 18004@end ifnottex 18005@tex 18006$$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$ 18007$$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$ 18008$$ \code{fvl}(r, n, p) = p (1 + r)^n $$ 18009$$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$ 18010$$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$ 18011$$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$ 18012$$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$ 18013$$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$ 18014$$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$ 18015$$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 18016 (1 - (1 + r)^{-n}) (1 + r) } $$ 18017$$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$ 18018$$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$ 18019$$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$ 18020$$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$ 18021$$ \code{sln}(c, s, l) = { c - s \over l } $$ 18022$$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$ 18023$$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$ 18024@end tex 18025 18026@noindent 18027In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted. 18028 18029These functions accept any numeric objects, including error forms, 18030intervals, and even (though not very usefully) complex numbers. The 18031above formulas specify exactly the behavior of these functions with 18032all sorts of inputs. 18033 18034Note that if the first argument to the @code{log} in @code{nper} is 18035negative, @code{nper} leaves itself in symbolic form rather than 18036returning a (financially meaningless) complex number. 18037 18038@samp{rate(num, pmt, amt)} solves the equation 18039@samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R} 18040(@code{calc-find-root}), with the interval @samp{[.01% .. 100%]} 18041for an initial guess. The @code{rateb} function is the same except 18042that it uses @code{pvb}. Note that @code{ratel} can be solved 18043directly; its formula is shown in the above list. 18044 18045Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0} 18046for @samp{rate}. 18047 18048If you give a fourth argument to @code{nper} or @code{nperb}, Calc 18049will also use @kbd{H a R} to solve the equation using an initial 18050guess interval of @samp{[0 .. 100]}. 18051 18052A fourth argument to @code{fv} simply sums the two components 18053calculated from the above formulas for @code{fv} and @code{fvl}. 18054The same is true of @code{fvb}, @code{pv}, and @code{pvb}. 18055 18056The @kbd{ddb} function is computed iteratively; the ``book'' value 18057starts out equal to @var{cost}, and decreases according to the above 18058formula for the specified number of periods. If the book value 18059would decrease below @var{salvage}, it only decreases to @var{salvage} 18060and the depreciation is zero for all subsequent periods. The @code{ddb} 18061function returns the amount the book value decreased in the specified 18062period. 18063 18064@node Binary Functions, , Financial Functions, Arithmetic 18065@section Binary Number Functions 18066 18067@noindent 18068The commands in this chapter all use two-letter sequences beginning with 18069the @kbd{b} prefix. 18070 18071@cindex Binary numbers 18072The ``binary'' operations actually work regardless of the currently 18073displayed radix, although their results make the most sense in a radix 18074like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}} 18075commands, respectively). You may also wish to enable display of leading 18076zeros with @kbd{d z}. @xref{Radix Modes}. 18077 18078@cindex Word size for binary operations 18079The Calculator maintains a current @dfn{word size} @expr{w}, an 18080arbitrary positive or negative integer. For a positive word size, all 18081of the binary operations described here operate modulo @expr{2^w}. In 18082particular, negative arguments are converted to positive integers modulo 18083@expr{2^w} by all binary functions. 18084 18085If the word size is negative, binary operations produce twos-complement 18086integers from 18087@texline @math{-2^{-w-1}} 18088@infoline @expr{-(2^(-w-1))} 18089to 18090@texline @math{2^{-w-1}-1} 18091@infoline @expr{2^(-w-1)-1} 18092inclusive. Either mode accepts inputs in any range; the sign of 18093@expr{w} affects only the results produced. 18094 18095@kindex b c 18096@pindex calc-clip 18097@tindex clip 18098The @kbd{b c} (@code{calc-clip}) 18099[@code{clip}] command can be used to clip a number by reducing it modulo 18100@expr{2^w}. The commands described in this chapter automatically clip 18101their results to the current word size. Note that other operations like 18102addition do not use the current word size, since integer addition 18103generally is not ``binary.'' (However, @pxref{Simplification Modes}, 18104@code{calc-bin-simplify-mode}.) For example, with a word size of 8 18105bits @kbd{b c} converts a number to the range 0 to 255; with a word 18106size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127. 18107 18108@kindex b w 18109@pindex calc-word-size 18110The default word size is 32 bits. All operations except the shifts and 18111rotates allow you to specify a different word size for that one 18112operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the 18113top of stack to the range 0 to 255 regardless of the current word size. 18114To set the word size permanently, use @kbd{b w} (@code{calc-word-size}). 18115This command displays a prompt with the current word size; press @key{RET} 18116immediately to keep this word size, or type a new word size at the prompt. 18117 18118When the binary operations are written in symbolic form, they take an 18119optional second (or third) word-size parameter. When a formula like 18120@samp{and(a,b)} is finally evaluated, the word size current at that time 18121will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of 18122@mathit{-8} will always be used. A symbolic binary function will be left 18123in symbolic form unless the all of its argument(s) are integers or 18124integer-valued floats. 18125 18126If either or both arguments are modulo forms for which @expr{M} is a 18127power of two, that power of two is taken as the word size unless a 18128numeric prefix argument overrides it. The current word size is never 18129consulted when modulo-power-of-two forms are involved. 18130 18131@kindex b a 18132@pindex calc-and 18133@tindex and 18134The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise 18135AND of the two numbers on the top of the stack. In other words, for each 18136of the @expr{w} binary digits of the two numbers (pairwise), the corresponding 18137bit of the result is 1 if and only if both input bits are 1: 18138@samp{and(2#1100, 2#1010) = 2#1000}. 18139 18140@kindex b o 18141@pindex calc-or 18142@tindex or 18143The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise 18144inclusive OR of two numbers. A bit is 1 if either of the input bits, or 18145both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}. 18146 18147@kindex b x 18148@pindex calc-xor 18149@tindex xor 18150The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise 18151exclusive OR of two numbers. A bit is 1 if exactly one of the input bits 18152is 1: @samp{xor(2#1100, 2#1010) = 2#0110}. 18153 18154@kindex b d 18155@pindex calc-diff 18156@tindex diff 18157The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise 18158difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))}, 18159so that @samp{diff(2#1100, 2#1010) = 2#0100}. 18160 18161@kindex b n 18162@pindex calc-not 18163@tindex not 18164The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise 18165NOT of a number. A bit is 1 if the input bit is 0 and vice-versa. 18166 18167@kindex b l 18168@pindex calc-lshift-binary 18169@tindex lsh 18170The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a 18171number left by one bit, or by the number of bits specified in the numeric 18172prefix argument. A negative prefix argument performs a logical right shift, 18173in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)} 18174is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}. 18175Bits shifted ``off the end,'' according to the current word size, are lost. 18176 18177@kindex H b l 18178@kindex H b r 18179@ignore 18180@mindex @idots 18181@end ignore 18182@kindex H b L 18183@ignore 18184@mindex @null 18185@end ignore 18186@kindex H b R 18187@ignore 18188@mindex @null 18189@end ignore 18190@kindex H b t 18191The @kbd{H b l} command also does a left shift, but it takes two arguments 18192from the stack (the value to shift, and, at top-of-stack, the number of 18193bits to shift). This version interprets the prefix argument just like 18194the regular binary operations, i.e., as a word size. The Hyperbolic flag 18195has a similar effect on the rest of the binary shift and rotate commands. 18196 18197@kindex b r 18198@pindex calc-rshift-binary 18199@tindex rsh 18200The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a 18201number right by one bit, or by the number of bits specified in the numeric 18202prefix argument: @samp{rsh(a,n) = lsh(a,-n)}. 18203 18204@kindex b L 18205@pindex calc-lshift-arith 18206@tindex ash 18207The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a 18208number left. It is analogous to @code{lsh}, except that if the shift 18209is rightward (the prefix argument is negative), an arithmetic shift 18210is performed as described below. 18211 18212@kindex b R 18213@pindex calc-rshift-arith 18214@tindex rash 18215The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs 18216an ``arithmetic'' shift to the right, in which the leftmost bit (according 18217to the current word size) is duplicated rather than shifting in zeros. 18218This corresponds to dividing by a power of two where the input is interpreted 18219as a signed, twos-complement number. (The distinction between the @samp{rsh} 18220and @samp{rash} operations is totally independent from whether the word 18221size is positive or negative.) With a negative prefix argument, this 18222performs a standard left shift. 18223 18224@kindex b t 18225@pindex calc-rotate-binary 18226@tindex rot 18227The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a 18228number one bit to the left. The leftmost bit (according to the current 18229word size) is dropped off the left and shifted in on the right. With a 18230numeric prefix argument, the number is rotated that many bits to the left 18231or right. 18232 18233@xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that 18234pack and unpack binary integers into sets. (For example, @kbd{b u} 18235unpacks the number @samp{2#11001} to the set of bit-numbers 18236@samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1'' 18237bits in a binary integer. 18238 18239Another interesting use of the set representation of binary integers 18240is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to 18241unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set 18242with 31 minus that bit-number; type @kbd{b p} to pack the set back 18243into a binary integer. 18244 18245@node Scientific Functions, Matrix Functions, Arithmetic, Top 18246@chapter Scientific Functions 18247 18248@noindent 18249The functions described here perform trigonometric and other transcendental 18250calculations. They generally produce floating-point answers correct to the 18251full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse) 18252flag keys must be used to get some of these functions from the keyboard. 18253 18254@kindex P 18255@pindex calc-pi 18256@cindex @code{pi} variable 18257@vindex pi 18258@kindex H P 18259@cindex @code{e} variable 18260@vindex e 18261@kindex I P 18262@cindex @code{gamma} variable 18263@vindex gamma 18264@cindex Gamma constant, Euler's 18265@cindex Euler's gamma constant 18266@kindex H I P 18267@cindex @code{phi} variable 18268@cindex Phi, golden ratio 18269@cindex Golden ratio 18270One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes 18271the value of @cpi{} (at the current precision) onto the stack. With the 18272Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms. 18273With the Inverse flag, it pushes Euler's constant 18274@texline @math{\gamma} 18275@infoline @expr{gamma} 18276(about 0.5772). With both Inverse and Hyperbolic, it 18277pushes the ``golden ratio'' 18278@texline @math{\phi} 18279@infoline @expr{phi} 18280(about 1.618). (At present, Euler's constant is not available 18281to unlimited precision; Calc knows only the first 100 digits.) 18282In Symbolic mode, these commands push the 18283actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi}, 18284respectively, instead of their values; @pxref{Symbolic Mode}. 18285 18286@ignore 18287@mindex Q 18288@end ignore 18289@ignore 18290@mindex I Q 18291@end ignore 18292@kindex I Q 18293@tindex sqr 18294The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere; 18295@pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command 18296computes the square of the argument. 18297 18298@xref{Prefix Arguments}, for a discussion of the effect of numeric 18299prefix arguments on commands in this chapter which do not otherwise 18300interpret a prefix argument. 18301 18302@menu 18303* Logarithmic Functions:: 18304* Trigonometric and Hyperbolic Functions:: 18305* Advanced Math Functions:: 18306* Branch Cuts:: 18307* Random Numbers:: 18308* Combinatorial Functions:: 18309* Probability Distribution Functions:: 18310@end menu 18311 18312@node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions 18313@section Logarithmic Functions 18314 18315@noindent 18316@kindex L 18317@pindex calc-ln 18318@tindex ln 18319@ignore 18320@mindex @null 18321@end ignore 18322@kindex I E 18323The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural 18324logarithm of the real or complex number on the top of the stack. With 18325the Inverse flag it computes the exponential function instead, although 18326this is redundant with the @kbd{E} command. 18327 18328@kindex E 18329@pindex calc-exp 18330@tindex exp 18331@ignore 18332@mindex @null 18333@end ignore 18334@kindex I L 18335The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the 18336exponential, i.e., @expr{e} raised to the power of the number on the stack. 18337The meanings of the Inverse and Hyperbolic flags follow from those for 18338the @code{calc-ln} command. 18339 18340@kindex H L 18341@kindex H E 18342@pindex calc-log10 18343@tindex log10 18344@tindex exp10 18345@ignore 18346@mindex @null 18347@end ignore 18348@kindex H I L 18349@ignore 18350@mindex @null 18351@end ignore 18352@kindex H I E 18353The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common 18354(base-10) logarithm of a number. (With the Inverse flag [@code{exp10}], 18355it raises ten to a given power.) Note that the common logarithm of a 18356complex number is computed by taking the natural logarithm and dividing 18357by 18358@texline @math{\ln10}. 18359@infoline @expr{ln(10)}. 18360 18361@kindex B 18362@kindex I B 18363@pindex calc-log 18364@tindex log 18365@tindex alog 18366The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm 18367to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since 18368@texline @math{2^{10} = 1024}. 18369@infoline @expr{2^10 = 1024}. 18370In certain cases like @samp{log(3,9)}, the result 18371will be either @expr{1:2} or @expr{0.5} depending on the current Fraction 18372mode setting. With the Inverse flag [@code{alog}], this command is 18373similar to @kbd{^} except that the order of the arguments is reversed. 18374 18375@kindex f I 18376@pindex calc-ilog 18377@tindex ilog 18378The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the 18379integer logarithm of a number to any base. The number and the base must 18380themselves be positive integers. This is the true logarithm, rounded 18381down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the 18382range from 1000 to 9999. If both arguments are positive integers, exact 18383integer arithmetic is used; otherwise, this is equivalent to 18384@samp{floor(log(x,b))}. 18385 18386@kindex f E 18387@pindex calc-expm1 18388@tindex expm1 18389The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes 18390@texline @math{e^x - 1}, 18391@infoline @expr{exp(x)-1}, 18392but using an algorithm that produces a more accurate 18393answer when the result is close to zero, i.e., when 18394@texline @math{e^x} 18395@infoline @expr{exp(x)} 18396is close to one. 18397 18398@kindex f L 18399@pindex calc-lnp1 18400@tindex lnp1 18401The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes 18402@texline @math{\ln(x+1)}, 18403@infoline @expr{ln(x+1)}, 18404producing a more accurate answer when @expr{x} is close to zero. 18405 18406@node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions 18407@section Trigonometric/Hyperbolic Functions 18408 18409@noindent 18410@kindex S 18411@pindex calc-sin 18412@tindex sin 18413The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine 18414of an angle or complex number. If the input is an HMS form, it is interpreted 18415as degrees-minutes-seconds; otherwise, the input is interpreted according 18416to the current angular mode. It is best to use Radians mode when operating 18417on complex numbers. 18418 18419Calc's ``units'' mechanism includes angular units like @code{deg}, 18420@code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated 18421all the time, the @kbd{u s} (@code{calc-simplify-units}) command will 18422simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless 18423of the current angular mode. @xref{Basic Operations on Units}. 18424 18425Also, the symbolic variable @code{pi} is not ordinarily recognized in 18426arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but 18427the default algebraic simplifications recognize many such 18428formulas when the current angular mode is Radians @emph{and} Symbolic 18429mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}. 18430@xref{Symbolic Mode}. Beware, this simplification occurs even if you 18431have stored a different value in the variable @samp{pi}; this is one 18432reason why changing built-in variables is a bad idea. Arguments of 18433the form @expr{x} plus a multiple of @cpiover{2} are also simplified. 18434Calc includes similar formulas for @code{cos} and @code{tan}. 18435 18436Calc's algebraic simplifications know all angles which are integer multiples of 18437@cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode, 18438analogous simplifications occur for integer multiples of 15 or 18 18439degrees, and for arguments plus multiples of 90 degrees. 18440 18441@kindex I S 18442@pindex calc-arcsin 18443@tindex arcsin 18444With the Inverse flag, @code{calc-sin} computes an arcsine. This is also 18445available as the @code{calc-arcsin} command or @code{arcsin} algebraic 18446function. The returned argument is converted to degrees, radians, or HMS 18447notation depending on the current angular mode. 18448 18449@kindex H S 18450@pindex calc-sinh 18451@tindex sinh 18452@kindex H I S 18453@pindex calc-arcsinh 18454@tindex arcsinh 18455With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic 18456sine, also available as @code{calc-sinh} [@code{sinh}]. With the 18457Hyperbolic and Inverse flags, it computes the hyperbolic arcsine 18458(@code{calc-arcsinh}) [@code{arcsinh}]. 18459 18460@kindex C 18461@pindex calc-cos 18462@tindex cos 18463@ignore 18464@mindex @idots 18465@end ignore 18466@kindex I C 18467@pindex calc-arccos 18468@ignore 18469@mindex @null 18470@end ignore 18471@tindex arccos 18472@ignore 18473@mindex @null 18474@end ignore 18475@kindex H C 18476@pindex calc-cosh 18477@ignore 18478@mindex @null 18479@end ignore 18480@tindex cosh 18481@ignore 18482@mindex @null 18483@end ignore 18484@kindex H I C 18485@pindex calc-arccosh 18486@ignore 18487@mindex @null 18488@end ignore 18489@tindex arccosh 18490@ignore 18491@mindex @null 18492@end ignore 18493@kindex T 18494@pindex calc-tan 18495@ignore 18496@mindex @null 18497@end ignore 18498@tindex tan 18499@ignore 18500@mindex @null 18501@end ignore 18502@kindex I T 18503@pindex calc-arctan 18504@ignore 18505@mindex @null 18506@end ignore 18507@tindex arctan 18508@ignore 18509@mindex @null 18510@end ignore 18511@kindex H T 18512@pindex calc-tanh 18513@ignore 18514@mindex @null 18515@end ignore 18516@tindex tanh 18517@ignore 18518@mindex @null 18519@end ignore 18520@kindex H I T 18521@pindex calc-arctanh 18522@ignore 18523@mindex @null 18524@end ignore 18525@tindex arctanh 18526The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine 18527of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}] 18528computes the tangent, along with all the various inverse and hyperbolic 18529variants of these functions. 18530 18531@kindex f T 18532@pindex calc-arctan2 18533@tindex arctan2 18534The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two 18535numbers from the stack and computes the arc tangent of their ratio. The 18536result is in the full range from @mathit{-180} (exclusive) to @mathit{+180} 18537(inclusive) degrees, or the analogous range in radians. A similar 18538result would be obtained with @kbd{/} followed by @kbd{I T}, but the 18539value would only be in the range from @mathit{-90} to @mathit{+90} degrees 18540since the division loses information about the signs of the two 18541components, and an error might result from an explicit division by zero 18542which @code{arctan2} would avoid. By (arbitrary) definition, 18543@samp{arctan2(0,0)=0}. 18544 18545@pindex calc-sincos 18546@ignore 18547@starindex 18548@end ignore 18549@tindex sincos 18550@ignore 18551@starindex 18552@end ignore 18553@ignore 18554@mindex arc@idots 18555@end ignore 18556@tindex arcsincos 18557The @code{calc-sincos} [@code{sincos}] command computes the sine and 18558cosine of a number, returning them as a vector of the form 18559@samp{[@var{cos}, @var{sin}]}. 18560With the Inverse flag [@code{arcsincos}], this command takes a two-element 18561vector as an argument and computes @code{arctan2} of the elements. 18562(This command does not accept the Hyperbolic flag.) 18563 18564@pindex calc-sec 18565@tindex sec 18566@pindex calc-csc 18567@tindex csc 18568@pindex calc-cot 18569@tindex cot 18570@pindex calc-sech 18571@tindex sech 18572@pindex calc-csch 18573@tindex csch 18574@pindex calc-coth 18575@tindex coth 18576The remaining trigonometric functions, @code{calc-sec} [@code{sec}], 18577@code{calc-csc} [@code{csc}] and @code{calc-cot} [@code{cot}], are also 18578available. With the Hyperbolic flag, these compute their hyperbolic 18579counterparts, which are also available separately as @code{calc-sech} 18580[@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-coth} 18581[@code{coth}]. (These commands do not accept the Inverse flag.) 18582 18583@node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions 18584@section Advanced Mathematical Functions 18585 18586@noindent 18587Calc can compute a variety of less common functions that arise in 18588various branches of mathematics. All of the functions described in 18589this section allow arbitrary complex arguments and, except as noted, 18590will work to arbitrarily large precision. They can not at present 18591handle error forms or intervals as arguments. 18592 18593NOTE: These functions are still experimental. In particular, their 18594accuracy is not guaranteed in all domains. It is advisable to set the 18595current precision comfortably higher than you actually need when 18596using these functions. Also, these functions may be impractically 18597slow for some values of the arguments. 18598 18599@kindex f g 18600@pindex calc-gamma 18601@tindex gamma 18602The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler 18603gamma function. For positive integer arguments, this is related to the 18604factorial function: @samp{gamma(n+1) = fact(n)}. For general complex 18605arguments the gamma function can be defined by the following definite 18606integral: 18607@texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}. 18608@infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}. 18609(The actual implementation uses far more efficient computational methods.) 18610 18611@kindex f G 18612@tindex gammaP 18613@ignore 18614@mindex @idots 18615@end ignore 18616@kindex I f G 18617@ignore 18618@mindex @null 18619@end ignore 18620@kindex H f G 18621@ignore 18622@mindex @null 18623@end ignore 18624@kindex H I f G 18625@pindex calc-inc-gamma 18626@ignore 18627@mindex @null 18628@end ignore 18629@tindex gammaQ 18630@ignore 18631@mindex @null 18632@end ignore 18633@tindex gammag 18634@ignore 18635@mindex @null 18636@end ignore 18637@tindex gammaG 18638The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes 18639the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by 18640the integral, 18641@texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}. 18642@infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}. 18643This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the 18644definition of the normal gamma function). 18645 18646Several other varieties of incomplete gamma function are defined. 18647The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by 18648some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command. 18649You can think of this as taking the other half of the integral, from 18650@expr{x} to infinity. 18651 18652@ifnottex 18653The functions corresponding to the integrals that define @expr{P(a,x)} 18654and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)} 18655factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively 18656(where @expr{g} and @expr{G} represent the lower- and upper-case Greek 18657letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}] 18658and @kbd{H I f G} [@code{gammaG}] commands. 18659@end ifnottex 18660@tex 18661The functions corresponding to the integrals that define $P(a,x)$ 18662and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$ 18663factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively. 18664You can obtain these using the \kbd{H f G} [\code{gammag}] and 18665\kbd{I H f G} [\code{gammaG}] commands. 18666@end tex 18667 18668@kindex f b 18669@pindex calc-beta 18670@tindex beta 18671The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the 18672Euler beta function, which is defined in terms of the gamma function as 18673@texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)}, 18674@infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)}, 18675or by 18676@texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}. 18677@infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}. 18678 18679@kindex f B 18680@kindex H f B 18681@pindex calc-inc-beta 18682@tindex betaI 18683@tindex betaB 18684The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes 18685the incomplete beta function @expr{I(x,a,b)}. It is defined by 18686@texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}. 18687@infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}. 18688Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding 18689un-normalized version [@code{betaB}]. 18690 18691@kindex f e 18692@kindex I f e 18693@pindex calc-erf 18694@tindex erf 18695@tindex erfc 18696The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the 18697error function 18698@texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}. 18699@infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}. 18700The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}] 18701is the corresponding integral from @samp{x} to infinity; the sum 18702@texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}. 18703@infoline @expr{erf(x) + erfc(x) = 1}. 18704 18705@kindex f j 18706@kindex f y 18707@pindex calc-bessel-J 18708@pindex calc-bessel-Y 18709@tindex besJ 18710@tindex besY 18711The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y} 18712(@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel 18713functions of the first and second kinds, respectively. 18714In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter 18715@expr{n} is often an integer, but is not required to be one. 18716Calc's implementation of the Bessel functions currently limits the 18717precision to 8 digits, and may not be exact even to that precision. 18718Use with care! 18719 18720@node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions 18721@section Branch Cuts and Principal Values 18722 18723@noindent 18724@cindex Branch cuts 18725@cindex Principal values 18726All of the logarithmic, trigonometric, and other scientific functions are 18727defined for complex numbers as well as for reals. 18728This section describes the values 18729returned in cases where the general result is a family of possible values. 18730Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language}, 18731second edition, in these matters. This section will describe each 18732function briefly; for a more detailed discussion (including some nifty 18733diagrams), consult Steele's book. 18734 18735Note that the branch cuts for @code{arctan} and @code{arctanh} were 18736changed between the first and second editions of Steele. Recent 18737versions of Calc follow the second edition. 18738 18739The new branch cuts exactly match those of the HP-28/48 calculators. 18740They also match those of Mathematica 1.2, except that Mathematica's 18741@code{arctan} cut is always in the right half of the complex plane, 18742and its @code{arctanh} cut is always in the top half of the plane. 18743Calc's cuts are continuous with quadrants I and III for @code{arctan}, 18744or II and IV for @code{arctanh}. 18745 18746Note: The current implementations of these functions with complex arguments 18747are designed with proper behavior around the branch cuts in mind, @emph{not} 18748efficiency or accuracy. You may need to increase the floating precision 18749and wait a while to get suitable answers from them. 18750 18751For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive 18752or zero, the result is close to the @expr{+i} axis. For @expr{b} small and 18753negative, the result is close to the @expr{-i} axis. The result always lies 18754in the right half of the complex plane. 18755 18756For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}. 18757The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}. 18758Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the 18759negative real axis. 18760 18761The following table describes these branch cuts in another way. 18762If the real and imaginary parts of @expr{z} are as shown, then 18763the real and imaginary parts of @expr{f(z)} will be as shown. 18764Here @code{eps} stands for a small positive value; each 18765occurrence of @code{eps} may stand for a different small value. 18766 18767@smallexample 18768 z sqrt(z) ln(z) 18769---------------------------------------- 18770 +, 0 +, 0 any, 0 18771 -, 0 0, + any, pi 18772 -, +eps +eps, + +eps, + 18773 -, -eps +eps, - +eps, - 18774@end smallexample 18775 18776For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}. 18777One interesting consequence of this is that @samp{(-8)^1:3} does 18778not evaluate to @mathit{-2} as you might expect, but to the complex 18779number @expr{(1., 1.732)}. Both of these are valid cube roots 18780of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps 18781less-obvious root for the sake of mathematical consistency. 18782 18783For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}. 18784The branch cuts are on the real axis, less than @mathit{-1} and greater than 1. 18785 18786For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))}, 18787or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on 18788the real axis, less than @mathit{-1} and greater than 1. 18789 18790For @samp{arctan(z)}: This is defined by 18791@samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the 18792imaginary axis, below @expr{-i} and above @expr{i}. 18793 18794For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}. 18795The branch cuts are on the imaginary axis, below @expr{-i} and 18796above @expr{i}. 18797 18798For @samp{arccosh(z)}: This is defined by 18799@samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the 18800real axis less than 1. 18801 18802For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}. 18803The branch cuts are on the real axis, less than @mathit{-1} and greater than 1. 18804 18805The following tables for @code{arcsin}, @code{arccos}, and 18806@code{arctan} assume the current angular mode is Radians. The 18807hyperbolic functions operate independently of the angular mode. 18808 18809@smallexample 18810 z arcsin(z) arccos(z) 18811------------------------------------------------------- 18812 (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0 18813 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps 18814 (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps 18815 <-1, 0 -pi/2, + pi, - 18816 <-1, +eps -pi/2 + eps, + pi - eps, - 18817 <-1, -eps -pi/2 + eps, - pi - eps, + 18818 >1, 0 pi/2, - 0, + 18819 >1, +eps pi/2 - eps, + +eps, - 18820 >1, -eps pi/2 - eps, - +eps, + 18821@end smallexample 18822 18823@smallexample 18824 z arccosh(z) arctanh(z) 18825----------------------------------------------------- 18826 (-1..1), 0 0, (0..pi) any, 0 18827 (-1..1), +eps +eps, (0..pi) any, +eps 18828 (-1..1), -eps +eps, (-pi..0) any, -eps 18829 <-1, 0 +, pi -, pi/2 18830 <-1, +eps +, pi - eps -, pi/2 - eps 18831 <-1, -eps +, -pi + eps -, -pi/2 + eps 18832 >1, 0 +, 0 +, -pi/2 18833 >1, +eps +, +eps +, pi/2 - eps 18834 >1, -eps +, -eps +, -pi/2 + eps 18835@end smallexample 18836 18837@smallexample 18838 z arcsinh(z) arctan(z) 18839----------------------------------------------------- 18840 0, (-1..1) 0, (-pi/2..pi/2) 0, any 18841 0, <-1 -, -pi/2 -pi/2, - 18842 +eps, <-1 +, -pi/2 + eps pi/2 - eps, - 18843 -eps, <-1 -, -pi/2 + eps -pi/2 + eps, - 18844 0, >1 +, pi/2 pi/2, + 18845 +eps, >1 +, pi/2 - eps pi/2 - eps, + 18846 -eps, >1 -, pi/2 - eps -pi/2 + eps, + 18847@end smallexample 18848 18849Finally, the following identities help to illustrate the relationship 18850between the complex trigonometric and hyperbolic functions. They 18851are valid everywhere, including on the branch cuts. 18852 18853@smallexample 18854sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z) 18855cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z) 18856tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z) 18857sinh(i*z) = i*sin(z) cosh(i*z) = cos(z) 18858@end smallexample 18859 18860The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined 18861for general complex arguments, but their branch cuts and principal values 18862are not rigorously specified at present. 18863 18864@node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions 18865@section Random Numbers 18866 18867@noindent 18868@kindex k r 18869@pindex calc-random 18870@tindex random 18871The @kbd{k r} (@code{calc-random}) [@code{random}] command produces 18872random numbers of various sorts. 18873 18874Given a positive numeric prefix argument @expr{M}, it produces a random 18875integer @expr{N} in the range 18876@texline @math{0 \le N < M}. 18877@infoline @expr{0 <= N < M}. 18878Each possible value @expr{N} appears with equal probability. 18879 18880With no numeric prefix argument, the @kbd{k r} command takes its argument 18881from the stack instead. Once again, if this is a positive integer @expr{M} 18882the result is a random integer less than @expr{M}. However, note that 18883while numeric prefix arguments are limited to six digits or so, an @expr{M} 18884taken from the stack can be arbitrarily large. If @expr{M} is negative, 18885the result is a random integer in the range 18886@texline @math{M < N \le 0}. 18887@infoline @expr{M < N <= 0}. 18888 18889If the value on the stack is a floating-point number @expr{M}, the result 18890is a random floating-point number @expr{N} in the range 18891@texline @math{0 \le N < M} 18892@infoline @expr{0 <= N < M} 18893or 18894@texline @math{M < N \le 0}, 18895@infoline @expr{M < N <= 0}, 18896according to the sign of @expr{M}. 18897 18898If @expr{M} is zero, the result is a Gaussian-distributed random real 18899number; the distribution has a mean of zero and a standard deviation 18900of one. The algorithm used generates random numbers in pairs; thus, 18901every other call to this function will be especially fast. 18902 18903If @expr{M} is an error form 18904@texline @math{m} @code{+/-} @math{\sigma} 18905@infoline @samp{m +/- s} 18906where @var{m} and 18907@texline @math{\sigma} 18908@infoline @var{s} 18909are both real numbers, the result uses a Gaussian distribution with mean 18910@var{m} and standard deviation 18911@texline @math{\sigma}. 18912@infoline @var{s}. 18913 18914If @expr{M} is an interval form, the lower and upper bounds specify the 18915acceptable limits of the random numbers. If both bounds are integers, 18916the result is a random integer in the specified range. If either bound 18917is floating-point, the result is a random real number in the specified 18918range. If the interval is open at either end, the result will be sure 18919not to equal that end value. (This makes a big difference for integer 18920intervals, but for floating-point intervals it's relatively minor: 18921with a precision of 6, @samp{random([1.0..2.0))} will return any of one 18922million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may 18923additionally return 2.00000, but the probability of this happening is 18924extremely small.) 18925 18926If @expr{M} is a vector, the result is one element taken at random from 18927the vector. All elements of the vector are given equal probabilities. 18928 18929@vindex RandSeed 18930The sequence of numbers produced by @kbd{k r} is completely random by 18931default, i.e., the sequence is seeded each time you start Calc using 18932the current time and other information. You can get a reproducible 18933sequence by storing a particular ``seed value'' in the Calc variable 18934@code{RandSeed}. Any integer will do for a seed; integers of from 1 18935to 12 digits are good. If you later store a different integer into 18936@code{RandSeed}, Calc will switch to a different pseudo-random 18937sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself 18938from the current time. If you store the same integer that you used 18939before back into @code{RandSeed}, you will get the exact same sequence 18940of random numbers as before. 18941 18942@pindex calc-rrandom 18943The @code{calc-rrandom} command (not on any key) produces a random real 18944number between zero and one. It is equivalent to @samp{random(1.0)}. 18945 18946@kindex k a 18947@pindex calc-random-again 18948The @kbd{k a} (@code{calc-random-again}) command produces another random 18949number, re-using the most recent value of @expr{M}. With a numeric 18950prefix argument @var{n}, it produces @var{n} more random numbers using 18951that value of @expr{M}. 18952 18953@kindex k h 18954@pindex calc-shuffle 18955@tindex shuffle 18956The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several 18957random values with no duplicates. The value on the top of the stack 18958specifies the set from which the random values are drawn, and may be any 18959of the @expr{M} formats described above. The numeric prefix argument 18960gives the length of the desired list. (If you do not provide a numeric 18961prefix argument, the length of the list is taken from the top of the 18962stack, and @expr{M} from second-to-top.) 18963 18964If @expr{M} is a floating-point number, zero, or an error form (so 18965that the random values are being drawn from the set of real numbers) 18966there is little practical difference between using @kbd{k h} and using 18967@kbd{k r} several times. But if the set of possible values consists 18968of just a few integers, or the elements of a vector, then there is 18969a very real chance that multiple @kbd{k r}'s will produce the same 18970number more than once. The @kbd{k h} command produces a vector whose 18971elements are always distinct. (Actually, there is a slight exception: 18972If @expr{M} is a vector, no given vector element will be drawn more 18973than once, but if several elements of @expr{M} are equal, they may 18974each make it into the result vector.) 18975 18976One use of @kbd{k h} is to rearrange a list at random. This happens 18977if the prefix argument is equal to the number of values in the list: 18978@kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list 18979@samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument 18980@var{n} is negative it is replaced by the size of the set represented 18981by @expr{M}. Naturally, this is allowed only when @expr{M} specifies 18982a small discrete set of possibilities. 18983 18984To do the equivalent of @kbd{k h} but with duplications allowed, 18985given @expr{M} on the stack and with @var{n} just entered as a numeric 18986prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use 18987@kbd{V M k r} to ``map'' the normal @kbd{k r} function over the 18988elements of this vector. @xref{Matrix Functions}. 18989 18990@menu 18991* Random Number Generator:: (Complete description of Calc's algorithm) 18992@end menu 18993 18994@node Random Number Generator, , Random Numbers, Random Numbers 18995@subsection Random Number Generator 18996 18997Calc's random number generator uses several methods to ensure that 18998the numbers it produces are highly random. Knuth's @emph{Art of 18999Computer Programming}, Volume II, contains a thorough description 19000of the theory of random number generators and their measurement and 19001characterization. 19002 19003If @code{RandSeed} has no stored value, Calc calls Emacs's built-in 19004@code{random} function to get a stream of random numbers, which it 19005then treats in various ways to avoid problems inherent in the simple 19006random number generators that many systems use to implement @code{random}. 19007 19008When Calc's random number generator is first invoked, it ``seeds'' 19009the low-level random sequence using the time of day, so that the 19010random number sequence will be different every time you use Calc. 19011 19012Since Emacs Lisp doesn't specify the range of values that will be 19013returned by its @code{random} function, Calc exercises the function 19014several times to estimate the range. When Calc subsequently uses 19015the @code{random} function, it takes only 10 bits of the result 19016near the most-significant end. (It avoids at least the bottom 19017four bits, preferably more, and also tries to avoid the top two 19018bits.) This strategy works well with the linear congruential 19019generators that are typically used to implement @code{random}. 19020 19021If @code{RandSeed} contains an integer, Calc uses this integer to 19022seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A, 19023computing 19024@texline @math{X_{n-55} - X_{n-24}}. 19025@infoline @expr{X_n-55 - X_n-24}). 19026This method expands the seed 19027value into a large table which is maintained internally; the variable 19028@code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]} 19029to indicate that the seed has been absorbed into this table. When 19030@code{RandSeed} contains a vector, @kbd{k r} and related commands 19031continue to use the same internal table as last time. There is no 19032way to extract the complete state of the random number generator 19033so that you can restart it from any point; you can only restart it 19034from the same initial seed value. A simple way to restart from the 19035same seed is to type @kbd{s r RandSeed} to get the seed vector, 19036@kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed} 19037to reseed the generator with that number. 19038 19039Calc uses a ``shuffling'' method as described in algorithm 3.2.2B 19040of Knuth. It fills a table with 13 random 10-bit numbers. Then, 19041to generate a new random number, it uses the previous number to 19042index into the table, picks the value it finds there as the new 19043random number, then replaces that table entry with a new value 19044obtained from a call to the base random number generator (either 19045the additive congruential generator or the @code{random} function 19046supplied by the system). If there are any flaws in the base 19047generator, shuffling will tend to even them out. But if the system 19048provides an excellent @code{random} function, shuffling will not 19049damage its randomness. 19050 19051To create a random integer of a certain number of digits, Calc 19052builds the integer three decimal digits at a time. For each group 19053of three digits, Calc calls its 10-bit shuffling random number generator 19054(which returns a value from 0 to 1023); if the random value is 1000 19055or more, Calc throws it out and tries again until it gets a suitable 19056value. 19057 19058To create a random floating-point number with precision @var{p}, Calc 19059simply creates a random @var{p}-digit integer and multiplies by 19060@texline @math{10^{-p}}. 19061@infoline @expr{10^-p}. 19062The resulting random numbers should be very clean, but note 19063that relatively small numbers will have few significant random digits. 19064In other words, with a precision of 12, you will occasionally get 19065numbers on the order of 19066@texline @math{10^{-9}} 19067@infoline @expr{10^-9} 19068or 19069@texline @math{10^{-10}}, 19070@infoline @expr{10^-10}, 19071but those numbers will only have two or three random digits since they 19072correspond to small integers times 19073@texline @math{10^{-12}}. 19074@infoline @expr{10^-12}. 19075 19076To create a random integer in the interval @samp{[0 .. @var{m})}, Calc 19077counts the digits in @var{m}, creates a random integer with three 19078additional digits, then reduces modulo @var{m}. Unless @var{m} is a 19079power of ten the resulting values will be very slightly biased toward 19080the lower numbers, but this bias will be less than 0.1%. (For example, 19081if @var{m} is 42, Calc will reduce a random integer less than 100000 19082modulo 42 to get a result less than 42. It is easy to show that the 19083numbers 40 and 41 will be only 2380/2381 as likely to result from this 19084modulo operation as numbers 39 and below.) If @var{m} is a power of 19085ten, however, the numbers should be completely unbiased. 19086 19087The Gaussian random numbers generated by @samp{random(0.0)} use the 19088``polar'' method described in Knuth section 3.4.1C@. This method 19089generates a pair of Gaussian random numbers at a time, so only every 19090other call to @samp{random(0.0)} will require significant calculations. 19091 19092@node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions 19093@section Combinatorial Functions 19094 19095@noindent 19096Commands relating to combinatorics and number theory begin with the 19097@kbd{k} key prefix. 19098 19099@kindex k g 19100@pindex calc-gcd 19101@tindex gcd 19102The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the 19103Greatest Common Divisor of two integers. It also accepts fractions; 19104the GCD of two fractions is defined by taking the GCD of the 19105numerators, and the LCM of the denominators. This definition is 19106consistent with the idea that @samp{a / gcd(a,x)} should yield an 19107integer for any @samp{a} and @samp{x}. For other types of arguments, 19108the operation is left in symbolic form. 19109 19110@kindex k l 19111@pindex calc-lcm 19112@tindex lcm 19113The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the 19114Least Common Multiple of two integers or fractions. The product of 19115the LCM and GCD of two numbers is equal to the absolute value of the 19116product of the numbers. 19117 19118@kindex k E 19119@pindex calc-extended-gcd 19120@tindex egcd 19121The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes 19122the GCD of two integers @expr{x} and @expr{y} and returns a vector 19123@expr{[g, a, b]} where 19124@texline @math{g = \gcd(x,y) = a x + b y}. 19125@infoline @expr{g = gcd(x,y) = a x + b y}. 19126 19127@kindex ! 19128@pindex calc-factorial 19129@tindex fact 19130@ignore 19131@mindex @null 19132@end ignore 19133@tindex ! 19134The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the 19135factorial of the number at the top of the stack. If the number is an 19136integer, the result is an exact integer. If the number is an 19137integer-valued float, the result is a floating-point approximation. If 19138the number is a non-integral real number, the generalized factorial is used, 19139as defined by the Euler Gamma function. Please note that computation of 19140large factorials can be slow; using floating-point format will help 19141since fewer digits must be maintained. The same is true of many of 19142the commands in this section. 19143 19144@kindex k d 19145@pindex calc-double-factorial 19146@tindex dfact 19147@ignore 19148@mindex @null 19149@end ignore 19150@tindex !! 19151The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command 19152computes the ``double factorial'' of an integer. For an even integer, 19153this is the product of even integers from 2 to @expr{N}. For an odd 19154integer, this is the product of odd integers from 3 to @expr{N}. If 19155the argument is an integer-valued float, the result is a floating-point 19156approximation. This function is undefined for negative even integers. 19157The notation @expr{N!!} is also recognized for double factorials. 19158 19159@kindex k c 19160@pindex calc-choose 19161@tindex choose 19162The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the 19163binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number 19164on the top of the stack and @expr{N} is second-to-top. If both arguments 19165are integers, the result is an exact integer. Otherwise, the result is a 19166floating-point approximation. The binomial coefficient is defined for all 19167real numbers by 19168@texline @math{N! \over M! (N-M)!\,}. 19169@infoline @expr{N! / M! (N-M)!}. 19170 19171@kindex H k c 19172@pindex calc-perm 19173@tindex perm 19174@ifnottex 19175The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the 19176number-of-permutations function @expr{N! / (N-M)!}. 19177@end ifnottex 19178@tex 19179The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the 19180number-of-perm\-utations function $N! \over (N-M)!\,$. 19181@end tex 19182 19183@kindex k b 19184@kindex H k b 19185@pindex calc-bernoulli-number 19186@tindex bern 19187The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command 19188computes a given Bernoulli number. The value at the top of the stack 19189is a nonnegative integer @expr{n} that specifies which Bernoulli number 19190is desired. The @kbd{H k b} command computes a Bernoulli polynomial, 19191taking @expr{n} from the second-to-top position and @expr{x} from the 19192top of the stack. If @expr{x} is a variable or formula the result is 19193a polynomial in @expr{x}; if @expr{x} is a number the result is a number. 19194 19195@kindex k e 19196@kindex H k e 19197@pindex calc-euler-number 19198@tindex euler 19199The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly 19200computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial. 19201Bernoulli and Euler numbers occur in the Taylor expansions of several 19202functions. 19203 19204@kindex k s 19205@kindex H k s 19206@pindex calc-stirling-number 19207@tindex stir1 19208@tindex stir2 19209The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command 19210computes a Stirling number of the first 19211@texline kind@tie{}@math{n \brack m}, 19212@infoline kind, 19213given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s} 19214[@code{stir2}] command computes a Stirling number of the second 19215@texline kind@tie{}@math{n \brace m}. 19216@infoline kind. 19217These are the number of @expr{m}-cycle permutations of @expr{n} objects, 19218and the number of ways to partition @expr{n} objects into @expr{m} 19219non-empty sets, respectively. 19220 19221@kindex k p 19222@pindex calc-prime-test 19223@cindex Primes 19224The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on 19225the top of the stack is prime. For integers less than eight million, the 19226answer is always exact and reasonably fast. For larger integers, a 19227probabilistic method is used (see Knuth vol.@: II, section 4.5.4, algorithm P). 19228The number is first checked against small prime factors (up to 13). Then, 19229any number of iterations of the algorithm are performed. Each step either 19230discovers that the number is non-prime, or substantially increases the 19231certainty that the number is prime. After a few steps, the chance that 19232a number was mistakenly described as prime will be less than one percent. 19233(Indeed, this is a worst-case estimate of the probability; in practice 19234even a single iteration is quite reliable.) After the @kbd{k p} command, 19235the number will be reported as definitely prime or non-prime if possible, 19236or otherwise ``probably'' prime with a certain probability of error. 19237 19238@ignore 19239@starindex 19240@end ignore 19241@tindex prime 19242The normal @kbd{k p} command performs one iteration of the primality 19243test. Pressing @kbd{k p} repeatedly for the same integer will perform 19244additional iterations. Also, @kbd{k p} with a numeric prefix performs 19245the specified number of iterations. There is also an algebraic function 19246@samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n} 19247is (probably) prime and 0 if not. 19248 19249@kindex k f 19250@pindex calc-prime-factors 19251@tindex prfac 19252The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command 19253attempts to decompose an integer into its prime factors. For numbers up 19254to 25 million, the answer is exact although it may take some time. The 19255result is a vector of the prime factors in increasing order. For larger 19256inputs, prime factors above 5000 may not be found, in which case the 19257last number in the vector will be an unfactored integer greater than 25 19258million (with a warning message). For negative integers, the first 19259element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and 19260@mathit{1}, the result is a list of the same number. 19261 19262@kindex k n 19263@pindex calc-next-prime 19264@ignore 19265@mindex nextpr@idots 19266@end ignore 19267@tindex nextprime 19268The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds 19269the next prime above a given number. Essentially, it searches by calling 19270@code{calc-prime-test} on successive integers until it finds one that 19271passes the test. This is quite fast for integers less than eight million, 19272but once the probabilistic test comes into play the search may be rather 19273slow. Ordinarily this command stops for any prime that passes one iteration 19274of the primality test. With a numeric prefix argument, a number must pass 19275the specified number of iterations before the search stops. (This only 19276matters when searching above eight million.) You can always use additional 19277@kbd{k p} commands to increase your certainty that the number is indeed 19278prime. 19279 19280@kindex I k n 19281@pindex calc-prev-prime 19282@ignore 19283@mindex prevpr@idots 19284@end ignore 19285@tindex prevprime 19286The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command 19287analogously finds the next prime less than a given number. 19288 19289@kindex k t 19290@pindex calc-totient 19291@tindex totient 19292The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the 19293Euler ``totient'' 19294@texline function@tie{}@math{\phi(n)}, 19295@infoline function, 19296the number of integers less than @expr{n} which 19297are relatively prime to @expr{n}. 19298 19299@kindex k m 19300@pindex calc-moebius 19301@tindex moebius 19302The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the 19303Möbius μ function. If the input number is a product of @expr{k} 19304distinct factors, this is @expr{(-1)^k}. If the input number has any 19305duplicate factors (i.e., can be divided by the same prime more than once), 19306the result is zero. 19307 19308@node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions 19309@section Probability Distribution Functions 19310 19311@noindent 19312The functions in this section compute various probability distributions. 19313For continuous distributions, this is the integral of the probability 19314density function from @expr{x} to infinity. (These are the ``upper 19315tail'' distribution functions; there are also corresponding ``lower 19316tail'' functions which integrate from minus infinity to @expr{x}.) 19317For discrete distributions, the upper tail function gives the sum 19318from @expr{x} to infinity; the lower tail function gives the sum 19319from minus infinity up to, but not including,@w{ }@expr{x}. 19320 19321To integrate from @expr{x} to @expr{y}, just use the distribution 19322function twice and subtract. For example, the probability that a 19323Gaussian random variable with mean 2 and standard deviation 1 will 19324lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)} 19325(``the probability that it is greater than 2.5, but not greater than 2.8''), 19326or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}. 19327 19328@kindex k B 19329@kindex I k B 19330@pindex calc-utpb 19331@tindex utpb 19332@tindex ltpb 19333The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the 19334binomial distribution. Push the parameters @var{n}, @var{p}, and 19335then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the 19336probability that an event will occur @var{x} or more times out 19337of @var{n} trials, if its probability of occurring in any given 19338trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is 19339the probability that the event will occur fewer than @var{x} times. 19340 19341The other probability distribution functions similarly take the 19342form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}] 19343and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters 19344@var{x}. The arguments to the algebraic functions are the value of 19345the random variable first, then whatever other parameters define the 19346distribution. Note these are among the few Calc functions where the 19347order of the arguments in algebraic form differs from the order of 19348arguments as found on the stack. (The random variable comes last on 19349the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5 19350k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to 19351recover the original arguments but substitute a new value for @expr{x}.) 19352 19353@kindex k C 19354@pindex calc-utpc 19355@tindex utpc 19356@ignore 19357@mindex @idots 19358@end ignore 19359@kindex I k C 19360@ignore 19361@mindex @null 19362@end ignore 19363@tindex ltpc 19364The @samp{utpc(x,v)} function uses the chi-square distribution with 19365@texline @math{\nu} 19366@infoline @expr{v} 19367degrees of freedom. It is the probability that a model is 19368correct if its chi-square statistic is @expr{x}. 19369 19370@kindex k F 19371@pindex calc-utpf 19372@tindex utpf 19373@ignore 19374@mindex @idots 19375@end ignore 19376@kindex I k F 19377@ignore 19378@mindex @null 19379@end ignore 19380@tindex ltpf 19381The @samp{utpf(F,v1,v2)} function uses the F distribution, used in 19382various statistical tests. The parameters 19383@texline @math{\nu_1} 19384@infoline @expr{v1} 19385and 19386@texline @math{\nu_2} 19387@infoline @expr{v2} 19388are the degrees of freedom in the numerator and denominator, 19389respectively, used in computing the statistic @expr{F}. 19390 19391@kindex k N 19392@pindex calc-utpn 19393@tindex utpn 19394@ignore 19395@mindex @idots 19396@end ignore 19397@kindex I k N 19398@ignore 19399@mindex @null 19400@end ignore 19401@tindex ltpn 19402The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution 19403with mean @expr{m} and standard deviation 19404@texline @math{\sigma}. 19405@infoline @expr{s}. 19406It is the probability that such a normal-distributed random variable 19407would exceed @expr{x}. 19408 19409@kindex k P 19410@pindex calc-utpp 19411@tindex utpp 19412@ignore 19413@mindex @idots 19414@end ignore 19415@kindex I k P 19416@ignore 19417@mindex @null 19418@end ignore 19419@tindex ltpp 19420The @samp{utpp(n,x)} function uses a Poisson distribution with 19421mean @expr{x}. It is the probability that @expr{n} or more such 19422Poisson random events will occur. 19423 19424@kindex k T 19425@pindex calc-ltpt 19426@tindex utpt 19427@ignore 19428@mindex @idots 19429@end ignore 19430@kindex I k T 19431@ignore 19432@mindex @null 19433@end ignore 19434@tindex ltpt 19435The @samp{utpt(t,v)} function uses the Student's ``t'' distribution 19436with 19437@texline @math{\nu} 19438@infoline @expr{v} 19439degrees of freedom. It is the probability that a 19440t-distributed random variable will be greater than @expr{t}. 19441(Note: This computes the distribution function 19442@texline @math{A(t|\nu)} 19443@infoline @expr{A(t|v)} 19444where 19445@texline @math{A(0|\nu) = 1} 19446@infoline @expr{A(0|v) = 1} 19447and 19448@texline @math{A(\infty|\nu) \to 0}. 19449@infoline @expr{A(inf|v) -> 0}. 19450The @code{UTPT} operation on the HP-48 uses a different definition which 19451returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.) 19452 19453While Calc does not provide inverses of the probability distribution 19454functions, the @kbd{a R} command can be used to solve for the inverse. 19455Since the distribution functions are monotonic, @kbd{a R} is guaranteed 19456to be able to find a solution given any initial guess. 19457@xref{Numerical Solutions}. 19458 19459@node Matrix Functions, Algebra, Scientific Functions, Top 19460@chapter Vector/Matrix Functions 19461 19462@noindent 19463Many of the commands described here begin with the @kbd{v} prefix. 19464(For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.) 19465The commands usually apply to both plain vectors and matrices; some 19466apply only to matrices or only to square matrices. If the argument 19467has the wrong dimensions the operation is left in symbolic form. 19468 19469Vectors are entered and displayed using @samp{[a,b,c]} notation. 19470Matrices are vectors of which all elements are vectors of equal length. 19471(Though none of the standard Calc commands use this concept, a 19472three-dimensional matrix or rank-3 tensor could be defined as a 19473vector of matrices, and so on.) 19474 19475@menu 19476* Packing and Unpacking:: 19477* Building Vectors:: 19478* Extracting Elements:: 19479* Manipulating Vectors:: 19480* Vector and Matrix Arithmetic:: 19481* Set Operations:: 19482* Statistical Operations:: 19483* Reducing and Mapping:: 19484* Vector and Matrix Formats:: 19485@end menu 19486 19487@node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions 19488@section Packing and Unpacking 19489 19490@noindent 19491Calc's ``pack'' and ``unpack'' commands collect stack entries to build 19492composite objects such as vectors and complex numbers. They are 19493described in this chapter because they are most often used to build 19494vectors. 19495 19496@kindex v p 19497@kindex V p 19498@pindex calc-pack 19499The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several 19500elements from the stack into a matrix, complex number, HMS form, error 19501form, etc. It uses a numeric prefix argument to specify the kind of 19502object to be built; this argument is referred to as the ``packing mode.'' 19503If the packing mode is a nonnegative integer, a vector of that 19504length is created. For example, @kbd{C-u 5 v p} will pop the top 19505five stack elements and push back a single vector of those five 19506elements. (@kbd{C-u 0 v p} simply creates an empty vector.) 19507 19508The same effect can be had by pressing @kbd{[} to push an incomplete 19509vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak 19510the incomplete object up past a certain number of elements, and 19511then pressing @kbd{]} to complete the vector. 19512 19513Negative packing modes create other kinds of composite objects: 19514 19515@table @cite 19516@item -1 19517Two values are collected to build a complex number. For example, 19518@kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number 19519@expr{(5, 7)}. The result is always a rectangular complex 19520number. The two input values must both be real numbers, 19521i.e., integers, fractions, or floats. If they are not, Calc 19522will instead build a formula like @samp{a + (0, 1) b}. (The 19523other packing modes also create a symbolic answer if the 19524components are not suitable.) 19525 19526@item -2 19527Two values are collected to build a polar complex number. 19528The first is the magnitude; the second is the phase expressed 19529in either degrees or radians according to the current angular 19530mode. 19531 19532@item -3 19533Three values are collected into an HMS form. The first 19534two values (hours and minutes) must be integers or 19535integer-valued floats. The third value may be any real 19536number. 19537 19538@item -4 19539Two values are collected into an error form. The inputs 19540may be real numbers or formulas. 19541 19542@item -5 19543Two values are collected into a modulo form. The inputs 19544must be real numbers. 19545 19546@item -6 19547Two values are collected into the interval @samp{[a .. b]}. 19548The inputs may be real numbers, HMS or date forms, or formulas. 19549 19550@item -7 19551Two values are collected into the interval @samp{[a .. b)}. 19552 19553@item -8 19554Two values are collected into the interval @samp{(a .. b]}. 19555 19556@item -9 19557Two values are collected into the interval @samp{(a .. b)}. 19558 19559@item -10 19560Two integer values are collected into a fraction. 19561 19562@item -11 19563Two values are collected into a floating-point number. 19564The first is the mantissa; the second, which must be an 19565integer, is the exponent. The result is the mantissa 19566times ten to the power of the exponent. 19567 19568@item -12 19569This is treated the same as @mathit{-11} by the @kbd{v p} command. 19570When unpacking, @mathit{-12} specifies that a floating-point mantissa 19571is desired. 19572 19573@item -13 19574A real number is converted into a date form. 19575 19576@item -14 19577Three numbers (year, month, day) are packed into a pure date form. 19578 19579@item -15 19580Six numbers are packed into a date/time form. 19581@end table 19582 19583With any of the two-input negative packing modes, either or both 19584of the inputs may be vectors. If both are vectors of the same 19585length, the result is another vector made by packing corresponding 19586elements of the input vectors. If one input is a vector and the 19587other is a plain number, the number is packed along with each vector 19588element to produce a new vector. For example, @kbd{C-u -4 v p} 19589could be used to convert a vector of numbers and a vector of errors 19590into a single vector of error forms; @kbd{C-u -5 v p} could convert 19591a vector of numbers and a single number @var{M} into a vector of 19592numbers modulo @var{M}. 19593 19594If you don't give a prefix argument to @kbd{v p}, it takes 19595the packing mode from the top of the stack. The elements to 19596be packed then begin at stack level 2. Thus 19597@kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to 19598enter the error form @samp{1 +/- 2}. 19599 19600If the packing mode taken from the stack is a vector, the result is a 19601matrix with the dimensions specified by the elements of the vector, 19602which must each be integers. For example, if the packing mode is 19603@samp{[2, 3]}, then six numbers will be taken from the stack and 19604returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}. 19605 19606If any elements of the vector are negative, other kinds of 19607packing are done at that level as described above. For 19608example, @samp{[2, 3, -4]} takes 12 objects and creates a 19609@texline @math{2\times3} 19610@infoline 2x3 19611matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}. 19612Also, @samp{[-4, -10]} will convert four integers into an 19613error form consisting of two fractions: @samp{a:b +/- c:d}. 19614 19615@ignore 19616@starindex 19617@end ignore 19618@tindex pack 19619There is an equivalent algebraic function, 19620@samp{pack(@var{mode}, @var{items})} where @var{mode} is a 19621packing mode (an integer or a vector of integers) and @var{items} 19622is a vector of objects to be packed (re-packed, really) according 19623to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])} 19624yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is 19625left in symbolic form if the packing mode is invalid, or if the 19626number of data items does not match the number of items required 19627by the mode. 19628 19629@kindex v u 19630@kindex V u 19631@pindex calc-unpack 19632The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex 19633number, HMS form, or other composite object on the top of the stack and 19634``unpacks'' it, pushing each of its elements onto the stack as separate 19635objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value 19636at the top of the stack is a formula, @kbd{v u} unpacks it by pushing 19637each of the arguments of the top-level operator onto the stack. 19638 19639You can optionally give a numeric prefix argument to @kbd{v u} 19640to specify an explicit (un)packing mode. If the packing mode is 19641negative and the input is actually a vector or matrix, the result 19642will be two or more similar vectors or matrices of the elements. 19643For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]}, 19644the result of @kbd{C-u -4 v u} will be the two vectors 19645@samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}. 19646 19647Note that the prefix argument can have an effect even when the input is 19648not a vector. For example, if the input is the number @mathit{-5}, then 19649@kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5} 19650when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5 19651and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5} 19652and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational 19653number). Plain @kbd{v u} with this input would complain that the input 19654is not a composite object. 19655 19656Unpacking mode @mathit{-11} converts a float into an integer mantissa and 19657an integer exponent, where the mantissa is not divisible by 10 19658(except that 0.0 is represented by a mantissa and exponent of 0). 19659Unpacking mode @mathit{-12} converts a float into a floating-point mantissa 19660and integer exponent, where the mantissa (for non-zero numbers) 19661is guaranteed to lie in the range [1 .. 10). In both cases, 19662the mantissa is shifted left or right (and the exponent adjusted 19663to compensate) in order to satisfy these constraints. 19664 19665Positive unpacking modes are treated differently than for @kbd{v p}. 19666A mode of 1 is much like plain @kbd{v u} with no prefix argument, 19667except that in addition to the components of the input object, 19668a suitable packing mode to re-pack the object is also pushed. 19669Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the 19670original object. 19671 19672A mode of 2 unpacks two levels of the object; the resulting 19673re-packing mode will be a vector of length 2. This might be used 19674to unpack a matrix, say, or a vector of error forms. Higher 19675unpacking modes unpack the input even more deeply. 19676 19677@ignore 19678@starindex 19679@end ignore 19680@tindex unpack 19681There are two algebraic functions analogous to @kbd{v u}. 19682The @samp{unpack(@var{mode}, @var{item})} function unpacks the 19683@var{item} using the given @var{mode}, returning the result as 19684a vector of components. Here the @var{mode} must be an 19685integer, not a vector. For example, @samp{unpack(-4, a +/- b)} 19686returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}. 19687 19688@ignore 19689@starindex 19690@end ignore 19691@tindex unpackt 19692The @code{unpackt} function is like @code{unpack} but instead 19693of returning a simple vector of items, it returns a vector of 19694two things: The mode, and the vector of items. For example, 19695@samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]}, 19696and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}. 19697The identity for re-building the original object is 19698@samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The 19699@code{apply} function builds a function call given the function 19700name and a vector of arguments.) 19701 19702@cindex Numerator of a fraction, extracting 19703Subscript notation is a useful way to extract a particular part 19704of an object. For example, to get the numerator of a rational 19705number, you can use @samp{unpack(-10, @var{x})_1}. 19706 19707@node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions 19708@section Building Vectors 19709 19710@noindent 19711Vectors and matrices can be added, 19712subtracted, multiplied, and divided; @pxref{Basic Arithmetic}. 19713 19714@kindex | 19715@pindex calc-concat 19716@ignore 19717@mindex @null 19718@end ignore 19719@tindex | 19720The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors 19721into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack 19722will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments 19723are matrices, the rows of the first matrix are concatenated with the 19724rows of the second. (In other words, two matrices are just two vectors 19725of row-vectors as far as @kbd{|} is concerned.) 19726 19727If either argument to @kbd{|} is a scalar (a non-vector), it is treated 19728like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |} 19729produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a 19730matrix and the other is a plain vector, the vector is treated as a 19731one-row matrix. 19732 19733@kindex H | 19734@tindex append 19735The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates 19736two vectors without any special cases. Both inputs must be vectors. 19737Whether or not they are matrices is not taken into account. If either 19738argument is a scalar, the @code{append} function is left in symbolic form. 19739See also @code{cons} and @code{rcons} below. 19740 19741@kindex I | 19742@kindex H I | 19743The @kbd{I |} and @kbd{H I |} commands are similar, but they use their 19744two stack arguments in the opposite order. Thus @kbd{I |} is equivalent 19745to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster. 19746 19747@kindex v d 19748@kindex V d 19749@pindex calc-diag 19750@tindex diag 19751The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal 19752square matrix. The optional numeric prefix gives the number of rows 19753and columns in the matrix. If the value at the top of the stack is a 19754vector, the elements of the vector are used as the diagonal elements; the 19755prefix, if specified, must match the size of the vector. If the value on 19756the stack is a scalar, it is used for each element on the diagonal, and 19757the prefix argument is required. 19758 19759To build a constant square matrix, e.g., a 19760@texline @math{3\times3} 19761@infoline 3x3 19762matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero 19763matrix first and then add a constant value to that matrix. (Another 19764alternative would be to use @kbd{v b} and @kbd{v a}; see below.) 19765 19766@kindex v i 19767@kindex V i 19768@pindex calc-ident 19769@tindex idn 19770The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity 19771matrix of the specified size. It is a convenient form of @kbd{v d} 19772where the diagonal element is always one. If no prefix argument is given, 19773this command prompts for one. 19774 19775In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)}, 19776except that @expr{a} is required to be a scalar (non-vector) quantity. 19777If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an 19778identity matrix of unknown size. Calc can operate algebraically on 19779such generic identity matrices, and if one is combined with a matrix 19780whose size is known, it is converted automatically to an identity 19781matrix of a suitable matching size. The @kbd{v i} command with an 19782argument of zero creates a generic identity matrix, @samp{idn(1)}. 19783Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic 19784identity matrices are immediately expanded to the current default 19785dimensions. 19786 19787@kindex v x 19788@kindex V x 19789@pindex calc-index 19790@tindex index 19791The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector 19792of consecutive integers from 1 to @var{n}, where @var{n} is the numeric 19793prefix argument. If you do not provide a prefix argument, you will be 19794prompted to enter a suitable number. If @var{n} is negative, the result 19795is a vector of negative integers from @var{n} to @mathit{-1}. 19796 19797With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes 19798three values from the stack: @var{n}, @var{start}, and @var{incr} (with 19799@var{incr} at top-of-stack). Counting starts at @var{start} and increases 19800by @var{incr} for successive vector elements. If @var{start} or @var{n} 19801is in floating-point format, the resulting vector elements will also be 19802floats. Note that @var{start} and @var{incr} may in fact be any kind 19803of numbers or formulas. 19804 19805When @var{start} and @var{incr} are specified, a negative @var{n} has a 19806different interpretation: It causes a geometric instead of arithmetic 19807sequence to be generated. For example, @samp{index(-3, a, b)} produces 19808@samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form, 19809@samp{index(@var{n}, @var{start})}, the default value for @var{incr} 19810is one for positive @var{n} or two for negative @var{n}. 19811 19812@kindex v b 19813@kindex V b 19814@pindex calc-build-vector 19815@tindex cvec 19816The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a 19817vector of @var{n} copies of the value on the top of the stack, where @var{n} 19818is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)} 19819can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}. 19820(Interactively, just use @kbd{v b} twice: once to build a row, then again 19821to build a matrix of copies of that row.) 19822 19823@kindex v h 19824@kindex V h 19825@kindex I v h 19826@kindex I V h 19827@pindex calc-head 19828@pindex calc-tail 19829@tindex head 19830@tindex tail 19831The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first 19832element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}] 19833function returns the vector with its first element removed. In both 19834cases, the argument must be a non-empty vector. 19835 19836@kindex v k 19837@kindex V k 19838@pindex calc-cons 19839@tindex cons 19840The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h} 19841and a vector @var{t} from the stack, and produces the vector whose head is 19842@var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except 19843if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors 19844whereas @code{cons} will insert @var{h} at the front of the vector @var{t}. 19845 19846@kindex H v h 19847@kindex H V h 19848@tindex rhead 19849@ignore 19850@mindex @idots 19851@end ignore 19852@kindex H I v h 19853@kindex H I V h 19854@ignore 19855@mindex @null 19856@end ignore 19857@kindex H v k 19858@kindex H V k 19859@ignore 19860@mindex @null 19861@end ignore 19862@tindex rtail 19863@ignore 19864@mindex @null 19865@end ignore 19866@tindex rcons 19867Each of these three functions also accepts the Hyperbolic flag [@code{rhead}, 19868@code{rtail}, @code{rcons}] in which case @var{t} instead represents 19869the @emph{last} single element of the vector, with @var{h} 19870representing the remainder of the vector. Thus the vector 19871@samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}. 19872Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]}, 19873@samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}. 19874 19875@node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions 19876@section Extracting Vector Elements 19877 19878@noindent 19879@kindex v r 19880@kindex V r 19881@pindex calc-mrow 19882@tindex mrow 19883The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of 19884the matrix on the top of the stack, or one element of the plain vector on 19885the top of the stack. The row or element is specified by the numeric 19886prefix argument; the default is to prompt for the row or element number. 19887The matrix or vector is replaced by the specified row or element in the 19888form of a vector or scalar, respectively. 19889 19890@cindex Permutations, applying 19891With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of 19892the element or row from the top of the stack, and the vector or matrix 19893from the second-to-top position. If the index is itself a vector of 19894integers, the result is a vector of the corresponding elements of the 19895input vector, or a matrix of the corresponding rows of the input matrix. 19896This command can be used to obtain any permutation of a vector. 19897 19898With @kbd{C-u}, if the index is an interval form with integer components, 19899it is interpreted as a range of indices and the corresponding subvector or 19900submatrix is returned. 19901 19902@cindex Subscript notation 19903@kindex a _ 19904@pindex calc-subscript 19905@tindex subscr 19906@tindex _ 19907Subscript notation in algebraic formulas (@samp{a_b}) stands for the 19908Calc function @code{subscr}, which is synonymous with @code{mrow}. 19909Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if 19910@expr{k} is one, two, or three, respectively. A double subscript 19911(@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will 19912access the element at row @expr{i}, column @expr{j} of a matrix. 19913The @kbd{a _} (@code{calc-subscript}) command creates a subscript 19914formula @samp{a_b} out of two stack entries. (It is on the @kbd{a} 19915``algebra'' prefix because subscripted variables are often used 19916purely as an algebraic notation.) 19917 19918@tindex mrrow 19919Given a negative prefix argument, @kbd{v r} instead deletes one row or 19920element from the matrix or vector on the top of the stack. Thus 19921@kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r} 19922replaces the matrix with the same matrix with its second row removed. 19923In algebraic form this function is called @code{mrrow}. 19924 19925@tindex getdiag 19926Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements 19927of a square matrix in the form of a vector. In algebraic form this 19928function is called @code{getdiag}. 19929 19930@kindex v c 19931@kindex V c 19932@pindex calc-mcol 19933@tindex mcol 19934@tindex mrcol 19935The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is 19936the analogous operation on columns of a matrix. Given a plain vector 19937it extracts (or removes) one element, just like @kbd{v r}. If the 19938index in @kbd{C-u v c} is an interval or vector and the argument is a 19939matrix, the result is a submatrix with only the specified columns 19940retained (and possibly permuted in the case of a vector index). 19941 19942To extract a matrix element at a given row and column, use @kbd{v r} to 19943extract the row as a vector, then @kbd{v c} to extract the column element 19944from that vector. In algebraic formulas, it is often more convenient to 19945use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j} 19946of matrix @expr{m}. 19947 19948@kindex v s 19949@kindex V s 19950@pindex calc-subvector 19951@tindex subvec 19952The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts 19953a subvector of a vector. The arguments are the vector, the starting 19954index, and the ending index, with the ending index in the top-of-stack 19955position. The starting index indicates the first element of the vector 19956to take. The ending index indicates the first element @emph{past} the 19957range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces 19958the subvector @samp{[b, c]}. You could get the same result using 19959@samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}. 19960 19961If either the start or the end index is zero or negative, it is 19962interpreted as relative to the end of the vector. Thus 19963@samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In 19964the algebraic form, the end index can be omitted in which case it 19965is taken as zero, i.e., elements from the starting element to the 19966end of the vector are used. The infinity symbol, @code{inf}, also 19967has this effect when used as the ending index. 19968 19969@kindex I v s 19970@kindex I V s 19971@tindex rsubvec 19972With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector 19973from a vector. The arguments are interpreted the same as for the 19974normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)} 19975produces @samp{[a, d, e]}. It is always true that @code{subvec} and 19976@code{rsubvec} return complementary parts of the input vector. 19977 19978@xref{Selecting Subformulas}, for an alternative way to operate on 19979vectors one element at a time. 19980 19981@node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions 19982@section Manipulating Vectors 19983 19984@noindent 19985@kindex v l 19986@kindex V l 19987@pindex calc-vlength 19988@tindex vlen 19989The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the 19990length of a vector. The length of a non-vector is considered to be zero. 19991Note that matrices are just vectors of vectors for the purposes of this 19992command. 19993 19994@kindex H v l 19995@kindex H V l 19996@tindex mdims 19997With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector 19998of the dimensions of a vector, matrix, or higher-order object. For 19999example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since 20000its argument is a 20001@texline @math{2\times3} 20002@infoline 2x3 20003matrix. 20004 20005@kindex v f 20006@kindex V f 20007@pindex calc-vector-find 20008@tindex find 20009The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches 20010along a vector for the first element equal to a given target. The target 20011is on the top of the stack; the vector is in the second-to-top position. 20012If a match is found, the result is the index of the matching element. 20013Otherwise, the result is zero. The numeric prefix argument, if given, 20014allows you to select any starting index for the search. 20015 20016@kindex v a 20017@kindex V a 20018@pindex calc-arrange-vector 20019@tindex arrange 20020@cindex Arranging a matrix 20021@cindex Reshaping a matrix 20022@cindex Flattening a matrix 20023The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command 20024rearranges a vector to have a certain number of columns and rows. The 20025numeric prefix argument specifies the number of columns; if you do not 20026provide an argument, you will be prompted for the number of columns. 20027The vector or matrix on the top of the stack is @dfn{flattened} into a 20028plain vector. If the number of columns is nonzero, this vector is 20029then formed into a matrix by taking successive groups of @var{n} elements. 20030If the number of columns does not evenly divide the number of elements 20031in the vector, the last row will be short and the result will not be 20032suitable for use as a matrix. For example, with the matrix 20033@samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces 20034@samp{[[1, 2, 3, 4]]} (a 20035@texline @math{1\times4} 20036@infoline 1x4 20037matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a 20038@texline @math{4\times1} 20039@infoline 4x1 20040matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original 20041@texline @math{2\times2} 20042@infoline 2x2 20043matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a 20044matrix), and @kbd{v a 0} produces the flattened list 20045@samp{[1, 2, @w{3, 4}]}. 20046 20047@cindex Sorting data 20048@kindex v S 20049@kindex V S 20050@kindex I v S 20051@kindex I V S 20052@pindex calc-sort 20053@tindex sort 20054@tindex rsort 20055The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of 20056a vector into increasing order. Real numbers, real infinities, and 20057constant interval forms come first in this ordering; next come other 20058kinds of numbers, then variables (in alphabetical order), then finally 20059come formulas and other kinds of objects; these are sorted according 20060to a kind of lexicographic ordering with the useful property that 20061one vector is less or greater than another if the first corresponding 20062unequal elements are less or greater, respectively. Since quoted strings 20063are stored by Calc internally as vectors of ASCII character codes 20064(@pxref{Strings}), this means vectors of strings are also sorted into 20065alphabetical order by this command. 20066 20067The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order. 20068 20069@cindex Permutation, inverse of 20070@cindex Inverse of permutation 20071@cindex Index tables 20072@cindex Rank tables 20073@kindex v G 20074@kindex V G 20075@kindex I v G 20076@kindex I V G 20077@pindex calc-grade 20078@tindex grade 20079@tindex rgrade 20080The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command 20081produces an index table or permutation vector which, if applied to the 20082input vector (as the index of @kbd{C-u v r}, say), would sort the vector. 20083A permutation vector is just a vector of integers from 1 to @var{n}, where 20084each integer occurs exactly once. One application of this is to sort a 20085matrix of data rows using one column as the sort key; extract that column, 20086grade it with @kbd{V G}, then use the result to reorder the original matrix 20087with @kbd{C-u v r}. Another interesting property of the @code{V G} command 20088is that, if the input is itself a permutation vector, the result will 20089be the inverse of the permutation. The inverse of an index table is 20090a rank table, whose @var{k}th element says where the @var{k}th original 20091vector element will rest when the vector is sorted. To get a rank 20092table, just use @kbd{V G V G}. 20093 20094With the Inverse flag, @kbd{I V G} produces an index table that would 20095sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G} 20096use a ``stable'' sorting algorithm, i.e., any two elements which are equal 20097will not be moved out of their original order. Generally there is no way 20098to tell with @kbd{V S}, since two elements which are equal look the same, 20099but with @kbd{V G} this can be an important issue. In the matrix-of-rows 20100example, suppose you have names and telephone numbers as two columns and 20101you wish to sort by phone number primarily, and by name when the numbers 20102are equal. You can sort the data matrix by names first, and then again 20103by phone numbers. Because the sort is stable, any two rows with equal 20104phone numbers will remain sorted by name even after the second sort. 20105 20106@cindex Histograms 20107@kindex v H 20108@kindex V H 20109@pindex calc-histogram 20110@ignore 20111@mindex histo@idots 20112@end ignore 20113@tindex histogram 20114The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a 20115histogram of a vector of numbers. Vector elements are assumed to be 20116integers or real numbers in the range [0..@var{n}) for some ``number of 20117bins'' @var{n}, which is the numeric prefix argument given to the 20118command. The result is a vector of @var{n} counts of how many times 20119each value appeared in the original vector. Non-integers in the input 20120are rounded down to integers. Any vector elements outside the specified 20121range are ignored. (You can tell if elements have been ignored by noting 20122that the counts in the result vector don't add up to the length of the 20123input vector.) 20124 20125If no prefix is given, then you will be prompted for a vector which 20126will be used to determine the bins. (If a positive integer is given at 20127this prompt, it will be still treated as if it were given as a 20128prefix.) Each bin will consist of the interval of numbers closest to 20129the corresponding number of this new vector; if the vector 20130@expr{[a, b, c, ...]} is entered at the prompt, the bins will be 20131@expr{(-inf, (a+b)/2]}, @expr{((a+b)/2, (b+c)/2]}, etc. The result of 20132this command will be a vector counting how many elements of the 20133original vector are in each bin. 20134 20135The result will then be a vector with the same length as this new vector; 20136each element of the new vector will be replaced by the number of 20137elements of the original vector which are closest to it. 20138 20139@kindex H v H 20140@kindex H V H 20141With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack. 20142The second-to-top vector is the list of numbers as before. The top 20143vector is an equal-sized list of ``weights'' to attach to the elements 20144of the data vector. For example, if the first data element is 4.2 and 20145the first weight is 10, then 10 will be added to bin 4 of the result 20146vector. Without the hyperbolic flag, every element has a weight of one. 20147 20148@kindex v t 20149@kindex V t 20150@pindex calc-transpose 20151@tindex trn 20152The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes 20153the transpose of the matrix at the top of the stack. If the argument 20154is a plain vector, it is treated as a row vector and transposed into 20155a one-column matrix. 20156 20157@kindex v v 20158@kindex V v 20159@pindex calc-reverse-vector 20160@tindex rev 20161The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses 20162a vector end-for-end. Given a matrix, it reverses the order of the rows. 20163(To reverse the columns instead, just use @kbd{v t v v v t}. The same 20164principle can be used to apply other vector commands to the columns of 20165a matrix.) 20166 20167@kindex v m 20168@kindex V m 20169@pindex calc-mask-vector 20170@tindex vmask 20171The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses 20172one vector as a mask to extract elements of another vector. The mask 20173is in the second-to-top position; the target vector is on the top of 20174the stack. These vectors must have the same length. The result is 20175the same as the target vector, but with all elements which correspond 20176to zeros in the mask vector deleted. Thus, for example, 20177@samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}. 20178@xref{Logical Operations}. 20179 20180@kindex v e 20181@kindex V e 20182@pindex calc-expand-vector 20183@tindex vexp 20184The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command 20185expands a vector according to another mask vector. The result is a 20186vector the same length as the mask, but with nonzero elements replaced 20187by successive elements from the target vector. The length of the target 20188vector is normally the number of nonzero elements in the mask. If the 20189target vector is longer, its last few elements are lost. If the target 20190vector is shorter, the last few nonzero mask elements are left 20191unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])} 20192produces @samp{[a, 0, b, 0, 7]}. 20193 20194@kindex H v e 20195@kindex H V e 20196With the Hyperbolic flag, @kbd{H v e} takes a filler value from the 20197top of the stack; the mask and target vectors come from the third and 20198second elements of the stack. This filler is used where the mask is 20199zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces 20200@samp{[a, z, c, z, 7]}. If the filler value is itself a vector, 20201then successive values are taken from it, so that the effect is to 20202interleave two vectors according to the mask: 20203@samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces 20204@samp{[a, x, b, 7, y, 0]}. 20205 20206Another variation on the masking idea is to combine @samp{[a, b, c, d, e]} 20207with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}. 20208You can accomplish this with @kbd{V M a &}, mapping the logical ``and'' 20209operation across the two vectors. @xref{Logical Operations}. Note that 20210the @code{? :} operation also discussed there allows other types of 20211masking using vectors. 20212 20213@node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions 20214@section Vector and Matrix Arithmetic 20215 20216@noindent 20217Basic arithmetic operations like addition and multiplication are defined 20218for vectors and matrices as well as for numbers. Division of matrices, in 20219the sense of multiplying by the inverse, is supported. (Division by a 20220matrix actually uses LU-decomposition for greater accuracy and speed.) 20221@xref{Basic Arithmetic}. 20222 20223The following functions are applied element-wise if their arguments are 20224vectors or matrices: @code{change-sign}, @code{conj}, @code{arg}, 20225@code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean}, 20226@code{float}, @code{frac}. @xref{Function Index}. 20227 20228@kindex v J 20229@kindex V J 20230@pindex calc-conj-transpose 20231@tindex ctrn 20232The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes 20233the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}. 20234 20235@ignore 20236@mindex A 20237@end ignore 20238@kindex A @r{(vectors)} 20239@pindex calc-abs (vectors) 20240@ignore 20241@mindex abs 20242@end ignore 20243@tindex abs (vectors) 20244The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the 20245Frobenius norm of a vector or matrix argument. This is the square 20246root of the sum of the squares of the absolute values of the 20247elements of the vector or matrix. If the vector is interpreted as 20248a point in two- or three-dimensional space, this is the distance 20249from that point to the origin. 20250 20251@kindex v n 20252@kindex V n 20253@pindex calc-rnorm 20254@tindex rnorm 20255The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes the 20256infinity-norm of a vector, or the row norm of a matrix. For a plain 20257vector, this is the maximum of the absolute values of the elements. For 20258a matrix, this is the maximum of the row-absolute-value-sums, i.e., of 20259the sums of the absolute values of the elements along the various rows. 20260 20261@kindex v N 20262@kindex V N 20263@pindex calc-cnorm 20264@tindex cnorm 20265The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes 20266the one-norm of a vector, or column norm of a matrix. For a plain 20267vector, this is the sum of the absolute values of the elements. 20268For a matrix, this is the maximum of the column-absolute-value-sums. 20269General @expr{k}-norms for @expr{k} other than one or infinity are 20270not provided. However, the 2-norm (or Frobenius norm) is provided for 20271vectors by the @kbd{A} (@code{calc-abs}) command. 20272 20273@kindex v C 20274@kindex V C 20275@pindex calc-cross 20276@tindex cross 20277The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the 20278right-handed cross product of two vectors, each of which must have 20279exactly three elements. 20280 20281@ignore 20282@mindex & 20283@end ignore 20284@kindex & @r{(matrices)} 20285@pindex calc-inv (matrices) 20286@ignore 20287@mindex inv 20288@end ignore 20289@tindex inv (matrices) 20290The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the 20291inverse of a square matrix. If the matrix is singular, the inverse 20292operation is left in symbolic form. Matrix inverses are recorded so 20293that once an inverse (or determinant) of a particular matrix has been 20294computed, the inverse and determinant of the matrix can be recomputed 20295quickly in the future. 20296 20297If the argument to @kbd{&} is a plain number @expr{x}, this 20298command simply computes @expr{1/x}. This is okay, because the 20299@samp{/} operator also does a matrix inversion when dividing one 20300by a matrix. 20301 20302@kindex v D 20303@kindex V D 20304@pindex calc-mdet 20305@tindex det 20306The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the 20307determinant of a square matrix. 20308 20309@kindex v L 20310@kindex V L 20311@pindex calc-mlud 20312@tindex lud 20313The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the 20314LU decomposition of a matrix. The result is a list of three matrices 20315which, when multiplied together left-to-right, form the original matrix. 20316The first is a permutation matrix that arises from pivoting in the 20317algorithm, the second is lower-triangular with ones on the diagonal, 20318and the third is upper-triangular. 20319 20320@kindex v T 20321@kindex V T 20322@pindex calc-mtrace 20323@tindex tr 20324The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the 20325trace of a square matrix. This is defined as the sum of the diagonal 20326elements of the matrix. 20327 20328@kindex v K 20329@kindex V K 20330@pindex calc-kron 20331@tindex kron 20332The @kbd{V K} (@code{calc-kron}) [@code{kron}] command computes 20333the Kronecker product of two matrices. 20334 20335@node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions 20336@section Set Operations using Vectors 20337 20338@noindent 20339@cindex Sets, as vectors 20340Calc includes several commands which interpret vectors as @dfn{sets} of 20341objects. A set is a collection of objects; any given object can appear 20342only once in the set. Calc stores sets as vectors of objects in 20343sorted order. Objects in a Calc set can be any of the usual things, 20344such as numbers, variables, or formulas. Two set elements are considered 20345equal if they are identical, except that numerically equal numbers like 20346the integer 4 and the float 4.0 are considered equal even though they 20347are not ``identical.'' Variables are treated like plain symbols without 20348attached values by the set operations; subtracting the set @samp{[b]} 20349from @samp{[a, b]} always yields the set @samp{[a]} even though if 20350the variables @samp{a} and @samp{b} both equaled 17, you might 20351expect the answer @samp{[]}. 20352 20353If a set contains interval forms, then it is assumed to be a set of 20354real numbers. In this case, all set operations require the elements 20355of the set to be only things that are allowed in intervals: Real 20356numbers, plus and minus infinity, HMS forms, and date forms. If 20357there are variables or other non-real objects present in a real set, 20358all set operations on it will be left in unevaluated form. 20359 20360If the input to a set operation is a plain number or interval form 20361@var{a}, it is treated like the one-element vector @samp{[@var{a}]}. 20362The result is always a vector, except that if the set consists of a 20363single interval, the interval itself is returned instead. 20364 20365@xref{Logical Operations}, for the @code{in} function which tests if 20366a certain value is a member of a given set. To test if the set @expr{A} 20367is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}. 20368 20369@kindex v + 20370@kindex V + 20371@pindex calc-remove-duplicates 20372@tindex rdup 20373The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command 20374converts an arbitrary vector into set notation. It works by sorting 20375the vector as if by @kbd{V S}, then removing duplicates. (For example, 20376@kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then 20377reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as 20378necessary. You rarely need to use @kbd{V +} explicitly, since all the 20379other set-based commands apply @kbd{V +} to their inputs before using 20380them. 20381 20382@kindex v V 20383@kindex V V 20384@pindex calc-set-union 20385@tindex vunion 20386The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes 20387the union of two sets. An object is in the union of two sets if and 20388only if it is in either (or both) of the input sets. (You could 20389accomplish the same thing by concatenating the sets with @kbd{|}, 20390then using @kbd{V +}.) 20391 20392@kindex v ^ 20393@kindex V ^ 20394@pindex calc-set-intersect 20395@tindex vint 20396The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes 20397the intersection of two sets. An object is in the intersection if 20398and only if it is in both of the input sets. Thus if the input 20399sets are disjoint, i.e., if they share no common elements, the result 20400will be the empty vector @samp{[]}. Note that the characters @kbd{V} 20401and @kbd{^} were chosen to be close to the conventional mathematical 20402notation for set 20403@texline union@tie{}(@math{A \cup B}) 20404@infoline union 20405and 20406@texline intersection@tie{}(@math{A \cap B}). 20407@infoline intersection. 20408 20409@kindex v - 20410@kindex V - 20411@pindex calc-set-difference 20412@tindex vdiff 20413The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes 20414the difference between two sets. An object is in the difference 20415@expr{A - B} if and only if it is in @expr{A} but not in @expr{B}. 20416Thus subtracting @samp{[y,z]} from a set will remove the elements 20417@samp{y} and @samp{z} if they are present. You can also think of this 20418as a general @dfn{set complement} operator; if @expr{A} is the set of 20419all possible values, then @expr{A - B} is the ``complement'' of @expr{B}. 20420Obviously this is only practical if the set of all possible values in 20421your problem is small enough to list in a Calc vector (or simple 20422enough to express in a few intervals). 20423 20424@kindex v X 20425@kindex V X 20426@pindex calc-set-xor 20427@tindex vxor 20428The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes 20429the ``exclusive-or,'' or ``symmetric difference'' of two sets. 20430An object is in the symmetric difference of two sets if and only 20431if it is in one, but @emph{not} both, of the sets. Objects that 20432occur in both sets ``cancel out.'' 20433 20434@kindex v ~ 20435@kindex V ~ 20436@pindex calc-set-complement 20437@tindex vcompl 20438The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command 20439computes the complement of a set with respect to the real numbers. 20440Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}. 20441For example, @samp{vcompl([2, (3 .. 4]])} evaluates to 20442@samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}. 20443 20444@kindex v F 20445@kindex V F 20446@pindex calc-set-floor 20447@tindex vfloor 20448The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command 20449reinterprets a set as a set of integers. Any non-integer values, 20450and intervals that do not enclose any integers, are removed. Open 20451intervals are converted to equivalent closed intervals. Successive 20452integers are converted into intervals of integers. For example, the 20453complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted 20454the complement with respect to the set of integers you could type 20455@kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}. 20456 20457@kindex v E 20458@kindex V E 20459@pindex calc-set-enumerate 20460@tindex venum 20461The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command 20462converts a set of integers into an explicit vector. Intervals in 20463the set are expanded out to lists of all integers encompassed by 20464the intervals. This only works for finite sets (i.e., sets which 20465do not involve @samp{-inf} or @samp{inf}). 20466 20467@kindex v : 20468@kindex V : 20469@pindex calc-set-span 20470@tindex vspan 20471The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any 20472set of reals into an interval form that encompasses all its elements. 20473The lower limit will be the smallest element in the set; the upper 20474limit will be the largest element. For an empty set, @samp{vspan([])} 20475returns the empty interval @w{@samp{[0 .. 0)}}. 20476 20477@kindex v # 20478@kindex V # 20479@pindex calc-set-cardinality 20480@tindex vcard 20481The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts 20482the number of integers in a set. The result is the length of the vector 20483that would be produced by @kbd{V E}, although the computation is much 20484more efficient than actually producing that vector. 20485 20486@cindex Sets, as binary numbers 20487Another representation for sets that may be more appropriate in some 20488cases is binary numbers. If you are dealing with sets of integers 20489in the range 0 to 49, you can use a 50-bit binary number where a 20490particular bit is 1 if the corresponding element is in the set. 20491@xref{Binary Functions}, for a list of commands that operate on 20492binary numbers. Note that many of the above set operations have 20493direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}), 20494@kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}), 20495@kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}), 20496respectively. You can use whatever representation for sets is most 20497convenient to you. 20498 20499@kindex b p 20500@kindex b u 20501@pindex calc-pack-bits 20502@pindex calc-unpack-bits 20503@tindex vpack 20504@tindex vunpack 20505The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command 20506converts an integer that represents a set in binary into a set 20507in vector/interval notation. For example, @samp{vunpack(67)} 20508returns @samp{[[0 .. 1], 6]}. If the input is negative, the set 20509it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}. 20510Use @kbd{V E} afterwards to expand intervals to individual 20511values if you wish. Note that this command uses the @kbd{b} 20512(binary) prefix key. 20513 20514The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command 20515converts the other way, from a vector or interval representing 20516a set of nonnegative integers into a binary integer describing 20517the same set. The set may include positive infinity, but must 20518not include any negative numbers. The input is interpreted as a 20519set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware 20520that a simple input like @samp{[100]} can result in a huge integer 20521representation 20522@texline (@math{2^{100}}, a 31-digit integer, in this case). 20523@infoline (@expr{2^100}, a 31-digit integer, in this case). 20524 20525@node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions 20526@section Statistical Operations on Vectors 20527 20528@noindent 20529@cindex Statistical functions 20530The commands in this section take vectors as arguments and compute 20531various statistical measures on the data stored in the vectors. The 20532references used in the definitions of these functions are Bevington's 20533@emph{Data Reduction and Error Analysis for the Physical Sciences}, 20534and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and 20535Vetterling. 20536 20537The statistical commands use the @kbd{u} prefix key followed by 20538a shifted letter or other character. 20539 20540@xref{Manipulating Vectors}, for a description of @kbd{V H} 20541(@code{calc-histogram}). 20542 20543@xref{Curve Fitting}, for the @kbd{a F} command for doing 20544least-squares fits to statistical data. 20545 20546@xref{Probability Distribution Functions}, for several common 20547probability distribution functions. 20548 20549@menu 20550* Single-Variable Statistics:: 20551* Paired-Sample Statistics:: 20552@end menu 20553 20554@node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations 20555@subsection Single-Variable Statistics 20556 20557@noindent 20558These functions do various statistical computations on single 20559vectors. Given a numeric prefix argument, they actually pop 20560@var{n} objects from the stack and combine them into a data 20561vector. Each object may be either a number or a vector; if a 20562vector, any sub-vectors inside it are ``flattened'' as if by 20563@kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object 20564is popped, which (in order to be useful) is usually a vector. 20565 20566If an argument is a variable name, and the value stored in that 20567variable is a vector, then the stored vector is used. This method 20568has the advantage that if your data vector is large, you can avoid 20569the slow process of manipulating it directly on the stack. 20570 20571These functions are left in symbolic form if any of their arguments 20572are not numbers or vectors, e.g., if an argument is a formula, or 20573a non-vector variable. However, formulas embedded within vector 20574arguments are accepted; the result is a symbolic representation 20575of the computation, based on the assumption that the formula does 20576not itself represent a vector. All varieties of numbers such as 20577error forms and interval forms are acceptable. 20578 20579Some of the functions in this section also accept a single error form 20580or interval as an argument. They then describe a property of the 20581normal or uniform (respectively) statistical distribution described 20582by the argument. The arguments are interpreted in the same way as 20583the @var{M} argument of the random number function @kbd{k r}. In 20584particular, an interval with integer limits is considered an integer 20585distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}. 20586An interval with at least one floating-point limit is a continuous 20587distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as 20588@samp{[2.0 .. 5.0]}! 20589 20590@kindex u # 20591@pindex calc-vector-count 20592@tindex vcount 20593The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command 20594computes the number of data values represented by the inputs. 20595For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7. 20596If the argument is a single vector with no sub-vectors, this 20597simply computes the length of the vector. 20598 20599@kindex u + 20600@kindex u * 20601@pindex calc-vector-sum 20602@pindex calc-vector-prod 20603@tindex vsum 20604@tindex vprod 20605@cindex Summations (statistical) 20606The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command 20607computes the sum of the data values. The @kbd{u *} 20608(@code{calc-vector-prod}) [@code{vprod}] command computes the 20609product of the data values. If the input is a single flat vector, 20610these are the same as @kbd{V R +} and @kbd{V R *} 20611(@pxref{Reducing and Mapping}). 20612 20613@kindex u X 20614@kindex u N 20615@pindex calc-vector-max 20616@pindex calc-vector-min 20617@tindex vmax 20618@tindex vmin 20619The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command 20620computes the maximum of the data values, and the @kbd{u N} 20621(@code{calc-vector-min}) [@code{vmin}] command computes the minimum. 20622If the argument is an interval, this finds the minimum or maximum 20623value in the interval. (Note that @samp{vmax([2..6)) = 5} as 20624described above.) If the argument is an error form, this returns 20625plus or minus infinity. 20626 20627@kindex u M 20628@pindex calc-vector-mean 20629@tindex vmean 20630@cindex Mean of data values 20631The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command 20632computes the average (arithmetic mean) of the data values. 20633If the inputs are error forms 20634@texline @math{x \pm \sigma}, 20635@infoline @samp{x +/- s}, 20636this is the weighted mean of the @expr{x} values with weights 20637@texline @math{1 /\sigma^2}. 20638@infoline @expr{1 / s^2}. 20639@tex 20640$$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over 20641 \displaystyle \sum { 1 \over \sigma_i^2 } } $$ 20642@end tex 20643If the inputs are not error forms, this is simply the sum of the 20644values divided by the count of the values. 20645 20646Note that a plain number can be considered an error form with 20647error 20648@texline @math{\sigma = 0}. 20649@infoline @expr{s = 0}. 20650If the input to @kbd{u M} is a mixture of 20651plain numbers and error forms, the result is the mean of the 20652plain numbers, ignoring all values with non-zero errors. (By the 20653above definitions it's clear that a plain number effectively 20654has an infinite weight, next to which an error form with a finite 20655weight is completely negligible.) 20656 20657This function also works for distributions (error forms or 20658intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply 20659@expr{a}. The mean of an interval is the mean of the minimum 20660and maximum values of the interval. 20661 20662@kindex I u M 20663@pindex calc-vector-mean-error 20664@tindex vmeane 20665The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}] 20666command computes the mean of the data points expressed as an 20667error form. This includes the estimated error associated with 20668the mean. If the inputs are error forms, the error is the square 20669root of the reciprocal of the sum of the reciprocals of the squares 20670of the input errors. (I.e., the variance is the reciprocal of the 20671sum of the reciprocals of the variances.) 20672@tex 20673$$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$ 20674@end tex 20675If the inputs are plain 20676numbers, the error is equal to the standard deviation of the values 20677divided by the square root of the number of values. (This works 20678out to be equivalent to calculating the standard deviation and 20679then assuming each value's error is equal to this standard 20680deviation.) 20681@tex 20682$$ \sigma_\mu^2 = {\sigma^2 \over N} $$ 20683@end tex 20684 20685@kindex H u M 20686@pindex calc-vector-median 20687@tindex vmedian 20688@cindex Median of data values 20689The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}] 20690command computes the median of the data values. The values are 20691first sorted into numerical order; the median is the middle 20692value after sorting. (If the number of data values is even, 20693the median is taken to be the average of the two middle values.) 20694The median function is different from the other functions in 20695this section in that the arguments must all be real numbers; 20696variables are not accepted even when nested inside vectors. 20697(Otherwise it is not possible to sort the data values.) If 20698any of the input values are error forms, their error parts are 20699ignored. 20700 20701The median function also accepts distributions. For both normal 20702(error form) and uniform (interval) distributions, the median is 20703the same as the mean. 20704 20705@kindex H I u M 20706@pindex calc-vector-harmonic-mean 20707@tindex vhmean 20708@cindex Harmonic mean 20709The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}] 20710command computes the harmonic mean of the data values. This is 20711defined as the reciprocal of the arithmetic mean of the reciprocals 20712of the values. 20713@tex 20714$$ { N \over \displaystyle \sum {1 \over x_i} } $$ 20715@end tex 20716 20717@kindex u G 20718@pindex calc-vector-geometric-mean 20719@tindex vgmean 20720@cindex Geometric mean 20721The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}] 20722command computes the geometric mean of the data values. This 20723is the @var{n}th root of the product of the values. This is also 20724equal to the @code{exp} of the arithmetic mean of the logarithms 20725of the data values. 20726@tex 20727$$ \exp \left ( \sum { \ln x_i } \right ) = 20728 \left ( \prod { x_i } \right)^{1 / N} $$ 20729@end tex 20730 20731@kindex H u G 20732@tindex agmean 20733The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric 20734mean'' of two numbers taken from the stack. This is computed by 20735replacing the two numbers with their arithmetic mean and geometric 20736mean, then repeating until the two values converge. 20737@tex 20738$$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$ 20739@end tex 20740 20741@kindex u R 20742@cindex Root-mean-square 20743@tindex rms 20744The @kbd{u R} (@code{calc-vector-rms}) [@code{rms}] 20745command computes the RMS (root-mean-square) of the data values. 20746As its name suggests, this is the square root of the mean of the 20747squares of the data values. 20748 20749@kindex u S 20750@pindex calc-vector-sdev 20751@tindex vsdev 20752@cindex Standard deviation 20753@cindex Sample statistics 20754The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command 20755computes the standard 20756@texline deviation@tie{}@math{\sigma} 20757@infoline deviation 20758of the data values. If the values are error forms, the errors are used 20759as weights just as for @kbd{u M}. This is the @emph{sample} standard 20760deviation, whose value is the square root of the sum of the squares of 20761the differences between the values and the mean of the @expr{N} values, 20762divided by @expr{N-1}. 20763@tex 20764$$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$ 20765@end tex 20766 20767This function also applies to distributions. The standard deviation 20768of a single error form is simply the error part. The standard deviation 20769of a continuous interval happens to equal the difference between the 20770limits, divided by 20771@texline @math{\sqrt{12}}. 20772@infoline @expr{sqrt(12)}. 20773The standard deviation of an integer interval is the same as the 20774standard deviation of a vector of those integers. 20775 20776@kindex I u S 20777@pindex calc-vector-pop-sdev 20778@tindex vpsdev 20779@cindex Population statistics 20780The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}] 20781command computes the @emph{population} standard deviation. 20782It is defined by the same formula as above but dividing 20783by @expr{N} instead of by @expr{N-1}. The population standard 20784deviation is used when the input represents the entire set of 20785data values in the distribution; the sample standard deviation 20786is used when the input represents a sample of the set of all 20787data values, so that the mean computed from the input is itself 20788only an estimate of the true mean. 20789@tex 20790$$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$ 20791@end tex 20792 20793For error forms and continuous intervals, @code{vpsdev} works 20794exactly like @code{vsdev}. For integer intervals, it computes the 20795population standard deviation of the equivalent vector of integers. 20796 20797@kindex H u S 20798@kindex H I u S 20799@pindex calc-vector-variance 20800@pindex calc-vector-pop-variance 20801@tindex vvar 20802@tindex vpvar 20803@cindex Variance of data values 20804The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and 20805@kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}] 20806commands compute the variance of the data values. The variance 20807is the 20808@texline square@tie{}@math{\sigma^2} 20809@infoline square 20810of the standard deviation, i.e., the sum of the 20811squares of the deviations of the data values from the mean. 20812(This definition also applies when the argument is a distribution.) 20813 20814@ignore 20815@starindex 20816@end ignore 20817@tindex vflat 20818The @code{vflat} algebraic function returns a vector of its 20819arguments, interpreted in the same way as the other functions 20820in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)} 20821returns @samp{[1, 2, 3, 4, 5]}. 20822 20823@node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations 20824@subsection Paired-Sample Statistics 20825 20826@noindent 20827The functions in this section take two arguments, which must be 20828vectors of equal size. The vectors are each flattened in the same 20829way as by the single-variable statistical functions. Given a numeric 20830prefix argument of 1, these functions instead take one object from 20831the stack, which must be an 20832@texline @math{N\times2} 20833@infoline Nx2 20834matrix of data values. Once again, variable names can be used in place 20835of actual vectors and matrices. 20836 20837@kindex u C 20838@pindex calc-vector-covariance 20839@tindex vcov 20840@cindex Covariance 20841The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command 20842computes the sample covariance of two vectors. The covariance 20843of vectors @var{x} and @var{y} is the sum of the products of the 20844differences between the elements of @var{x} and the mean of @var{x} 20845times the differences between the corresponding elements of @var{y} 20846and the mean of @var{y}, all divided by @expr{N-1}. Note that 20847the variance of a vector is just the covariance of the vector 20848with itself. Once again, if the inputs are error forms the 20849errors are used as weight factors. If both @var{x} and @var{y} 20850are composed of error forms, the error for a given data point 20851is taken as the square root of the sum of the squares of the two 20852input errors. 20853@tex 20854$$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$ 20855$$ \sigma_{x\!y}^2 = 20856 {\displaystyle {1 \over N-1} 20857 \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2} 20858 \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}} 20859$$ 20860@end tex 20861 20862@kindex I u C 20863@pindex calc-vector-pop-covariance 20864@tindex vpcov 20865The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}] 20866command computes the population covariance, which is the same as the 20867sample covariance computed by @kbd{u C} except dividing by @expr{N} 20868instead of @expr{N-1}. 20869 20870@kindex H u C 20871@pindex calc-vector-correlation 20872@tindex vcorr 20873@cindex Correlation coefficient 20874@cindex Linear correlation 20875The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}] 20876command computes the linear correlation coefficient of two vectors. 20877This is defined by the covariance of the vectors divided by the 20878product of their standard deviations. (There is no difference 20879between sample or population statistics here.) 20880@tex 20881$$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$ 20882@end tex 20883 20884@node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions 20885@section Reducing and Mapping Vectors 20886 20887@noindent 20888The commands in this section allow for more general operations on the 20889elements of vectors. 20890 20891@kindex v A 20892@kindex V A 20893@pindex calc-apply 20894@tindex apply 20895The simplest of these operations is @kbd{V A} (@code{calc-apply}) 20896[@code{apply}], which applies a given operator to the elements of a vector. 20897For example, applying the hypothetical function @code{f} to the vector 20898@w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}. 20899Applying the @code{+} function to the vector @samp{[a, b]} gives 20900@samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an 20901error, since the @code{+} function expects exactly two arguments. 20902 20903While @kbd{V A} is useful in some cases, you will usually find that either 20904@kbd{V R} or @kbd{V M}, described below, is closer to what you want. 20905 20906@menu 20907* Specifying Operators:: 20908* Mapping:: 20909* Reducing:: 20910* Nesting and Fixed Points:: 20911* Generalized Products:: 20912@end menu 20913 20914@node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping 20915@subsection Specifying Operators 20916 20917@noindent 20918Commands in this section (like @kbd{V A}) prompt you to press the key 20919corresponding to the desired operator. Press @kbd{?} for a partial 20920list of the available operators. Generally, an operator is any key or 20921sequence of keys that would normally take one or more arguments from 20922the stack and replace them with a result. For example, @kbd{V A H C} 20923uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh} 20924expects one argument, @kbd{V A H C} requires a vector with a single 20925element as its argument.) 20926 20927You can press @kbd{x} at the operator prompt to select any algebraic 20928function by name to use as the operator. This includes functions you 20929have defined yourself using the @kbd{Z F} command. (@xref{Algebraic 20930Definitions}.) If you give a name for which no function has been 20931defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}. 20932Calc will prompt for the number of arguments the function takes if it 20933can't figure it out on its own (say, because you named a function that 20934is currently undefined). It is also possible to type a digit key before 20935the function name to specify the number of arguments, e.g., 20936@kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it 20937looks like it ought to have only two. This technique may be necessary 20938if the function allows a variable number of arguments. For example, 20939the @kbd{v e} [@code{vexp}] function accepts two or three arguments; 20940if you want to map with the three-argument version, you will have to 20941type @kbd{V M 3 v e}. 20942 20943It is also possible to apply any formula to a vector by treating that 20944formula as a function. When prompted for the operator to use, press 20945@kbd{'} (the apostrophe) and type your formula as an algebraic entry. 20946You will then be prompted for the argument list, which defaults to a 20947list of all variables that appear in the formula, sorted into alphabetic 20948order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}. 20949The default argument list would be @samp{(x y)}, which means that if 20950this function is applied to the arguments @samp{[3, 10]} the result will 20951be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this 20952way often, you might consider defining it as a function with @kbd{Z F}.) 20953 20954Another way to specify the arguments to the formula you enter is with 20955@kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$} 20956has the same effect as the previous example. The argument list is 20957automatically taken to be @samp{($$ $)}. (The order of the arguments 20958may seem backwards, but it is analogous to the way normal algebraic 20959entry interacts with the stack.) 20960 20961If you press @kbd{$} at the operator prompt, the effect is similar to 20962the apostrophe except that the relevant formula is taken from top-of-stack 20963instead. The actual vector arguments of the @kbd{V A $} or related command 20964then start at the second-to-top stack position. You will still be 20965prompted for an argument list. 20966 20967@cindex Nameless functions 20968@cindex Generic functions 20969A function can be written without a name using the notation @samp{<#1 - #2>}, 20970which means ``a function of two arguments that computes the first 20971argument minus the second argument.'' The symbols @samp{#1} and @samp{#2} 20972are placeholders for the arguments. You can use any names for these 20973placeholders if you wish, by including an argument list followed by a 20974colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}}, 20975Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function 20976to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}}, 20977Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both 20978cases, Calc also writes the nameless function to the Trail so that you 20979can get it back later if you wish. 20980 20981If there is only one argument, you can write @samp{#} in place of @samp{#1}. 20982(Note that @samp{< >} notation is also used for date forms. Calc tells 20983that @samp{<@var{stuff}>} is a nameless function by the presence of 20984@samp{#} signs inside @var{stuff}, or by the fact that @var{stuff} 20985begins with a list of variables followed by a colon.) 20986 20987You can type a nameless function directly to @kbd{V A '}, or put one on 20988the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an 20989argument list in this case, since the nameless function specifies the 20990argument list as well as the function itself. In @kbd{V A '}, you can 20991omit the @samp{< >} marks if you use @samp{#} notation for the arguments, 20992so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}}, 20993which in turn is the same as @kbd{V A ' $$+$ @key{RET}}. 20994 20995@cindex Lambda expressions 20996@ignore 20997@starindex 20998@end ignore 20999@tindex lambda 21000The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}. 21001(The word @code{lambda} derives from Lisp notation and the theory of 21002functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA, 21003ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called 21004@code{lambda}; the whole point is that the @code{lambda} expression is 21005used in its symbolic form, not evaluated for an answer until it is applied 21006to specific arguments by a command like @kbd{V A} or @kbd{V M}. 21007 21008(Actually, @code{lambda} does have one special property: Its arguments 21009are never evaluated; for example, putting @samp{<(2/3) #>} on the stack 21010will not simplify the @samp{2/3} until the nameless function is actually 21011called.) 21012 21013@tindex add 21014@tindex sub 21015@ignore 21016@mindex @idots 21017@end ignore 21018@tindex mul 21019@ignore 21020@mindex @null 21021@end ignore 21022@tindex div 21023@ignore 21024@mindex @null 21025@end ignore 21026@tindex pow 21027@ignore 21028@mindex @null 21029@end ignore 21030@tindex neg 21031@ignore 21032@mindex @null 21033@end ignore 21034@tindex mod 21035@ignore 21036@mindex @null 21037@end ignore 21038@tindex vconcat 21039As usual, commands like @kbd{V A} have algebraic function name equivalents. 21040For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to 21041@samp{apply(gcd, v)}. The first argument specifies the operator name, 21042and is either a variable whose name is the same as the function name, 21043or a nameless function like @samp{<#^3+1>}. Operators that are normally 21044written as algebraic symbols have the names @code{add}, @code{sub}, 21045@code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and 21046@code{vconcat}. 21047 21048@ignore 21049@starindex 21050@end ignore 21051@tindex call 21052The @code{call} function builds a function call out of several arguments: 21053@samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which 21054in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call}, 21055like the other functions described here, may be either a variable naming a 21056function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same 21057as @samp{x + 2y}). 21058 21059(Experts will notice that it's not quite proper to use a variable to name 21060a function, since the name @code{gcd} corresponds to the Lisp variable 21061@code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc 21062automatically makes this translation, so you don't have to worry 21063about it.) 21064 21065@node Mapping, Reducing, Specifying Operators, Reducing and Mapping 21066@subsection Mapping 21067 21068@noindent 21069@kindex v M 21070@kindex V M 21071@pindex calc-map 21072@tindex map 21073The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given 21074operator elementwise to one or more vectors. For example, mapping 21075@code{A} [@code{abs}] produces a vector of the absolute values of the 21076elements in the input vector. Mapping @code{+} pops two vectors from 21077the stack, which must be of equal length, and produces a vector of the 21078pairwise sums of the elements. If either argument is a non-vector, it 21079is duplicated for each element of the other vector. For example, 21080@kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector. 21081With the 2 listed first, it would have computed a vector of powers of 21082two. Mapping a user-defined function pops as many arguments from the 21083stack as the function requires. If you give an undefined name, you will 21084be prompted for the number of arguments to use. 21085 21086If any argument to @kbd{V M} is a matrix, the operator is normally mapped 21087across all elements of the matrix. For example, given the matrix 21088@expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to 21089produce another 21090@texline @math{3\times2} 21091@infoline 3x2 21092matrix, @expr{[[1, 2, 3], [4, 5, 6]]}. 21093 21094@tindex mapr 21095The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the 21096operator prompt) maps by rows instead. For example, @kbd{V M _ A} views 21097the above matrix as a vector of two 3-element row vectors. It produces 21098a new vector which contains the absolute values of those row vectors, 21099namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is 21100defined as the square root of the sum of the squares of the elements.) 21101Some operators accept vectors and return new vectors; for example, 21102@kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row 21103of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}. 21104 21105Sometimes a vector of vectors (representing, say, strings, sets, or lists) 21106happens to look like a matrix. If so, remember to use @kbd{V M _} if you 21107want to map a function across the whole strings or sets rather than across 21108their individual elements. 21109 21110@tindex mapc 21111The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it 21112transposes the input matrix, maps by rows, and then, if the result is a 21113matrix, transposes again. For example, @kbd{V M : A} takes the absolute 21114values of the three columns of the matrix, treating each as a 2-vector, 21115and @kbd{V M : v v} reverses the columns to get the matrix 21116@expr{[[-4, 5, -6], [1, -2, 3]]}. 21117 21118(The symbols @kbd{_} and @kbd{:} were chosen because they had row-like 21119and column-like appearances, and were not already taken by useful 21120operators. Also, they appear shifted on most keyboards so they are easy 21121to type after @kbd{V M}.) 21122 21123The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are 21124not matrices (so if none of the arguments are matrices, they have no 21125effect at all). If some of the arguments are matrices and others are 21126plain numbers, the plain numbers are held constant for all rows of the 21127matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring 21128a vector takes a dot product of the vector with itself). 21129 21130If some of the arguments are vectors with the same lengths as the 21131rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix 21132arguments, those vectors are also held constant for every row or 21133column. 21134 21135Sometimes it is useful to specify another mapping command as the operator 21136to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +} 21137to each row of the input matrix, which in turn adds the two values on that 21138row. If you give another vector-operator command as the operator for 21139@kbd{V M}, it automatically uses map-by-rows mode if you don't specify 21140otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If 21141you really want to map-by-elements another mapping command, you can use 21142a triple-nested mapping command: @kbd{V M V M V A +} means to map 21143@kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is 21144mapped over the elements of each row.) 21145 21146@tindex mapa 21147@tindex mapd 21148Previous versions of Calc had ``map across'' and ``map down'' modes 21149that are now considered obsolete; the old ``map across'' is now simply 21150@kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic 21151functions @code{mapa} and @code{mapd} are still supported, though. 21152Note also that, while the old mapping modes were persistent (once you 21153set the mode, it would apply to later mapping commands until you reset 21154it), the new @kbd{:} and @kbd{_} modifiers apply only to the current 21155mapping command. The default @kbd{V M} always means map-by-elements. 21156 21157@xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like 21158@kbd{V M} but for equations and inequalities instead of vectors. 21159@xref{Storing Variables}, for the @kbd{s m} command which modifies a 21160variable's stored value using a @kbd{V M}-like operator. 21161 21162@node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping 21163@subsection Reducing 21164 21165@noindent 21166@kindex v R 21167@kindex V R 21168@pindex calc-reduce 21169@tindex reduce 21170The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given 21171binary operator across all the elements of a vector. A binary operator is 21172a function such as @code{+} or @code{max} which takes two arguments. For 21173example, reducing @code{+} over a vector computes the sum of the elements 21174of the vector. Reducing @code{-} computes the first element minus each of 21175the remaining elements. Reducing @code{max} computes the maximum element 21176and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]} 21177produces @samp{f(f(f(a, b), c), d)}. 21178 21179@kindex I v R 21180@kindex I V R 21181@tindex rreduce 21182The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except 21183that works from right to left through the vector. For example, plain 21184@kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d} 21185but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))}, 21186or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently 21187in power series expansions. 21188 21189@kindex v U 21190@kindex V U 21191@tindex accum 21192The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an 21193accumulation operation. Here Calc does the corresponding reduction 21194operation, but instead of producing only the final result, it produces 21195a vector of all the intermediate results. Accumulating @code{+} over 21196the vector @samp{[a, b, c, d]} produces the vector 21197@samp{[a, a + b, a + b + c, a + b + c + d]}. 21198 21199@kindex I v U 21200@kindex I V U 21201@tindex raccum 21202The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation. 21203For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the 21204vector @samp{[a - b + c - d, b - c + d, c - d, d]}. 21205 21206@tindex reducea 21207@tindex rreducea 21208@tindex reduced 21209@tindex rreduced 21210As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For 21211example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will 21212compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or 21213@kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}] 21214command reduces ``across'' the matrix; it reduces each row of the matrix 21215as a vector, then collects the results. Thus @kbd{V R _ +} of this 21216matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :} 21217[@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d, 21218b + e, c + f]}. 21219 21220@tindex reducer 21221@tindex rreducer 21222There is a third ``by rows'' mode for reduction that is occasionally 21223useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over 21224the rows of the matrix themselves. Thus @kbd{V R = +} on the above 21225matrix would get the same result as @kbd{V R : +}, since adding two 21226row vectors is equivalent to adding their elements. But @kbd{V R = *} 21227would multiply the two rows (to get a single number, their dot product), 21228while @kbd{V R : *} would produce a vector of the products of the columns. 21229 21230These three matrix reduction modes work with @kbd{V R} and @kbd{I V R}, 21231but they are not currently supported with @kbd{V U} or @kbd{I V U}. 21232 21233@tindex reducec 21234@tindex rreducec 21235The obsolete reduce-by-columns function, @code{reducec}, is still 21236supported but there is no way to get it through the @kbd{V R} command. 21237 21238The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing 21239@kbd{C-x * r} to grab a rectangle of data into Calc, and then typing 21240@kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or 21241rows of the matrix. @xref{Grabbing From Buffers}. 21242 21243@node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping 21244@subsection Nesting and Fixed Points 21245 21246@noindent 21247@kindex H v R 21248@kindex H V R 21249@tindex nest 21250The @kbd{H V R} [@code{nest}] command applies a function to a given 21251argument repeatedly. It takes two values, @samp{a} and @samp{n}, from 21252the stack, where @samp{n} must be an integer. It then applies the 21253function nested @samp{n} times; if the function is @samp{f} and @samp{n} 21254is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be 21255negative if Calc knows an inverse for the function @samp{f}; for 21256example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}. 21257 21258@kindex H v U 21259@kindex H V U 21260@tindex anest 21261The @kbd{H V U} [@code{anest}] command is an accumulating version of 21262@code{nest}: It returns a vector of @samp{n+1} values, e.g., 21263@samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and 21264@samp{F} is the inverse of @samp{f}, then the result is of the 21265form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}. 21266 21267@kindex H I v R 21268@kindex H I V R 21269@tindex fixp 21270@cindex Fixed points 21271The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except 21272that it takes only an @samp{a} value from the stack; the function is 21273applied until it reaches a ``fixed point,'' i.e., until the result 21274no longer changes. 21275 21276@kindex H I v U 21277@kindex H I V U 21278@tindex afixp 21279The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}. 21280The first element of the return vector will be the initial value @samp{a}; 21281the last element will be the final result that would have been returned 21282by @code{fixp}. 21283 21284For example, 0.739085 is a fixed point of the cosine function (in radians): 21285@samp{cos(0.739085) = 0.739085}. You can find this value by putting, say, 212861.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating 21287version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553, 212880.65329, ...]}. With a precision of six, this command will take 36 steps 21289to converge to 0.739085.) 21290 21291Newton's method for finding roots is a classic example of iteration 21292to a fixed point. To find the square root of five starting with an 21293initial guess, Newton's method would look for a fixed point of the 21294function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack 21295and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result 212962.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root}) 21297command to find a root of the equation @samp{x^2 = 5}. 21298 21299These examples used numbers for @samp{a} values. Calc keeps applying 21300the function until two successive results are equal to within the 21301current precision. For complex numbers, both the real parts and the 21302imaginary parts must be equal to within the current precision. If 21303@samp{a} is a formula (say, a variable name), then the function is 21304applied until two successive results are exactly the same formula. 21305It is up to you to ensure that the function will eventually converge; 21306if it doesn't, you may have to press @kbd{C-g} to stop the Calculator. 21307 21308The algebraic @code{fixp} function takes two optional arguments, @samp{n} 21309and @samp{tol}. The first is the maximum number of steps to be allowed, 21310and must be either an integer or the symbol @samp{inf} (infinity, the 21311default). The second is a convergence tolerance. If a tolerance is 21312specified, all results during the calculation must be numbers, not 21313formulas, and the iteration stops when the magnitude of the difference 21314between two successive results is less than or equal to the tolerance. 21315(This implies that a tolerance of zero iterates until the results are 21316exactly equal.) 21317 21318Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)} 21319computes the square root of @samp{A} given the initial guess @samp{B}, 21320stopping when the result is correct within the specified tolerance, or 21321when 20 steps have been taken, whichever is sooner. 21322 21323@node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping 21324@subsection Generalized Products 21325 21326@kindex v O 21327@kindex V O 21328@pindex calc-outer-product 21329@tindex outer 21330The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies 21331a given binary operator to all possible pairs of elements from two 21332vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]} 21333and @samp{[x, y, z]} on the stack produces a multiplication table: 21334@samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of 21335the result matrix is obtained by applying the operator to element @var{r} 21336of the lefthand vector and element @var{c} of the righthand vector. 21337 21338@kindex v I 21339@kindex V I 21340@pindex calc-inner-product 21341@tindex inner 21342The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes 21343the generalized inner product of two vectors or matrices, given a 21344``multiplicative'' operator and an ``additive'' operator. These can each 21345actually be any binary operators; if they are @samp{*} and @samp{+}, 21346respectively, the result is a standard matrix multiplication. Element 21347@var{r},@var{c} of the result matrix is obtained by mapping the 21348multiplicative operator across row @var{r} of the lefthand matrix and 21349column @var{c} of the righthand matrix, and then reducing with the additive 21350operator. Just as for the standard @kbd{*} command, this can also do a 21351vector-matrix or matrix-vector inner product, or a vector-vector 21352generalized dot product. 21353 21354Since @kbd{V I} requires two operators, it prompts twice. In each case, 21355you can use any of the usual methods for entering the operator. If you 21356use @kbd{$} twice to take both operator formulas from the stack, the 21357first (multiplicative) operator is taken from the top of the stack 21358and the second (additive) operator is taken from second-to-top. 21359 21360@node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions 21361@section Vector and Matrix Display Formats 21362 21363@noindent 21364Commands for controlling vector and matrix display use the @kbd{v} prefix 21365instead of the usual @kbd{d} prefix. But they are display modes; in 21366particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys 21367in the same way (@pxref{Display Modes}). Matrix display is also 21368influenced by the @kbd{d O} (@code{calc-flat-language}) mode; 21369@pxref{Normal Language Modes}. 21370 21371@kindex v < 21372@kindex V < 21373@pindex calc-matrix-left-justify 21374@kindex v = 21375@kindex V = 21376@pindex calc-matrix-center-justify 21377@kindex v > 21378@kindex V > 21379@pindex calc-matrix-right-justify 21380The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >} 21381(@code{calc-matrix-right-justify}), and @w{@kbd{v =}} 21382(@code{calc-matrix-center-justify}) control whether matrix elements 21383are justified to the left, right, or center of their columns. 21384 21385@kindex v [ 21386@kindex V [ 21387@pindex calc-vector-brackets 21388@kindex v @{ 21389@kindex V @{ 21390@pindex calc-vector-braces 21391@kindex v ( 21392@kindex V ( 21393@pindex calc-vector-parens 21394The @kbd{v [} (@code{calc-vector-brackets}) command turns the square 21395brackets that surround vectors and matrices displayed in the stack on 21396and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (} 21397(@code{calc-vector-parens}) commands use curly braces or parentheses, 21398respectively, instead of square brackets. For example, @kbd{v @{} might 21399be used in preparation for yanking a matrix into a buffer running 21400Mathematica. (In fact, the Mathematica language mode uses this mode; 21401@pxref{Mathematica Language Mode}.) Note that, regardless of the 21402display mode, either brackets or braces may be used to enter vectors, 21403and parentheses may never be used for this purpose. 21404 21405@kindex V ] 21406@kindex v ] 21407@kindex V ) 21408@kindex v ) 21409@kindex V @} 21410@kindex v @} 21411@pindex calc-matrix-brackets 21412The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the 21413``big'' style display of matrices, for matrices which have more than 21414one row. It prompts for a string of code letters; currently 21415implemented letters are @code{R}, which enables brackets on each row 21416of the matrix; @code{O}, which enables outer brackets in opposite 21417corners of the matrix; and @code{C}, which enables commas or 21418semicolons at the ends of all rows but the last. The default format 21419is @samp{RO}. (Before Calc 2.00, the format was fixed at @samp{ROC}.) 21420Here are some example matrices: 21421 21422@example 21423@group 21424[ [ 123, 0, 0 ] [ [ 123, 0, 0 ], 21425 [ 0, 123, 0 ] [ 0, 123, 0 ], 21426 [ 0, 0, 123 ] ] [ 0, 0, 123 ] ] 21427 21428 RO ROC 21429 21430@end group 21431@end example 21432@noindent 21433@example 21434@group 21435 [ 123, 0, 0 [ 123, 0, 0 ; 21436 0, 123, 0 0, 123, 0 ; 21437 0, 0, 123 ] 0, 0, 123 ] 21438 21439 O OC 21440 21441@end group 21442@end example 21443@noindent 21444@example 21445@group 21446 [ 123, 0, 0 ] 123, 0, 0 21447 [ 0, 123, 0 ] 0, 123, 0 21448 [ 0, 0, 123 ] 0, 0, 123 21449 21450 R @r{blank} 21451@end group 21452@end example 21453 21454@noindent 21455Note that of the formats shown here, @samp{RO}, @samp{ROC}, and 21456@samp{OC} are all recognized as matrices during reading, while 21457the others are useful for display only. 21458 21459@kindex v , 21460@kindex V , 21461@pindex calc-vector-commas 21462The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and 21463off in vector and matrix display. 21464 21465In vectors of length one, and in all vectors when commas have been 21466turned off, Calc adds extra parentheses around formulas that might 21467otherwise be ambiguous. For example, @samp{[a b]} could be a vector 21468of the one formula @samp{a b}, or it could be a vector of two 21469variables with commas turned off. Calc will display the former 21470case as @samp{[(a b)]}. You can disable these extra parentheses 21471(to make the output less cluttered at the expense of allowing some 21472ambiguity) by adding the letter @code{P} to the control string you 21473give to @kbd{v ]} (as described above). 21474 21475@kindex v . 21476@kindex V . 21477@pindex calc-full-vectors 21478The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated 21479display of long vectors on and off. In this mode, vectors of six 21480or more elements, or matrices of six or more rows or columns, will 21481be displayed in an abbreviated form that displays only the first 21482three elements and the last element: @samp{[a, b, c, ..., z]}. 21483When very large vectors are involved this will substantially 21484improve Calc's display speed. 21485 21486@kindex t . 21487@pindex calc-full-trail-vectors 21488The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a 21489similar mode for recording vectors in the Trail. If you turn on 21490this mode, vectors of six or more elements and matrices of six or 21491more rows or columns will be abbreviated when they are put in the 21492Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be 21493unable to recover those vectors. If you are working with very 21494large vectors, this mode will improve the speed of all operations 21495that involve the trail. 21496 21497@kindex v / 21498@kindex V / 21499@pindex calc-break-vectors 21500The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line 21501vector display on and off. Normally, matrices are displayed with one 21502row per line but all other types of vectors are displayed in a single 21503line. This mode causes all vectors, whether matrices or not, to be 21504displayed with a single element per line. Sub-vectors within the 21505vectors will still use the normal linear form. 21506 21507@node Algebra, Units, Matrix Functions, Top 21508@chapter Algebra 21509 21510@noindent 21511This section covers the Calc features that help you work with 21512algebraic formulas. First, the general sub-formula selection 21513mechanism is described; this works in conjunction with any Calc 21514commands. Then, commands for specific algebraic operations are 21515described. Finally, the flexible @dfn{rewrite rule} mechanism 21516is discussed. 21517 21518The algebraic commands use the @kbd{a} key prefix; selection 21519commands use the @kbd{j} (for ``just a letter that wasn't used 21520for anything else'') prefix. 21521 21522@xref{Editing Stack Entries}, to see how to manipulate formulas 21523using regular Emacs editing commands. 21524 21525When doing algebraic work, you may find several of the Calculator's 21526modes to be helpful, including Algebraic Simplification mode (@kbd{m A}) 21527or No-Simplification mode (@kbd{m O}), 21528Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and 21529Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions 21530of these modes. You may also wish to select Big display mode (@kbd{d B}). 21531@xref{Normal Language Modes}. 21532 21533@menu 21534* Selecting Subformulas:: 21535* Algebraic Manipulation:: 21536* Simplifying Formulas:: 21537* Polynomials:: 21538* Calculus:: 21539* Solving Equations:: 21540* Numerical Solutions:: 21541* Curve Fitting:: 21542* Summations:: 21543* Logical Operations:: 21544* Rewrite Rules:: 21545@end menu 21546 21547@node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra 21548@section Selecting Sub-Formulas 21549 21550@noindent 21551@cindex Selections 21552@cindex Sub-formulas 21553@cindex Parts of formulas 21554When working with an algebraic formula it is often necessary to 21555manipulate a portion of the formula rather than the formula as a 21556whole. Calc allows you to ``select'' a portion of any formula on 21557the stack. Commands which would normally operate on that stack 21558entry will now operate only on the sub-formula, leaving the 21559surrounding part of the stack entry alone. 21560 21561One common non-algebraic use for selection involves vectors. To work 21562on one element of a vector in-place, simply select that element as a 21563``sub-formula'' of the vector. 21564 21565@menu 21566* Making Selections:: 21567* Changing Selections:: 21568* Displaying Selections:: 21569* Operating on Selections:: 21570* Rearranging with Selections:: 21571@end menu 21572 21573@node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas 21574@subsection Making Selections 21575 21576@noindent 21577@kindex j s 21578@pindex calc-select-here 21579To select a sub-formula, move the Emacs cursor to any character in that 21580sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will 21581highlight the smallest portion of the formula that contains that 21582character. By default the sub-formula is highlighted by blanking out 21583all of the rest of the formula with dots. Selection works in any 21584display mode but is perhaps easiest in Big mode (@kbd{d B}). 21585Suppose you enter the following formula: 21586 21587@smallexample 21588@group 21589 3 ___ 21590 (a + b) + V c 215911: --------------- 21592 2 x + 1 21593@end group 21594@end smallexample 21595 21596@noindent 21597(by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the 21598cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes 21599to 21600 21601@smallexample 21602@group 21603 . ... 21604 .. . b. . . . 216051* ............... 21606 . . . . 21607@end group 21608@end smallexample 21609 21610@noindent 21611Every character not part of the sub-formula @samp{b} has been changed 21612to a dot. (If the customizable variable 21613@code{calc-highlight-selections-with-faces} is non-@code{nil}, then the characters 21614not part of the sub-formula are de-emphasized by using a less 21615noticeable face instead of using dots. @pxref{Displaying Selections}.) 21616The @samp{*} next to the line number is to remind you that 21617the formula has a portion of it selected. (In this case, it's very 21618obvious, but it might not always be. If Embedded mode is enabled, 21619the word @samp{Sel} also appears in the mode line because the stack 21620may not be visible. @pxref{Embedded Mode}.) 21621 21622If you had instead placed the cursor on the parenthesis immediately to 21623the right of the @samp{b}, the selection would have been: 21624 21625@smallexample 21626@group 21627 . ... 21628 (a + b) . . . 216291* ............... 21630 . . . . 21631@end group 21632@end smallexample 21633 21634@noindent 21635The portion selected is always large enough to be considered a complete 21636formula all by itself, so selecting the parenthesis selects the whole 21637formula that it encloses. Putting the cursor on the @samp{+} sign 21638would have had the same effect. 21639 21640(Strictly speaking, the Emacs cursor is really the manifestation of 21641the Emacs ``point,'' which is a position @emph{between} two characters 21642in the buffer. So purists would say that Calc selects the smallest 21643sub-formula which contains the character to the right of ``point.'') 21644 21645If you supply a numeric prefix argument @var{n}, the selection is 21646expanded to the @var{n}th enclosing sub-formula. Thus, positioning 21647the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select 21648@samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3}, 21649and so on. 21650 21651If the cursor is not on any part of the formula, or if you give a 21652numeric prefix that is too large, the entire formula is selected. 21653 21654If the cursor is on the @samp{.} line that marks the top of the stack 21655(i.e., its normal ``rest position''), this command selects the entire 21656formula at stack level 1. Most selection commands similarly operate 21657on the formula at the top of the stack if you haven't positioned the 21658cursor on any stack entry. 21659 21660@kindex j a 21661@pindex calc-select-additional 21662The @kbd{j a} (@code{calc-select-additional}) command enlarges the 21663current selection to encompass the cursor. To select the smallest 21664sub-formula defined by two different points, move to the first and 21665press @kbd{j s}, then move to the other and press @kbd{j a}. This 21666is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to 21667select the two ends of a region of text during normal Emacs editing. 21668 21669@kindex j o 21670@pindex calc-select-once 21671The @kbd{j o} (@code{calc-select-once}) command selects a formula in 21672exactly the same way as @kbd{j s}, except that the selection will 21673last only as long as the next command that uses it. For example, 21674@kbd{j o 1 +} is a handy way to add one to the sub-formula indicated 21675by the cursor. 21676 21677(A somewhat more precise definition: The @kbd{j o} command sets a flag 21678such that the next command involving selected stack entries will clear 21679the selections on those stack entries afterwards. All other selection 21680commands except @kbd{j a} and @kbd{j O} clear this flag.) 21681 21682@kindex j S 21683@kindex j O 21684@pindex calc-select-here-maybe 21685@pindex calc-select-once-maybe 21686The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O} 21687(@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s} 21688and @kbd{j o}, respectively, except that if the formula already 21689has a selection they have no effect. This is analogous to the 21690behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection}; 21691@pxref{Selections with Rewrite Rules}) and is mainly intended to be 21692used in keyboard macros that implement your own selection-oriented 21693commands. 21694 21695Selection of sub-formulas normally treats associative terms like 21696@samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula. 21697If you place the cursor anywhere inside @samp{a + b - c + d} except 21698on one of the variable names and use @kbd{j s}, you will select the 21699entire four-term sum. 21700 21701@kindex j b 21702@pindex calc-break-selections 21703The @kbd{j b} (@code{calc-break-selections}) command controls a mode 21704in which the ``deep structure'' of these associative formulas shows 21705through. Calc actually stores the above formulas as 21706@samp{((a + b) - c) + d} and @samp{x * (y * z)}. (Note that for certain 21707obscure reasons, by default Calc treats multiplication as 21708right-associative.) Once you have enabled @kbd{j b} mode, selecting 21709with the cursor on the @samp{-} sign would only select the @samp{a + b - 21710c} portion, which makes sense when the deep structure of the sum is 21711considered. There is no way to select the @samp{b - c + d} portion; 21712although this might initially look like just as legitimate a sub-formula 21713as @samp{a + b - c}, the deep structure shows that it isn't. The @kbd{d 21714U} command can be used to view the deep structure of any formula 21715(@pxref{Normal Language Modes}). 21716 21717When @kbd{j b} mode has not been enabled, the deep structure is 21718generally hidden by the selection commands---what you see is what 21719you get. 21720 21721@kindex j u 21722@pindex calc-unselect 21723The @kbd{j u} (@code{calc-unselect}) command unselects the formula 21724that the cursor is on. If there was no selection in the formula, 21725this command has no effect. With a numeric prefix argument, it 21726unselects the @var{n}th stack element rather than using the cursor 21727position. 21728 21729@kindex j c 21730@pindex calc-clear-selections 21731The @kbd{j c} (@code{calc-clear-selections}) command unselects all 21732stack elements. 21733 21734@node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas 21735@subsection Changing Selections 21736 21737@noindent 21738@kindex j m 21739@pindex calc-select-more 21740Once you have selected a sub-formula, you can expand it using the 21741@w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is 21742selected, pressing @w{@kbd{j m}} repeatedly works as follows: 21743 21744@smallexample 21745@group 21746 3 ... 3 ___ 3 ___ 21747 (a + b) . . . (a + b) + V c (a + b) + V c 217481* ............... 1* ............... 1* --------------- 21749 . . . . . . . . 2 x + 1 21750@end group 21751@end smallexample 21752 21753@noindent 21754In the last example, the entire formula is selected. This is roughly 21755the same as having no selection at all, but because there are subtle 21756differences the @samp{*} character is still there on the line number. 21757 21758With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n} 21759times (or until the entire formula is selected). Note that @kbd{j s} 21760with argument @var{n} is equivalent to plain @kbd{j s} followed by 21761@kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there 21762is no current selection, it is equivalent to @w{@kbd{j s}}. 21763 21764Even though @kbd{j m} does not explicitly use the location of the 21765cursor within the formula, it nevertheless uses the cursor to determine 21766which stack element to operate on. As usual, @kbd{j m} when the cursor 21767is not on any stack element operates on the top stack element. 21768 21769@kindex j l 21770@pindex calc-select-less 21771The @kbd{j l} (@code{calc-select-less}) command reduces the current 21772selection around the cursor position. That is, it selects the 21773immediate sub-formula of the current selection which contains the 21774cursor, the opposite of @kbd{j m}. If the cursor is not inside the 21775current selection, the command de-selects the formula. 21776 21777@kindex j 1-9 21778@pindex calc-select-part 21779The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands 21780select the @var{n}th sub-formula of the current selection. They are 21781like @kbd{j l} (@code{calc-select-less}) except they use counting 21782rather than the cursor position to decide which sub-formula to select. 21783For example, if the current selection is @kbd{a + b + c} or 21784@kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a}, 21785@kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of 21786these cases, @kbd{j 4} through @kbd{j 9} would be errors. 21787 21788If there is no current selection, @kbd{j 1} through @kbd{j 9} select 21789the @var{n}th top-level sub-formula. (In other words, they act as if 21790the entire stack entry were selected first.) To select the @var{n}th 21791sub-formula where @var{n} is greater than nine, you must instead invoke 21792@w{@kbd{j 1}} with @var{n} as a numeric prefix argument. 21793 21794@kindex j n 21795@kindex j p 21796@pindex calc-select-next 21797@pindex calc-select-previous 21798The @kbd{j n} (@code{calc-select-next}) and @kbd{j p} 21799(@code{calc-select-previous}) commands change the current selection 21800to the next or previous sub-formula at the same level. For example, 21801if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n} 21802selects @samp{c}. Further @kbd{j n} commands would be in error because, 21803even though there is something to the right of @samp{c} (namely, @samp{x}), 21804it is not at the same level; in this case, it is not a term of the 21805same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select 21806the whole product @samp{a*b*c} as a term of the sum) followed by 21807@w{@kbd{j n}} would successfully select the @samp{x}. 21808 21809Similarly, @kbd{j p} moves the selection from the @samp{b} in this 21810sample formula to the @samp{a}. Both commands accept numeric prefix 21811arguments to move several steps at a time. 21812 21813It is interesting to compare Calc's selection commands with the 21814Emacs Info system's commands for navigating through hierarchically 21815organized documentation. Calc's @kbd{j n} command is completely 21816analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to 21817@kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}. 21818(Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.) 21819The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and 21820@kbd{j l}; in each case, you can jump directly to a sub-component 21821of the hierarchy simply by pointing to it with the cursor. 21822 21823@node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas 21824@subsection Displaying Selections 21825 21826@noindent 21827@kindex j d 21828@pindex calc-show-selections 21829@vindex calc-highlight-selections-with-faces 21830@vindex calc-selected-face 21831@vindex calc-nonselected-face 21832The @kbd{j d} (@code{calc-show-selections}) command controls how 21833selected sub-formulas are displayed. One of the alternatives is 21834illustrated in the above examples; if we press @kbd{j d} we switch 21835to the other style in which the selected portion itself is obscured 21836by @samp{#} signs: 21837 21838@smallexample 21839@group 21840 3 ... # ___ 21841 (a + b) . . . ## # ## + V c 218421* ............... 1* --------------- 21843 . . . . 2 x + 1 21844@end group 21845@end smallexample 21846If the customizable variable 21847@code{calc-highlight-selections-with-faces} is non-@code{nil}, then the 21848non-selected portion of the formula will be de-emphasized by using a 21849less noticeable face (@code{calc-nonselected-face}) instead of dots 21850and the selected sub-formula will be highlighted by using a more 21851noticeable face (@code{calc-selected-face}) instead of @samp{#} 21852signs. (@pxref{Customizing Calc}.) 21853 21854@node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas 21855@subsection Operating on Selections 21856 21857@noindent 21858Once a selection is made, all Calc commands that manipulate items 21859on the stack will operate on the selected portions of the items 21860instead. (Note that several stack elements may have selections 21861at once, though there can be only one selection at a time in any 21862given stack element.) 21863 21864@kindex j e 21865@pindex calc-enable-selections 21866The @kbd{j e} (@code{calc-enable-selections}) command disables the 21867effect that selections have on Calc commands. The current selections 21868still exist, but Calc commands operate on whole stack elements anyway. 21869This mode can be identified by the fact that the @samp{*} markers on 21870the line numbers are gone, even though selections are visible. To 21871reactivate the selections, press @kbd{j e} again. 21872 21873To extract a sub-formula as a new formula, simply select the 21874sub-formula and press @key{RET}. This normally duplicates the top 21875stack element; here it duplicates only the selected portion of that 21876element. 21877 21878To replace a sub-formula with something different, you can enter the 21879new value onto the stack and press @key{TAB}. This normally exchanges 21880the top two stack elements; here it swaps the value you entered into 21881the selected portion of the formula, returning the old selected 21882portion to the top of the stack. 21883 21884@smallexample 21885@group 21886 3 ... ... ___ 21887 (a + b) . . . 17 x y . . . 17 x y + V c 218882* ............... 2* ............. 2: ------------- 21889 . . . . . . . . 2 x + 1 21890 21891 3 3 218921: 17 x y 1: (a + b) 1: (a + b) 21893@end group 21894@end smallexample 21895 21896In this example we select a sub-formula of our original example, 21897enter a new formula, @key{TAB} it into place, then deselect to see 21898the complete, edited formula. 21899 21900If you want to swap whole formulas around even though they contain 21901selections, just use @kbd{j e} before and after. 21902 21903@kindex j ' 21904@pindex calc-enter-selection 21905The @kbd{j '} (@code{calc-enter-selection}) command is another way 21906to replace a selected sub-formula. This command does an algebraic 21907entry just like the regular @kbd{'} key. When you press @key{RET}, 21908the formula you type replaces the original selection. You can use 21909the @samp{$} symbol in the formula to refer to the original 21910selection. If there is no selection in the formula under the cursor, 21911the cursor is used to make a temporary selection for the purposes of 21912the command. Thus, to change a term of a formula, all you have to 21913do is move the Emacs cursor to that term and press @kbd{j '}. 21914 21915@kindex j ` 21916@pindex calc-edit-selection 21917The @kbd{j `} (@code{calc-edit-selection}) command is a similar 21918analogue of the @kbd{`} (@code{calc-edit}) command. It edits the 21919selected sub-formula in a separate buffer. If there is no 21920selection, it edits the sub-formula indicated by the cursor. 21921 21922To delete a sub-formula, press @key{DEL}. This generally replaces 21923the sub-formula with the constant zero, but in a few suitable contexts 21924it uses the constant one instead. The @key{DEL} key automatically 21925deselects and re-simplifies the entire formula afterwards. Thus: 21926 21927@smallexample 21928@group 21929 ### 21930 17 x y + # # 17 x y 17 # y 17 y 219311* ------------- 1: ------- 1* ------- 1: ------- 21932 2 x + 1 2 x + 1 2 x + 1 2 x + 1 21933@end group 21934@end smallexample 21935 21936In this example, we first delete the @samp{sqrt(c)} term; Calc 21937accomplishes this by replacing @samp{sqrt(c)} with zero and 21938resimplifying. We then delete the @kbd{x} in the numerator; 21939since this is part of a product, Calc replaces it with @samp{1} 21940and resimplifies. 21941 21942If you select an element of a vector and press @key{DEL}, that 21943element is deleted from the vector. If you delete one side of 21944an equation or inequality, only the opposite side remains. 21945 21946@kindex j DEL 21947@pindex calc-del-selection 21948The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like 21949@key{DEL} but with the auto-selecting behavior of @kbd{j '} and 21950@kbd{j `}. It deletes the selected portion of the formula 21951indicated by the cursor, or, in the absence of a selection, it 21952deletes the sub-formula indicated by the cursor position. 21953 21954@kindex j RET 21955@pindex calc-grab-selection 21956(There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection}) 21957command.) 21958 21959Normal arithmetic operations also apply to sub-formulas. Here we 21960select the denominator, press @kbd{5 -} to subtract five from the 21961denominator, press @kbd{n} to negate the denominator, then 21962press @kbd{Q} to take the square root. 21963 21964@smallexample 21965@group 21966 .. . .. . .. . .. . 219671* ....... 1* ....... 1* ....... 1* .......... 21968 2 x + 1 2 x - 4 4 - 2 x _________ 21969 V 4 - 2 x 21970@end group 21971@end smallexample 21972 21973Certain types of operations on selections are not allowed. For 21974example, for an arithmetic function like @kbd{-} no more than one of 21975the arguments may be a selected sub-formula. (As the above example 21976shows, the result of the subtraction is spliced back into the argument 21977which had the selection; if there were more than one selection involved, 21978this would not be well-defined.) If you try to subtract two selections, 21979the command will abort with an error message. 21980 21981Operations on sub-formulas sometimes leave the formula as a whole 21982in an ``un-natural'' state. Consider negating the @samp{2 x} term 21983of our sample formula by selecting it and pressing @kbd{n} 21984(@code{calc-change-sign}). 21985 21986@smallexample 21987@group 21988 .. . .. . 219891* .......... 1* ........... 21990 ......... .......... 21991 . . . 2 x . . . -2 x 21992@end group 21993@end smallexample 21994 21995Unselecting the sub-formula reveals that the minus sign, which would 21996normally have canceled out with the subtraction automatically, has 21997not been able to do so because the subtraction was not part of the 21998selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing 21999any other mathematical operation on the whole formula will cause it 22000to be simplified. 22001 22002@smallexample 22003@group 22004 17 y 17 y 220051: ----------- 1: ---------- 22006 __________ _________ 22007 V 4 - -2 x V 4 + 2 x 22008@end group 22009@end smallexample 22010 22011@node Rearranging with Selections, , Operating on Selections, Selecting Subformulas 22012@subsection Rearranging Formulas using Selections 22013 22014@noindent 22015@kindex j R 22016@pindex calc-commute-right 22017The @kbd{j R} (@code{calc-commute-right}) command moves the selected 22018sub-formula to the right in its surrounding formula. Generally the 22019selection is one term of a sum or product; the sum or product is 22020rearranged according to the commutative laws of algebra. 22021 22022As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used 22023if there is no selection in the current formula. All commands described 22024in this section share this property. In this example, we place the 22025cursor on the @samp{a} and type @kbd{j R}, then repeat. 22026 22027@smallexample 220281: a + b - c 1: b + a - c 1: b - c + a 22029@end smallexample 22030 22031@noindent 22032Note that in the final step above, the @samp{a} is switched with 22033the @samp{c} but the signs are adjusted accordingly. When moving 22034terms of sums and products, @kbd{j R} will never change the 22035mathematical meaning of the formula. 22036 22037The selected term may also be an element of a vector or an argument 22038of a function. The term is exchanged with the one to its right. 22039In this case, the ``meaning'' of the vector or function may of 22040course be drastically changed. 22041 22042@smallexample 220431: [a, b, c] 1: [b, a, c] 1: [b, c, a] 22044 220451: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a) 22046@end smallexample 22047 22048@kindex j L 22049@pindex calc-commute-left 22050The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R} 22051except that it swaps the selected term with the one to its left. 22052 22053With numeric prefix arguments, these commands move the selected 22054term several steps at a time. It is an error to try to move a 22055term left or right past the end of its enclosing formula. 22056With numeric prefix arguments of zero, these commands move the 22057selected term as far as possible in the given direction. 22058 22059@kindex j D 22060@pindex calc-sel-distribute 22061The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected 22062sum or product into the surrounding formula using the distributive 22063law. For example, in @samp{a * (b - c)} with the @samp{b - c} 22064selected, the result is @samp{a b - a c}. This also distributes 22065products or quotients into surrounding powers, and can also do 22066transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)}, 22067where @samp{a + b} is the selected term, and @samp{ln(a ^ b)} 22068to @samp{ln(a) b}, where @samp{a ^ b} is the selected term. 22069 22070For multiple-term sums or products, @kbd{j D} takes off one term 22071at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b} 22072with the @samp{c - d} selected so that you can type @kbd{j D} 22073repeatedly to expand completely. The @kbd{j D} command allows a 22074numeric prefix argument which specifies the maximum number of 22075times to expand at once; the default is one time only. 22076 22077@vindex DistribRules 22078The @kbd{j D} command is implemented using rewrite rules. 22079@xref{Selections with Rewrite Rules}. The rules are stored in 22080the Calc variable @code{DistribRules}. A convenient way to view 22081these rules is to use @kbd{s e} (@code{calc-edit-variable}) which 22082displays and edits the stored value of a variable. Press @kbd{C-c C-c} 22083to return from editing mode; be careful not to make any actual changes 22084or else you will affect the behavior of future @kbd{j D} commands! 22085 22086To extend @kbd{j D} to handle new cases, just edit @code{DistribRules} 22087as described above. You can then use the @kbd{s p} command to save 22088this variable's value permanently for future Calc sessions. 22089@xref{Operations on Variables}. 22090 22091@kindex j M 22092@pindex calc-sel-merge 22093@vindex MergeRules 22094The @kbd{j M} (@code{calc-sel-merge}) command is the complement 22095of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or 22096@samp{a c} selected, the result is @samp{a * (b - c)}. Once 22097again, @kbd{j M} can also merge calls to functions like @code{exp} 22098and @code{ln}; examine the variable @code{MergeRules} to see all 22099the relevant rules. 22100 22101@kindex j C 22102@pindex calc-sel-commute 22103@vindex CommuteRules 22104The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments 22105of the selected sum, product, or equation. It always behaves as 22106if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is 22107treated as the nested sums @samp{(a + b) + c} by this command. 22108If you put the cursor on the first @samp{+}, the result is 22109@samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the 22110result is @samp{c + (a + b)} (which the default simplifications 22111will rearrange to @samp{(c + a) + b}). The relevant rules are stored 22112in the variable @code{CommuteRules}. 22113 22114You may need to turn default simplifications off (with the @kbd{m O} 22115command) in order to get the full benefit of @kbd{j C}. For example, 22116commuting @samp{a - b} produces @samp{-b + a}, but the default 22117simplifications will ``simplify'' this right back to @samp{a - b} if 22118you don't turn them off. The same is true of some of the other 22119manipulations described in this section. 22120 22121@kindex j N 22122@pindex calc-sel-negate 22123@vindex NegateRules 22124The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected 22125term with the negative of that term, then adjusts the surrounding 22126formula in order to preserve the meaning. For example, given 22127@samp{exp(a - b)} where @samp{a - b} is selected, the result is 22128@samp{1 / exp(b - a)}. By contrast, selecting a term and using the 22129regular @kbd{n} (@code{calc-change-sign}) command negates the 22130term without adjusting the surroundings, thus changing the meaning 22131of the formula as a whole. The rules variable is @code{NegateRules}. 22132 22133@kindex j & 22134@pindex calc-sel-invert 22135@vindex InvertRules 22136The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N} 22137except it takes the reciprocal of the selected term. For example, 22138given @samp{a - ln(b)} with @samp{b} selected, the result is 22139@samp{a + ln(1/b)}. The rules variable is @code{InvertRules}. 22140 22141@kindex j E 22142@pindex calc-sel-jump-equals 22143@vindex JumpRules 22144The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the 22145selected term from one side of an equation to the other. Given 22146@samp{a + b = c + d} with @samp{c} selected, the result is 22147@samp{a + b - c = d}. This command also works if the selected 22148term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The 22149relevant rules variable is @code{JumpRules}. 22150 22151@kindex j I 22152@kindex H j I 22153@pindex calc-sel-isolate 22154The @kbd{j I} (@code{calc-sel-isolate}) command isolates the 22155selected term on its side of an equation. It uses the @kbd{a S} 22156(@code{calc-solve-for}) command to solve the equation, and the 22157Hyperbolic flag affects it in the same way. @xref{Solving Equations}. 22158When it applies, @kbd{j I} is often easier to use than @kbd{j E}. 22159It understands more rules of algebra, and works for inequalities 22160as well as equations. 22161 22162@kindex j * 22163@kindex j / 22164@pindex calc-sel-mult-both-sides 22165@pindex calc-sel-div-both-sides 22166The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a 22167formula using algebraic entry, then multiplies both sides of the 22168selected quotient or equation by that formula. It performs the 22169default algebraic simplifications before re-forming the 22170quotient or equation. You can suppress this simplification by 22171providing a prefix argument: @kbd{C-u j *}. There is also a @kbd{j /} 22172(@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but 22173dividing instead of multiplying by the factor you enter. 22174 22175If the selection is a quotient with numerator 1, then Calc's default 22176simplifications would normally cancel the new factors. To prevent 22177this, when the @kbd{j *} command is used on a selection whose numerator is 221781 or -1, the denominator is expanded at the top level using the 22179distributive law (as if using the @kbd{C-u 1 a x} command). Suppose the 22180formula on the stack is @samp{1 / (a + 1)} and you wish to multiplying the 22181top and bottom by @samp{a - 1}. Calc's default simplifications would 22182normally change the result @samp{(a - 1) /(a + 1) (a - 1)} back 22183to the original form by cancellation; when @kbd{j *} is used, Calc 22184expands the denominator to @samp{a (a - 1) + a - 1} to prevent this. 22185 22186If you wish the @kbd{j *} command to completely expand the denominator 22187of a quotient you can call it with a zero prefix: @kbd{C-u 0 j *}. For 22188example, if the formula on the stack is @samp{1 / (sqrt(a) + 1)}, you may 22189wish to eliminate the square root in the denominator by multiplying 22190the top and bottom by @samp{sqrt(a) - 1}. If you did this simply by using 22191a simple @kbd{j *} command, you would get 22192@samp{(sqrt(a)-1)/ (sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1)}. Instead, 22193you would probably want to use @kbd{C-u 0 j *}, which would expand the 22194bottom and give you the desired result @samp{(sqrt(a)-1)/(a-1)}. More 22195generally, if @kbd{j *} is called with an argument of a positive 22196integer @var{n}, then the denominator of the expression will be 22197expanded @var{n} times (as if with the @kbd{C-u @var{n} a x} command). 22198 22199If the selection is an inequality, @kbd{j *} and @kbd{j /} will 22200accept any factor, but will warn unless they can prove the factor 22201is either positive or negative. (In the latter case the direction 22202of the inequality will be switched appropriately.) @xref{Declarations}, 22203for ways to inform Calc that a given variable is positive or 22204negative. If Calc can't tell for sure what the sign of the factor 22205will be, it will assume it is positive and display a warning 22206message. 22207 22208For selections that are not quotients, equations, or inequalities, 22209these commands pull out a multiplicative factor: They divide (or 22210multiply) by the entered formula, simplify, then multiply (or divide) 22211back by the formula. 22212 22213@kindex j + 22214@kindex j - 22215@pindex calc-sel-add-both-sides 22216@pindex calc-sel-sub-both-sides 22217The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -} 22218(@code{calc-sel-sub-both-sides}) commands analogously add to or 22219subtract from both sides of an equation or inequality. For other 22220types of selections, they extract an additive factor. A numeric 22221prefix argument suppresses simplification of the intermediate 22222results. 22223 22224@kindex j U 22225@pindex calc-sel-unpack 22226The @kbd{j U} (@code{calc-sel-unpack}) command replaces the 22227selected function call with its argument. For example, given 22228@samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result 22229is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you 22230wanted to change the @code{sin} to @code{cos}, just press @kbd{C} 22231now to take the cosine of the selected part.) 22232 22233@kindex j v 22234@pindex calc-sel-evaluate 22235The @kbd{j v} (@code{calc-sel-evaluate}) command performs the 22236basic simplifications on the selected sub-formula. 22237These simplifications would normally be done automatically 22238on all results, but may have been partially inhibited by 22239previous selection-related operations, or turned off altogether 22240by the @kbd{m O} command. This command is just an auto-selecting 22241version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}). 22242 22243With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies 22244the default algebraic simplifications to the selected 22245sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v} 22246applies the @kbd{a e} (@code{calc-simplify-extended}) command. 22247@xref{Simplifying Formulas}. With a negative prefix argument 22248it simplifies at the top level only, just as with @kbd{a v}. 22249Here the ``top'' level refers to the top level of the selected 22250sub-formula. 22251 22252@kindex j " 22253@pindex calc-sel-expand-formula 22254The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "} 22255(@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}. 22256 22257You can use the @kbd{j r} (@code{calc-rewrite-selection}) command 22258to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}. 22259 22260@node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra 22261@section Algebraic Manipulation 22262 22263@noindent 22264The commands in this section perform general-purpose algebraic 22265manipulations. They work on the whole formula at the top of the 22266stack (unless, of course, you have made a selection in that 22267formula). 22268 22269Many algebra commands prompt for a variable name or formula. If you 22270answer the prompt with a blank line, the variable or formula is taken 22271from top-of-stack, and the normal argument for the command is taken 22272from the second-to-top stack level. 22273 22274@kindex a v 22275@pindex calc-alg-evaluate 22276The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal 22277default simplifications on a formula; for example, @samp{a - -b} is 22278changed to @samp{a + b}. These simplifications are normally done 22279automatically on all Calc results, so this command is useful only if 22280you have turned default simplifications off with an @kbd{m O} 22281command. @xref{Simplification Modes}. 22282 22283It is often more convenient to type @kbd{=}, which is like @kbd{a v} 22284but which also substitutes stored values for variables in the formula. 22285Use @kbd{a v} if you want the variables to ignore their stored values. 22286 22287If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies 22288using Calc's algebraic simplifications; @pxref{Simplifying Formulas}. 22289If you give a numeric prefix of 3 or more, it uses Extended 22290Simplification mode (@kbd{a e}). 22291 22292If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3}, 22293it simplifies in the corresponding mode but only works on the top-level 22294function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will 22295simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas 22296@samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector 22297@samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])} 22298in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to 2229910; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}. 22300(@xref{Reducing and Mapping}.) 22301 22302@tindex evalv 22303@tindex evalvn 22304The @kbd{=} command corresponds to the @code{evalv} function, and 22305the related @kbd{N} command, which is like @kbd{=} but temporarily 22306disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds 22307to the @code{evalvn} function. (These commands interpret their prefix 22308arguments differently than @kbd{a v}; @kbd{=} treats the prefix as 22309the number of stack elements to evaluate at once, and @kbd{N} treats 22310it as a temporary different working precision.) 22311 22312The @code{evalvn} function can take an alternate working precision 22313as an optional second argument. This argument can be either an 22314integer, to set the precision absolutely, or a vector containing 22315a single integer, to adjust the precision relative to the current 22316precision. Note that @code{evalvn} with a larger than current 22317precision will do the calculation at this higher precision, but the 22318result will as usual be rounded back down to the current precision 22319afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision 22320of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)} 22321will return @samp{9.26535897932e-5} (computing a 25-digit result which 22322is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])} 22323will return @samp{9.2654e-5}. 22324 22325@kindex a " 22326@pindex calc-expand-formula 22327The @kbd{a "} (@code{calc-expand-formula}) command expands functions 22328into their defining formulas wherever possible. For example, 22329@samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions, 22330like @code{sin} and @code{gcd}, are not defined by simple formulas 22331and so are unaffected by this command. One important class of 22332functions which @emph{can} be expanded is the user-defined functions 22333created by the @kbd{Z F} command. @xref{Algebraic Definitions}. 22334Other functions which @kbd{a "} can expand include the probability 22335distribution functions, most of the financial functions, and the 22336hyperbolic and inverse hyperbolic functions. A numeric prefix argument 22337affects @kbd{a "} in the same way as it does @kbd{a v}: A positive 22338argument expands all functions in the formula and then simplifies in 22339various ways; a negative argument expands and simplifies only the 22340top-level function call. 22341 22342@kindex a M 22343@pindex calc-map-equation 22344@tindex mapeq 22345The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies 22346a given function or operator to one or more equations. It is analogous 22347to @kbd{V M}, which operates on vectors instead of equations. 22348@pxref{Reducing and Mapping}. For example, @kbd{a M S} changes 22349@samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with 22350@samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}. 22351With two equations on the stack, @kbd{a M +} would add the lefthand 22352sides together and the righthand sides together to get the two 22353respective sides of a new equation. 22354 22355Mapping also works on inequalities. Mapping two similar inequalities 22356produces another inequality of the same type. Mapping an inequality 22357with an equation produces an inequality of the same type. Mapping a 22358@samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}. 22359If inequalities with opposite direction (e.g., @samp{<} and @samp{>}) 22360are mapped, the direction of the second inequality is reversed to 22361match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2} 22362reverses the latter to get @samp{2 < a}, which then allows the 22363combination @samp{a + 2 < b + a}, which the algebraic simplifications 22364can reduce to @samp{2 < b}. 22365 22366Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate 22367or invert an inequality will reverse the direction of the inequality. 22368Other adjustments to inequalities are @emph{not} done automatically; 22369@kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even 22370though this is not true for all values of the variables. 22371 22372@kindex H a M 22373@tindex mapeqp 22374With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain 22375mapping operation without reversing the direction of any inequalities. 22376Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}. 22377(This change is mathematically incorrect, but perhaps you were 22378fixing an inequality which was already incorrect.) 22379 22380@kindex I a M 22381@tindex mapeqr 22382With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses 22383the direction of the inequality. You might use @kbd{I a M C} to 22384change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are 22385working with small positive angles. 22386 22387@kindex a b 22388@pindex calc-substitute 22389@tindex subst 22390The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes 22391all occurrences 22392of some variable or sub-expression of an expression with a new 22393sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)} 22394in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces 22395@samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}. 22396Note that this is a purely structural substitution; the lone @samp{x} and 22397the @samp{sin(2 x)} stayed the same because they did not look like 22398@samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for 22399doing substitutions. 22400 22401The @kbd{a b} command normally prompts for two formulas, the old 22402one and the new one. If you enter a blank line for the first 22403prompt, all three arguments are taken from the stack (new, then old, 22404then target expression). If you type an old formula but then enter a 22405blank line for the new one, the new formula is taken from top-of-stack 22406and the target from second-to-top. If you answer both prompts, the 22407target is taken from top-of-stack as usual. 22408 22409Note that @kbd{a b} has no understanding of commutativity or 22410associativity. The pattern @samp{x+y} will not match the formula 22411@samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z} 22412because the @samp{+} operator is left-associative, so the ``deep 22413structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U} 22414(@code{calc-unformatted-language}) mode to see the true structure of 22415a formula. The rewrite rule mechanism, discussed later, does not have 22416these limitations. 22417 22418As an algebraic function, @code{subst} takes three arguments: 22419Target expression, old, new. Note that @code{subst} is always 22420evaluated immediately, even if its arguments are variables, so if 22421you wish to put a call to @code{subst} onto the stack you must 22422turn the default simplifications off first (with @kbd{m O}). 22423 22424@node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra 22425@section Simplifying Formulas 22426 22427@noindent 22428@kindex a s 22429@kindex I a s 22430@kindex H a s 22431@pindex calc-simplify 22432@tindex simplify 22433 22434The sections below describe all the various kinds of 22435simplifications Calc provides in full detail. None of Calc's 22436simplification commands are designed to pull rabbits out of hats; 22437they simply apply certain specific rules to put formulas into 22438less redundant or more pleasing forms. Serious algebra in Calc 22439must be done manually, usually with a combination of selections 22440and rewrite rules. @xref{Rearranging with Selections}. 22441@xref{Rewrite Rules}. 22442 22443@xref{Simplification Modes}, for commands to control what level of 22444simplification occurs automatically. Normally the algebraic 22445simplifications described below occur. If you have turned on a 22446simplification mode which does not do these algebraic simplifications, 22447you can still apply them to a formula with the @kbd{a s} 22448(@code{calc-simplify}) [@code{simplify}] command. 22449 22450There are some simplifications that, while sometimes useful, are never 22451done automatically. For example, the @kbd{I} prefix can be given to 22452@kbd{a s}; the @kbd{I a s} command will change any trigonometric 22453function to the appropriate combination of @samp{sin}s and @samp{cos}s 22454before simplifying. This can be useful in simplifying even mildly 22455complicated trigonometric expressions. For example, while the algebraic 22456simplifications can reduce @samp{sin(x) csc(x)} to @samp{1}, they will not 22457simplify @samp{sin(x)^2 csc(x)}. The command @kbd{I a s} can be used to 22458simplify this latter expression; it will transform @samp{sin(x)^2 22459csc(x)} into @samp{sin(x)}. However, @kbd{I a s} will also perform 22460some ``simplifications'' which may not be desired; for example, it 22461will transform @samp{tan(x)^2} into @samp{sin(x)^2 / cos(x)^2}. The 22462Hyperbolic prefix @kbd{H} can be used similarly; the @kbd{H a s} will 22463replace any hyperbolic functions in the formula with the appropriate 22464combinations of @samp{sinh}s and @samp{cosh}s before simplifying. 22465 22466@menu 22467* Basic Simplifications:: 22468* Algebraic Simplifications:: 22469* Unsafe Simplifications:: 22470* Simplification of Units:: 22471@end menu 22472 22473@node Basic Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas 22474@subsection Basic Simplifications 22475 22476@noindent 22477@cindex Basic simplifications 22478This section describes basic simplifications which Calc performs in many 22479situations. For example, both binary simplifications and algebraic 22480simplifications begin by performing these basic simplifications. You 22481can type @kbd{m I} to restrict the simplifications done on the stack to 22482these simplifications. 22483 22484The most basic simplification is the evaluation of functions. 22485For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)} 22486is evaluated to @expr{3}. Evaluation does not occur if the arguments 22487to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}), 22488range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}), 22489or if the function name is not recognized (@expr{@tfn{f}(5)}), or if 22490Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation 22491(@expr{@tfn{sqrt}(2)}). 22492 22493Calc simplifies (evaluates) the arguments to a function before it 22494simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is 22495simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function 22496itself is applied. There are very few exceptions to this rule: 22497@code{quote}, @code{lambda}, and @code{condition} (the @code{::} 22498operator) do not evaluate their arguments, @code{if} (the @code{? :} 22499operator) does not evaluate all of its arguments, and @code{evalto} 22500does not evaluate its lefthand argument. 22501 22502Most commands apply at least these basic simplifications to all 22503arguments they take from the stack, perform a particular operation, 22504then simplify the result before pushing it back on the stack. In the 22505common special case of regular arithmetic commands like @kbd{+} and 22506@kbd{Q} [@code{sqrt}], the arguments are simply popped from the stack 22507and collected into a suitable function call, which is then simplified 22508(the arguments being simplified first as part of the process, as 22509described above). 22510 22511Even the basic set of simplifications are too numerous to describe 22512completely here, but this section will describe the ones that apply to the 22513major arithmetic operators. This list will be rather technical in 22514nature, and will probably be interesting to you only if you are 22515a serious user of Calc's algebra facilities. 22516 22517@tex 22518\bigskip 22519@end tex 22520 22521As well as the simplifications described here, if you have stored 22522any rewrite rules in the variable @code{EvalRules} then these rules 22523will also be applied before any of the basic simplifications. 22524@xref{Automatic Rewrites}, for details. 22525 22526@tex 22527\bigskip 22528@end tex 22529 22530And now, on with the basic simplifications: 22531 22532Arithmetic operators like @kbd{+} and @kbd{*} always take two 22533arguments in Calc's internal form. Sums and products of three or 22534more terms are arranged by the associative law of algebra into 22535a left-associative form for sums, @expr{((a + b) + c) + d}, and 22536(by default) a right-associative form for products, 22537@expr{a * (b * (c * d))}. Formulas like @expr{(a + b) + (c + d)} are 22538rearranged to left-associative form, though this rarely matters since 22539Calc's algebra commands are designed to hide the inner structure of sums 22540and products as much as possible. Sums and products in their proper 22541associative form will be written without parentheses in the examples 22542below. 22543 22544Sums and products are @emph{not} rearranged according to the 22545commutative law (@expr{a + b} to @expr{b + a}) except in a few 22546special cases described below. Some algebra programs always 22547rearrange terms into a canonical order, which enables them to 22548see that @expr{a b + b a} can be simplified to @expr{2 a b}. 22549If you are using Basic Simplification mode, Calc assumes you have put 22550the terms into the order you want and generally leaves that order alone, 22551with the consequence that formulas like the above will only be 22552simplified if you explicitly give the @kbd{a s} command. 22553@xref{Algebraic Simplifications}. 22554 22555Differences @expr{a - b} are treated like sums @expr{a + (-b)} 22556for purposes of simplification; one of the default simplifications 22557is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b} 22558represents a ``negative-looking'' term, into @expr{a - b} form. 22559``Negative-looking'' means negative numbers, negated formulas like 22560@expr{-x}, and products or quotients in which either term is 22561negative-looking. 22562 22563Other simplifications involving negation are @expr{-(-x)} to @expr{x}; 22564@expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is 22565negative-looking, simplified by negating that term, or else where 22566@expr{a} or @expr{b} is any number, by negating that number; 22567@expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}. 22568(This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only 22569cases where the order of terms in a sum is changed by the default 22570simplifications.) 22571 22572The distributive law is used to simplify sums in some cases: 22573@expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents 22574a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x}) 22575and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or 22576@kbd{j M} commands to merge sums with non-numeric coefficients 22577using the distributive law. 22578 22579The distributive law is only used for sums of two terms, or 22580for adjacent terms in a larger sum. Thus @expr{a + b + b + c} 22581is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b} 22582is not simplified. The reason is that comparing all terms of a 22583sum with one another would require time proportional to the 22584square of the number of terms; Calc omits potentially slow 22585operations like this in basic simplification mode. 22586 22587Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}. 22588A consequence of the above rules is that @expr{0 - a} is simplified 22589to @expr{-a}. 22590 22591@tex 22592\bigskip 22593@end tex 22594 22595The products @expr{1 a} and @expr{a 1} are simplified to @expr{a}; 22596@expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a}; 22597@expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that 22598in Matrix mode where @expr{a} is not provably scalar the result 22599is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is 22600infinite the result is @samp{nan}. 22601 22602Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)}, 22603where this occurs for negated formulas but not for regular negative 22604numbers. 22605 22606Products are commuted only to move numbers to the front: 22607@expr{a b 2} is commuted to @expr{2 a b}. 22608 22609The product @expr{a (b + c)} is distributed over the sum only if 22610@expr{a} and at least one of @expr{b} and @expr{c} are numbers: 22611@expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula 22612@expr{(-a) (b - c)}, where @expr{-a} is a negative number, is 22613rewritten to @expr{a (c - b)}. 22614 22615The distributive law of products and powers is used for adjacent 22616terms of the product: @expr{x^a x^b} goes to 22617@texline @math{x^{a+b}} 22618@infoline @expr{x^(a+b)} 22619where @expr{a} is a number, or an implicit 1 (as in @expr{x}), 22620or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for 22621@expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt} 22622if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively. 22623If the sum of the powers is zero, the product is simplified to 22624@expr{1} or to @samp{idn(1)} if Matrix mode is enabled. 22625 22626The product of a negative power times anything but another negative 22627power is changed to use division: 22628@texline @math{x^{-2} y} 22629@infoline @expr{x^(-2) y} 22630goes to @expr{y / x^2} unless Matrix mode is 22631in effect and neither @expr{x} nor @expr{y} are scalar (in which 22632case it is considered unsafe to rearrange the order of the terms). 22633 22634Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also 22635@expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode. 22636 22637@tex 22638\bigskip 22639@end tex 22640 22641Simplifications for quotients are analogous to those for products. 22642The quotient @expr{0 / x} is simplified to @expr{0}, with the same 22643exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1} 22644and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x}, 22645respectively. 22646 22647The quotient @expr{x / 0} is left unsimplified or changed to an 22648infinite quantity, as directed by the current infinite mode. 22649@xref{Infinite Mode}. 22650 22651The expression 22652@texline @math{a / b^{-c}} 22653@infoline @expr{a / b^(-c)} 22654is changed to @expr{a b^c}, where @expr{-c} is any negative-looking 22655power. Also, @expr{1 / b^c} is changed to 22656@texline @math{b^{-c}} 22657@infoline @expr{b^(-c)} 22658for any power @expr{c}. 22659 22660Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)}; 22661@expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)} 22662goes to @expr{(a c) / b} unless Matrix mode prevents this 22663rearrangement. Similarly, @expr{a / (b:c)} is simplified to 22664@expr{(c:b) a} for any fraction @expr{b:c}. 22665 22666The distributive law is applied to @expr{(a + b) / c} only if 22667@expr{c} and at least one of @expr{a} and @expr{b} are numbers. 22668Quotients of powers and square roots are distributed just as 22669described for multiplication. 22670 22671Quotients of products cancel only in the leading terms of the 22672numerator and denominator. In other words, @expr{a x b / a y b} 22673is canceled to @expr{x b / y b} but not to @expr{x / y}. Once 22674again this is because full cancellation can be slow; use @kbd{a s} 22675to cancel all terms of the quotient. 22676 22677Quotients of negative-looking values are simplified according 22678to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)} 22679to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}. 22680 22681@tex 22682\bigskip 22683@end tex 22684 22685The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)} 22686in Matrix mode. The formula @expr{0^x} is simplified to @expr{0} 22687unless @expr{x} is a negative number, complex number or zero. 22688If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an 22689infinity or an unsimplified formula according to the current infinite 22690mode. The expression @expr{0^0} is simplified to @expr{1}. 22691 22692Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c} 22693are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c} 22694is an integer, or if either @expr{a} or @expr{b} are nonnegative 22695real numbers. Powers of powers @expr{(a^b)^c} are simplified to 22696@texline @math{a^{b c}} 22697@infoline @expr{a^(b c)} 22698only when @expr{c} is an integer and @expr{b c} also 22699evaluates to an integer. Without these restrictions these simplifications 22700would not be safe because of problems with principal values. 22701(In other words, 22702@texline @math{((-3)^{1/2})^2} 22703@infoline @expr{((-3)^1:2)^2} 22704is safe to simplify, but 22705@texline @math{((-3)^2)^{1/2}} 22706@infoline @expr{((-3)^2)^1:2} 22707is not.) @xref{Declarations}, for ways to inform Calc that your 22708variables satisfy these requirements. 22709 22710As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to 22711@texline @math{x^{n/2}} 22712@infoline @expr{x^(n/2)} 22713only for even integers @expr{n}. 22714 22715If @expr{a} is known to be real, @expr{b} is an even integer, and 22716@expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is 22717simplified to @expr{@tfn{abs}(a^(b c))}. 22718 22719Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an 22720even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer, 22721for any negative-looking expression @expr{-a}. 22722 22723Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers 22724@texline @math{x^{1:2}} 22725@infoline @expr{x^1:2} 22726for the purposes of the above-listed simplifications. 22727 22728Also, note that 22729@texline @math{1 / x^{1:2}} 22730@infoline @expr{1 / x^1:2} 22731is changed to 22732@texline @math{x^{-1:2}}, 22733@infoline @expr{x^(-1:2)}, 22734but @expr{1 / @tfn{sqrt}(x)} is left alone. 22735 22736@tex 22737\bigskip 22738@end tex 22739 22740Generic identity matrices (@pxref{Matrix Mode}) are simplified by the 22741following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b} 22742is provably scalar, or expanded out if @expr{b} is a matrix; 22743@expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)}; 22744@expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to 22745@expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b} 22746if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to 22747@expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving 22748@code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where 22749@expr{n} is an integer. 22750 22751@tex 22752\bigskip 22753@end tex 22754 22755The @code{floor} function and other integer truncation functions 22756vanish if the argument is provably integer-valued, so that 22757@expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}. 22758Also, combinations of @code{float}, @code{floor} and its friends, 22759and @code{ffloor} and its friends, are simplified in appropriate 22760ways. @xref{Integer Truncation}. 22761 22762The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}. 22763The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to 22764@expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or 22765@expr{-x} if @expr{x} is provably nonnegative or nonpositive 22766(@pxref{Declarations}). 22767 22768While most functions do not recognize the variable @code{i} as an 22769imaginary number, the @code{arg} function does handle the two cases 22770@expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience. 22771 22772The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}. 22773Various other expressions involving @code{conj}, @code{re}, and 22774@code{im} are simplified, especially if some of the arguments are 22775provably real or involve the constant @code{i}. For example, 22776@expr{@tfn{conj}(a + b i)} is changed to 22777@expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a} 22778and @expr{b} are known to be real. 22779 22780Functions like @code{sin} and @code{arctan} generally don't have 22781any default simplifications beyond simply evaluating the functions 22782for suitable numeric arguments and infinity. The algebraic 22783simplifications described in the next section do provide some 22784simplifications for these functions, though. 22785 22786One important simplification that does occur is that 22787@expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is 22788simplified to @expr{x} for any @expr{x}. This occurs even if you have 22789stored a different value in the Calc variable @samp{e}; but this would 22790be a bad idea in any case if you were also using natural logarithms! 22791 22792Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to 22793@tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides 22794are either negative-looking or zero are simplified by negating both sides 22795and reversing the inequality. While it might seem reasonable to simplify 22796@expr{!!x} to @expr{x}, this would not be valid in general because 22797@expr{!!2} is 1, not 2. 22798 22799Most other Calc functions have few if any basic simplifications 22800defined, aside of course from evaluation when the arguments are 22801suitable numbers. 22802 22803@node Algebraic Simplifications, Unsafe Simplifications, Basic Simplifications, Simplifying Formulas 22804@subsection Algebraic Simplifications 22805 22806@noindent 22807@cindex Algebraic simplifications 22808@kindex a s 22809@kindex m A 22810This section describes all simplifications that are performed by 22811the algebraic simplification mode, which is the default simplification 22812mode. If you have switched to a different simplification mode, you can 22813switch back with the @kbd{m A} command. Even in other simplification 22814modes, the @kbd{a s} command will use these algebraic simplifications to 22815simplify the formula. 22816 22817There is a variable, @code{AlgSimpRules}, in which you can put rewrites 22818to be applied. Its use is analogous to @code{EvalRules}, 22819but without the special restrictions. Basically, the simplifier does 22820@samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole 22821expression being simplified, then it traverses the expression applying 22822the built-in rules described below. If the result is different from 22823the original expression, the process repeats with the basic 22824simplifications (including @code{EvalRules}), then @code{AlgSimpRules}, 22825then the built-in simplifications, and so on. 22826 22827@tex 22828\bigskip 22829@end tex 22830 22831Sums are simplified in two ways. Constant terms are commuted to the 22832end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}. 22833The only exception is that a constant will not be commuted away 22834from the first position of a difference, i.e., @expr{2 - x} is not 22835commuted to @expr{-x + 2}. 22836 22837Also, terms of sums are combined by the distributive law, as in 22838@expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for 22839adjacent terms, but Calc's algebraic simplifications compare all pairs 22840of terms including non-adjacent ones. 22841 22842@tex 22843\bigskip 22844@end tex 22845 22846Products are sorted into a canonical order using the commutative 22847law. For example, @expr{b c a} is commuted to @expr{a b c}. 22848This allows easier comparison of products; for example, the basic 22849simplifications will not change @expr{x y + y x} to @expr{2 x y}, 22850but the algebraic simplifications; it first rewrites the sum to 22851@expr{x y + x y} which can then be recognized as a sum of identical 22852terms. 22853 22854The canonical ordering used to sort terms of products has the 22855property that real-valued numbers, interval forms and infinities 22856come first, and are sorted into increasing order. The @kbd{V S} 22857command uses the same ordering when sorting a vector. 22858 22859Sorting of terms of products is inhibited when Matrix mode is 22860turned on; in this case, Calc will never exchange the order of 22861two terms unless it knows at least one of the terms is a scalar. 22862 22863Products of powers are distributed by comparing all pairs of 22864terms, using the same method that the default simplifications 22865use for adjacent terms of products. 22866 22867Even though sums are not sorted, the commutative law is still 22868taken into account when terms of a product are being compared. 22869Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}. 22870A subtle point is that @expr{(x - y) (y - x)} will @emph{not} 22871be simplified to @expr{-(x - y)^2}; Calc does not notice that 22872one term can be written as a constant times the other, even if 22873that constant is @mathit{-1}. 22874 22875A fraction times any expression, @expr{(a:b) x}, is changed to 22876a quotient involving integers: @expr{a x / b}. This is not 22877done for floating-point numbers like @expr{0.5}, however. This 22878is one reason why you may find it convenient to turn Fraction mode 22879on while doing algebra; @pxref{Fraction Mode}. 22880 22881@tex 22882\bigskip 22883@end tex 22884 22885Quotients are simplified by comparing all terms in the numerator 22886with all terms in the denominator for possible cancellation using 22887the distributive law. For example, @expr{a x^2 b / c x^3 d} will 22888cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}. 22889(The terms in the denominator will then be rearranged to @expr{c d x} 22890as described above.) If there is any common integer or fractional 22891factor in the numerator and denominator, it is canceled out; 22892for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}. 22893 22894Non-constant common factors are not found even by algebraic 22895simplifications. To cancel the factor @expr{a} in 22896@expr{(a x + a) / a^2} you could first use @kbd{j M} on the product 22897@expr{a x} to Merge the numerator to @expr{a (1+x)}, which can then be 22898simplified successfully. 22899 22900@tex 22901\bigskip 22902@end tex 22903 22904Integer powers of the variable @code{i} are simplified according 22905to the identity @expr{i^2 = -1}. If you store a new value other 22906than the complex number @expr{(0,1)} in @code{i}, this simplification 22907will no longer occur. This is not done by the basic 22908simplifications; in case someone (unwisely) wants to use the name 22909@code{i} for a variable unrelated to complex numbers, they can use 22910basic simplification mode. 22911 22912Square roots of integer or rational arguments are simplified in 22913several ways. (Note that these will be left unevaluated only in 22914Symbolic mode.) First, square integer or rational factors are 22915pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as 22916@texline @math{2\,@tfn{sqrt}(2)}. 22917@infoline @expr{2 sqrt(2)}. 22918Conceptually speaking this implies factoring the argument into primes 22919and moving pairs of primes out of the square root, but for reasons of 22920efficiency Calc only looks for primes up to 29. 22921 22922Square roots in the denominator of a quotient are moved to the 22923numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}. 22924The same effect occurs for the square root of a fraction: 22925@expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}. 22926 22927@tex 22928\bigskip 22929@end tex 22930 22931The @code{%} (modulo) operator is simplified in several ways 22932when the modulus @expr{M} is a positive real number. First, if 22933the argument is of the form @expr{x + n} for some real number 22934@expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For 22935example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}. 22936 22937If the argument is multiplied by a constant, and this constant 22938has a common integer divisor with the modulus, then this factor is 22939canceled out. For example, @samp{12 x % 15} is changed to 22940@samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15} 22941is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may 22942not seem ``simpler,'' they allow Calc to discover useful information 22943about modulo forms in the presence of declarations. 22944 22945If the modulus is 1, then Calc can use @code{int} declarations to 22946evaluate the expression. For example, the idiom @samp{x % 2} is 22947often used to check whether a number is odd or even. As described 22948above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to 22949@samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc 22950can simplify these to 0 and 1 (respectively) if @code{n} has been 22951declared to be an integer. 22952 22953@tex 22954\bigskip 22955@end tex 22956 22957Trigonometric functions are simplified in several ways. Whenever a 22958products of two trigonometric functions can be replaced by a single 22959function, the replacement is made; for example, 22960@expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}. 22961Reciprocals of trigonometric functions are replaced by their reciprocal 22962function; for example, @expr{1/@tfn{sec}(x)} is simplified to 22963@expr{@tfn{cos}(x)}. The corresponding simplifications for the 22964hyperbolic functions are also handled. 22965 22966Trigonometric functions of their inverse functions are 22967simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is 22968simplified to @expr{x}, and similarly for @code{cos} and @code{tan}. 22969Trigonometric functions of inverses of different trigonometric 22970functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))} 22971to @expr{@tfn{sqrt}(1 - x^2)}. 22972 22973If the argument to @code{sin} is negative-looking, it is simplified to 22974@expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}. 22975Finally, certain special values of the argument are recognized; 22976@pxref{Trigonometric and Hyperbolic Functions}. 22977 22978Hyperbolic functions of their inverses and of negative-looking 22979arguments are also handled, as are exponentials of inverse 22980hyperbolic functions. 22981 22982No simplifications for inverse trigonometric and hyperbolic 22983functions are known, except for negative arguments of @code{arcsin}, 22984@code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that 22985@expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to 22986@expr{x}, since this only correct within an integer multiple of 22987@texline @math{2 \pi} 22988@infoline @expr{2 pi} 22989radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is 22990simplified to @expr{x} if @expr{x} is known to be real. 22991 22992Several simplifications that apply to logarithms and exponentials 22993are that @expr{@tfn{exp}(@tfn{ln}(x))}, 22994@texline @tfn{e}@math{^{\ln(x)}}, 22995@infoline @expr{e^@tfn{ln}(x)}, 22996and 22997@texline @math{10^{{\rm log10}(x)}} 22998@infoline @expr{10^@tfn{log10}(x)} 22999all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can 23000reduce to @expr{x} if @expr{x} is provably real. The form 23001@expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x} 23002is a suitable multiple of 23003@texline @math{\pi i} 23004@infoline @expr{pi i} 23005(as described above for the trigonometric functions), then 23006@expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally, 23007@expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and 23008@code{i} where @expr{x} is provably negative, positive imaginary, or 23009negative imaginary. 23010 23011The error functions @code{erf} and @code{erfc} are simplified when 23012their arguments are negative-looking or are calls to the @code{conj} 23013function. 23014 23015@tex 23016\bigskip 23017@end tex 23018 23019Equations and inequalities are simplified by canceling factors 23020of products, quotients, or sums on both sides. Inequalities 23021change sign if a negative multiplicative factor is canceled. 23022Non-constant multiplicative factors as in @expr{a b = a c} are 23023canceled from equations only if they are provably nonzero (generally 23024because they were declared so; @pxref{Declarations}). Factors 23025are canceled from inequalities only if they are nonzero and their 23026sign is known. 23027 23028Simplification also replaces an equation or inequality with 230291 or 0 (``true'' or ``false'') if it can through the use of 23030declarations. If @expr{x} is declared to be an integer greater 23031than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are 23032all simplified to 0, but @expr{x > 3} is simplified to 1. 23033By a similar analysis, @expr{abs(x) >= 0} is simplified to 1, 23034as is @expr{x^2 >= 0} if @expr{x} is known to be real. 23035 23036@node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas 23037@subsection ``Unsafe'' Simplifications 23038 23039@noindent 23040@cindex Unsafe simplifications 23041@cindex Extended simplification 23042@kindex a e 23043@kindex m E 23044@pindex calc-simplify-extended 23045@ignore 23046@mindex esimpl@idots 23047@end ignore 23048@tindex esimplify 23049Calc is capable of performing some simplifications which may sometimes 23050be desired but which are not ``safe'' in all cases. The @kbd{a e} 23051(@code{calc-simplify-extended}) [@code{esimplify}] command 23052applies the algebraic simplifications as well as these extended, or 23053``unsafe'', simplifications. Use this only if you know the values in 23054your formula lie in the restricted ranges for which these 23055simplifications are valid. You can use Extended Simplification mode 23056(@kbd{m E}) to have these simplifications done automatically. 23057 23058The symbolic integrator uses these extended simplifications; one effect 23059of this is that the integrator's results must be used with caution. 23060Where an integral table will often attach conditions like ``for positive 23061@expr{a} only,'' Calc (like most other symbolic integration programs) 23062will simply produce an unqualified result. 23063 23064Because @kbd{a e}'s simplifications are unsafe, it is sometimes better 23065to type @kbd{C-u -3 a v}, which does extended simplification only 23066on the top level of the formula without affecting the sub-formulas. 23067In fact, @kbd{C-u -3 j v} allows you to target extended simplification 23068to any specific part of a formula. 23069 23070The variable @code{ExtSimpRules} contains rewrites to be applied when 23071the extended simplifications are used. These are applied in addition to 23072@code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules} 23073step described above is simply followed by an @kbd{a r ExtSimpRules} step.) 23074 23075Following is a complete list of the ``unsafe'' simplifications. 23076 23077@tex 23078\bigskip 23079@end tex 23080 23081Inverse trigonometric or hyperbolic functions, called with their 23082corresponding non-inverse functions as arguments, are simplified. 23083For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes 23084to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and 23085@expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}. 23086These simplifications are unsafe because they are valid only for 23087values of @expr{x} in a certain range; outside that range, values 23088are folded down to the 360-degree range that the inverse trigonometric 23089functions always produce. 23090 23091Powers of powers @expr{(x^a)^b} are simplified to 23092@texline @math{x^{a b}} 23093@infoline @expr{x^(a b)} 23094for all @expr{a} and @expr{b}. These results will be valid only 23095in a restricted range of @expr{x}; for example, in 23096@texline @math{(x^2)^{1:2}} 23097@infoline @expr{(x^2)^1:2} 23098the powers cancel to get @expr{x}, which is valid for positive values 23099of @expr{x} but not for negative or complex values. 23100 23101Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both 23102simplified (possibly unsafely) to 23103@texline @math{x^{a/2}}. 23104@infoline @expr{x^(a/2)}. 23105 23106Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g., 23107@expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin}, 23108@code{cos}, @code{tan}, @code{sinh}, and @code{cosh}. 23109 23110Arguments of square roots are partially factored to look for 23111squared terms that can be extracted. For example, 23112@expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to 23113@expr{a b @tfn{sqrt}(a+b)}. 23114 23115The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))}, 23116@expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also 23117unsafe because of problems with principal values (although these 23118simplifications are safe if @expr{x} is known to be real). 23119 23120Common factors are canceled from products on both sides of an 23121equation, even if those factors may be zero: @expr{a x / b x} 23122to @expr{a / b}. Such factors are never canceled from 23123inequalities: Even the extended simplifications are not bold enough to 23124reduce @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending 23125on whether you believe @expr{x} is positive or negative). 23126The @kbd{a M /} command can be used to divide a factor out of 23127both sides of an inequality. 23128 23129@node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas 23130@subsection Simplification of Units 23131 23132@noindent 23133The simplifications described in this section (as well as the algebraic 23134simplifications) are applied when units need to be simplified. They can 23135be applied using the @kbd{u s} (@code{calc-simplify-units}) command, or 23136will be done automatically in Units Simplification mode (@kbd{m U}). 23137@xref{Basic Operations on Units}. 23138 23139The variable @code{UnitSimpRules} contains rewrites to be applied by 23140units simplifications. These are applied in addition to @code{EvalRules} 23141and @code{AlgSimpRules}. 23142 23143Scalar mode is automatically put into effect when simplifying units. 23144@xref{Matrix Mode}. 23145 23146Sums @expr{a + b} involving units are simplified by extracting the 23147units of @expr{a} as if by the @kbd{u x} command (call the result 23148@expr{u_a}), then simplifying the expression @expr{b / u_a} 23149using @kbd{u b} and @kbd{u s}. If the result has units then the sum 23150is inconsistent and is left alone. Otherwise, it is rewritten 23151in terms of the units @expr{u_a}. 23152 23153If units auto-ranging mode is enabled, products or quotients in 23154which the first argument is a number which is out of range for the 23155leading unit are modified accordingly. 23156 23157When canceling and combining units in products and quotients, 23158Calc accounts for unit names that differ only in the prefix letter. 23159For example, @samp{2 km m} is simplified to @samp{2000 m^2}. 23160However, compatible but different units like @code{ft} and @code{in} 23161are not combined in this way. 23162 23163Quotients @expr{a / b} are simplified in three additional ways. First, 23164if @expr{b} is a number or a product beginning with a number, Calc 23165computes the reciprocal of this number and moves it to the numerator. 23166 23167Second, for each pair of unit names from the numerator and denominator 23168of a quotient, if the units are compatible (e.g., they are both 23169units of area) then they are replaced by the ratio between those 23170units. For example, in @samp{3 s in N / kg cm} the units 23171@samp{in / cm} will be replaced by @expr{2.54}. 23172 23173Third, if the units in the quotient exactly cancel out, so that 23174a @kbd{u b} command on the quotient would produce a dimensionless 23175number for an answer, then the quotient simplifies to that number. 23176 23177For powers and square roots, the ``unsafe'' simplifications 23178@expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c}, 23179and @expr{(a^b)^c} to 23180@texline @math{a^{b c}} 23181@infoline @expr{a^(b c)} 23182are done if the powers are real numbers. (These are safe in the context 23183of units because all numbers involved can reasonably be assumed to be 23184real.) 23185 23186Also, if a unit name is raised to a fractional power, and the 23187base units in that unit name all occur to powers which are a 23188multiple of the denominator of the power, then the unit name 23189is expanded out into its base units, which can then be simplified 23190according to the previous paragraph. For example, @samp{acre^1.5} 23191is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre} 23192is defined in terms of @samp{m^2}, and that the 2 in the power of 23193@code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is 23194replaced by approximately 23195@texline @math{(4046 m^2)^{1.5}} 23196@infoline @expr{(4046 m^2)^1.5}, 23197which is then changed to 23198@texline @math{4046^{1.5} \, (m^2)^{1.5}}, 23199@infoline @expr{4046^1.5 (m^2)^1.5}, 23200then to @expr{257440 m^3}. 23201 23202The functions @code{float}, @code{frac}, @code{clean}, @code{abs}, 23203as well as @code{floor} and the other integer truncation functions, 23204applied to unit names or products or quotients involving units, are 23205simplified. For example, @samp{round(1.6 in)} is changed to 23206@samp{round(1.6) round(in)}; the lefthand term evaluates to 2, 23207and the righthand term simplifies to @code{in}. 23208 23209The functions @code{sin}, @code{cos}, and @code{tan} with arguments 23210that have angular units like @code{rad} or @code{arcmin} are 23211simplified by converting to base units (radians), then evaluating 23212with the angular mode temporarily set to radians. 23213 23214@node Polynomials, Calculus, Simplifying Formulas, Algebra 23215@section Polynomials 23216 23217A @dfn{polynomial} is a sum of terms which are coefficients times 23218various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4} 23219is a polynomial in @expr{x}. Some formulas can be considered 23220polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2} 23221is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients 23222are often numbers, but they may in general be any formulas not 23223involving the base variable. 23224 23225@kindex a f 23226@pindex calc-factor 23227@tindex factor 23228The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a 23229polynomial into a product of terms. For example, the polynomial 23230@expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another 23231example, @expr{a c + b d + b c + a d} is factored into the product 23232@expr{(a + b) (c + d)}. 23233 23234Calc currently has three algorithms for factoring. Formulas which are 23235linear in several variables, such as the second example above, are 23236merged according to the distributive law. Formulas which are 23237polynomials in a single variable, with constant integer or fractional 23238coefficients, are factored into irreducible linear and/or quadratic 23239terms. The first example above factors into three linear terms 23240(@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas 23241which do not fit the above criteria are handled by the algebraic 23242rewrite mechanism. 23243 23244Calc's polynomial factorization algorithm works by using the general 23245root-finding command (@w{@kbd{a P}}) to solve for the roots of the 23246polynomial. It then looks for roots which are rational numbers 23247or complex-conjugate pairs, and converts these into linear and 23248quadratic terms, respectively. Because it uses floating-point 23249arithmetic, it may be unable to find terms that involve large 23250integers (whose number of digits approaches the current precision). 23251Also, irreducible factors of degree higher than quadratic are not 23252found, and polynomials in more than one variable are not treated. 23253(A more robust factorization algorithm may be included in a future 23254version of Calc.) 23255 23256@vindex FactorRules 23257@ignore 23258@starindex 23259@end ignore 23260@tindex thecoefs 23261@ignore 23262@starindex 23263@end ignore 23264@ignore 23265@mindex @idots 23266@end ignore 23267@tindex thefactors 23268The rewrite-based factorization method uses rules stored in the variable 23269@code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the 23270operation of rewrite rules. The default @code{FactorRules} are able 23271to factor quadratic forms symbolically into two linear terms, 23272@expr{(a x + b) (c x + d)}. You can edit these rules to include other 23273cases if you wish. To use the rules, Calc builds the formula 23274@samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial 23275base variable and @code{a}, @code{b}, etc., are polynomial coefficients 23276(which may be numbers or formulas). The constant term is written first, 23277i.e., in the @code{a} position. When the rules complete, they should have 23278changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])} 23279where each @code{fi} should be a factored term, e.g., @samp{x - ai}. 23280Calc then multiplies these terms together to get the complete 23281factored form of the polynomial. If the rules do not change the 23282@code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the 23283polynomial alone on the assumption that it is unfactorable. (Note that 23284the function names @code{thecoefs} and @code{thefactors} are used only 23285as placeholders; there are no actual Calc functions by those names.) 23286 23287@kindex H a f 23288@tindex factors 23289The @kbd{H a f} [@code{factors}] command also factors a polynomial, 23290but it returns a list of factors instead of an expression which is the 23291product of the factors. Each factor is represented by a sub-vector 23292of the factor, and the power with which it appears. For example, 23293@expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2} 23294in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}. 23295If there is an overall numeric factor, it always comes first in the list. 23296The functions @code{factor} and @code{factors} allow a second argument 23297when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with 23298respect to the specific variable @expr{v}. The default is to factor with 23299respect to all the variables that appear in @expr{x}. 23300 23301@kindex a c 23302@pindex calc-collect 23303@tindex collect 23304The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a 23305formula as a 23306polynomial in a given variable, ordered in decreasing powers of that 23307variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on 23308the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)}, 23309and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}. 23310The polynomial will be expanded out using the distributive law as 23311necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces 23312@expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will 23313not be expanded. 23314 23315The ``variable'' you specify at the prompt can actually be any 23316expression: @kbd{a c ln(x+1)} will collect together all terms multiplied 23317by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears 23318in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will 23319treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants. 23320 23321@kindex a x 23322@pindex calc-expand 23323@tindex expand 23324The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an 23325expression by applying the distributive law everywhere. It applies to 23326products, quotients, and powers involving sums. By default, it fully 23327distributes all parts of the expression. With a numeric prefix argument, 23328the distributive law is applied only the specified number of times, then 23329the partially expanded expression is left on the stack. 23330 23331The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use 23332@kbd{a x} if you want to expand all products of sums in your formula. 23333Use @kbd{j D} if you want to expand a particular specified term of 23334the formula. There is an exactly analogous correspondence between 23335@kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands 23336also know many other kinds of expansions, such as 23337@samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f} 23338do not do.) 23339 23340Calc's automatic simplifications will sometimes reverse a partial 23341expansion. For example, the first step in expanding @expr{(x+1)^3} is 23342to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries 23343to put this formula onto the stack, though, Calc will automatically 23344simplify it back to @expr{(x+1)^3} form. The solution is to turn 23345simplification off first (@pxref{Simplification Modes}), or to run 23346@kbd{a x} without a numeric prefix argument so that it expands all 23347the way in one step. 23348 23349@kindex a a 23350@pindex calc-apart 23351@tindex apart 23352The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a 23353rational function by partial fractions. A rational function is the 23354quotient of two polynomials; @code{apart} pulls this apart into a 23355sum of rational functions with simple denominators. In algebraic 23356notation, the @code{apart} function allows a second argument that 23357specifies which variable to use as the ``base''; by default, Calc 23358chooses the base variable automatically. 23359 23360@kindex a n 23361@pindex calc-normalize-rat 23362@tindex nrat 23363The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command 23364attempts to arrange a formula into a quotient of two polynomials. 23365For example, given @expr{1 + (a + b/c) / d}, the result would be 23366@expr{(b + a c + c d) / c d}. The quotient is reduced, so that 23367@kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing 23368out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}. 23369 23370@kindex a \ 23371@pindex calc-poly-div 23372@tindex pdiv 23373The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides 23374two polynomials @expr{u} and @expr{v}, yielding a new polynomial 23375@expr{q}. If several variables occur in the inputs, the inputs are 23376considered multivariate polynomials. (Calc divides by the variable 23377with the largest power in @expr{u} first, or, in the case of equal 23378powers, chooses the variables in alphabetical order.) For example, 23379dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}. 23380The remainder from the division, if any, is reported at the bottom 23381of the screen and is also placed in the Trail along with the quotient. 23382 23383Using @code{pdiv} in algebraic notation, you can specify the particular 23384variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}. 23385If @code{pdiv} is given only two arguments (as is always the case with 23386the @kbd{a \} command), then it does a multivariate division as outlined 23387above. 23388 23389@kindex a % 23390@pindex calc-poly-rem 23391@tindex prem 23392The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides 23393two polynomials and keeps the remainder @expr{r}. The quotient 23394@expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the 23395results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}. 23396(This is analogous to plain @kbd{\} and @kbd{%}, which compute the 23397integer quotient and remainder from dividing two numbers.) 23398 23399@kindex a / 23400@kindex H a / 23401@pindex calc-poly-div-rem 23402@tindex pdivrem 23403@tindex pdivide 23404The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command 23405divides two polynomials and reports both the quotient and the 23406remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}] 23407command divides two polynomials and constructs the formula 23408@expr{q + r/b} on the stack. (Naturally if the remainder is zero, 23409this will immediately simplify to @expr{q}.) 23410 23411@kindex a g 23412@pindex calc-poly-gcd 23413@tindex pgcd 23414The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes 23415the greatest common divisor of two polynomials. (The GCD actually 23416is unique only to within a constant multiplier; Calc attempts to 23417choose a GCD which will be unsurprising.) For example, the @kbd{a n} 23418command uses @kbd{a g} to take the GCD of the numerator and denominator 23419of a quotient, then divides each by the result using @kbd{a \}. (The 23420definition of GCD ensures that this division can take place without 23421leaving a remainder.) 23422 23423While the polynomials used in operations like @kbd{a /} and @kbd{a g} 23424often have integer coefficients, this is not required. Calc can also 23425deal with polynomials over the rationals or floating-point reals. 23426Polynomials with modulo-form coefficients are also useful in many 23427applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc 23428automatically transforms this into a polynomial over the field of 23429integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}. 23430 23431Congratulations and thanks go to Ove Ewerlid 23432(@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the 23433polynomial routines used in the above commands. 23434 23435@xref{Decomposing Polynomials}, for several useful functions for 23436extracting the individual coefficients of a polynomial. 23437 23438@node Calculus, Solving Equations, Polynomials, Algebra 23439@section Calculus 23440 23441@noindent 23442The following calculus commands do not automatically simplify their 23443inputs or outputs using @code{calc-simplify}. You may find it helps 23444to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help 23445to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most 23446readable way. 23447 23448@menu 23449* Differentiation:: 23450* Integration:: 23451* Customizing the Integrator:: 23452* Numerical Integration:: 23453* Taylor Series:: 23454@end menu 23455 23456@node Differentiation, Integration, Calculus, Calculus 23457@subsection Differentiation 23458 23459@noindent 23460@kindex a d 23461@kindex H a d 23462@pindex calc-derivative 23463@tindex deriv 23464@tindex tderiv 23465The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes 23466the derivative of the expression on the top of the stack with respect to 23467some variable, which it will prompt you to enter. Normally, variables 23468in the formula other than the specified differentiation variable are 23469considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With 23470the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used 23471instead, in which derivatives of variables are not reduced to zero 23472unless those variables are known to be ``constant,'' i.e., independent 23473of any other variables. (The built-in special variables like @code{pi} 23474are considered constant, as are variables that have been declared 23475@code{const}; @pxref{Declarations}.) 23476 23477With a numeric prefix argument @var{n}, this command computes the 23478@var{n}th derivative. 23479 23480When working with trigonometric functions, it is best to switch to 23481Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)} 23482in degrees is @samp{(pi/180) cos(x)}, probably not the expected 23483answer! 23484 23485If you use the @code{deriv} function directly in an algebraic formula, 23486you can write @samp{deriv(f,x,x0)} which represents the derivative 23487of @expr{f} with respect to @expr{x}, evaluated at the point 23488@texline @math{x=x_0}. 23489@infoline @expr{x=x0}. 23490 23491If the formula being differentiated contains functions which Calc does 23492not know, the derivatives of those functions are produced by adding 23493primes (apostrophe characters). For example, @samp{deriv(f(2x), x)} 23494produces @samp{2 f'(2 x)}, where the function @code{f'} represents the 23495derivative of @code{f}. 23496 23497For functions you have defined with the @kbd{Z F} command, Calc expands 23498the functions according to their defining formulas unless you have 23499also defined @code{f'} suitably. For example, suppose we define 23500@samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate 23501the formula @samp{sinc(2 x)}, the formula will be expanded to 23502@samp{sin(2 x) / (2 x)} and differentiated. However, if we also 23503define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the 23504result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}. 23505 23506For multi-argument functions @samp{f(x,y,z)}, the derivative with respect 23507to the first argument is written @samp{f'(x,y,z)}; derivatives with 23508respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}. 23509Various higher-order derivatives can be formed in the obvious way, e.g., 23510@samp{f'@var{}'(x)} (the second derivative of @code{f}) or 23511@samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each 23512argument once). 23513 23514@node Integration, Customizing the Integrator, Differentiation, Calculus 23515@subsection Integration 23516 23517@noindent 23518@kindex a i 23519@pindex calc-integral 23520@tindex integ 23521The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the 23522indefinite integral of the expression on the top of the stack with 23523respect to a prompted-for variable. The integrator is not guaranteed to 23524work for all integrable functions, but it is able to integrate several 23525large classes of formulas. In particular, any polynomial or rational 23526function (a polynomial divided by a polynomial) is acceptable. 23527(Rational functions don't have to be in explicit quotient form, however; 23528@texline @math{x/(1+x^{-2})} 23529@infoline @expr{x/(1+x^-2)} 23530is not strictly a quotient of polynomials, but it is equivalent to 23531@expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving 23532@expr{x} and @expr{x^2} may appear in rational functions being 23533integrated. Finally, rational functions involving trigonometric or 23534hyperbolic functions can be integrated. 23535 23536With an argument (@kbd{C-u a i}), this command will compute the definite 23537integral of the expression on top of the stack. In this case, the 23538command will again prompt for an integration variable, then prompt for a 23539lower limit and an upper limit. 23540 23541@ifnottex 23542If you use the @code{integ} function directly in an algebraic formula, 23543you can also write @samp{integ(f,x,v)} which expresses the resulting 23544indefinite integral in terms of variable @code{v} instead of @code{x}. 23545With four arguments, @samp{integ(f(x),x,a,b)} represents a definite 23546integral from @code{a} to @code{b}. 23547@end ifnottex 23548@tex 23549If you use the @code{integ} function directly in an algebraic formula, 23550you can also write @samp{integ(f,x,v)} which expresses the resulting 23551indefinite integral in terms of variable @code{v} instead of @code{x}. 23552With four arguments, @samp{integ(f(x),x,a,b)} represents a definite 23553integral $\int_a^b f(x) \, dx$. 23554@end tex 23555 23556Please note that the current implementation of Calc's integrator sometimes 23557produces results that are significantly more complex than they need to 23558be. For example, the integral Calc finds for 23559@texline @math{1/(x+\sqrt{x^2+1})} 23560@infoline @expr{1/(x+sqrt(x^2+1))} 23561is several times more complicated than the answer Mathematica 23562returns for the same input, although the two forms are numerically 23563equivalent. Also, any indefinite integral should be considered to have 23564an arbitrary constant of integration added to it, although Calc does not 23565write an explicit constant of integration in its result. For example, 23566Calc's solution for 23567@texline @math{1/(1+\tan x)} 23568@infoline @expr{1/(1+tan(x))} 23569differs from the solution given in the @emph{CRC Math Tables} by a 23570constant factor of 23571@texline @math{\pi i / 2} 23572@infoline @expr{pi i / 2}, 23573due to a different choice of constant of integration. 23574 23575The Calculator remembers all the integrals it has done. If conditions 23576change in a way that would invalidate the old integrals, say, a switch 23577from Degrees to Radians mode, then they will be thrown out. If you 23578suspect this is not happening when it should, use the 23579@code{calc-flush-caches} command; @pxref{Caches}. 23580 23581@vindex IntegLimit 23582Calc normally will pursue integration by substitution or integration by 23583parts up to 3 nested times before abandoning an approach as fruitless. 23584If the integrator is taking too long, you can lower this limit by storing 23585a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I} 23586command is a convenient way to edit @code{IntegLimit}.) If this variable 23587has no stored value or does not contain a nonnegative integer, a limit 23588of 3 is used. The lower this limit is, the greater the chance that Calc 23589will be unable to integrate a function it could otherwise handle. Raising 23590this limit allows the Calculator to solve more integrals, though the time 23591it takes may grow exponentially. You can monitor the integrator's actions 23592by creating an Emacs buffer called @file{*Trace*}. If such a buffer 23593exists, the @kbd{a i} command will write a log of its actions there. 23594 23595If you want to manipulate integrals in a purely symbolic way, you can 23596set the integration nesting limit to 0 to prevent all but fast 23597table-lookup solutions of integrals. You might then wish to define 23598rewrite rules for integration by parts, various kinds of substitutions, 23599and so on. @xref{Rewrite Rules}. 23600 23601@node Customizing the Integrator, Numerical Integration, Integration, Calculus 23602@subsection Customizing the Integrator 23603 23604@noindent 23605@vindex IntegRules 23606Calc has two built-in rewrite rules called @code{IntegRules} and 23607@code{IntegAfterRules} which you can edit to define new integration 23608methods. @xref{Rewrite Rules}. At each step of the integration process, 23609Calc wraps the current integrand in a call to the fictitious function 23610@samp{integtry(@var{expr},@var{var})}, where @var{expr} is the 23611integrand and @var{var} is the integration variable. If your rules 23612rewrite this to be a plain formula (not a call to @code{integtry}), then 23613Calc will use this formula as the integral of @var{expr}. For example, 23614the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to 23615integrate a function @code{mysin} that acts like the sine function. 23616Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y} 23617will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has 23618automatically made various transformations on the integral to allow it 23619to use your rule; integral tables generally give rules for 23620@samp{mysin(a x + b)}, but you don't need to use this much generality 23621in your @code{IntegRules}. 23622 23623@cindex Exponential integral Ei(x) 23624@ignore 23625@starindex 23626@end ignore 23627@tindex Ei 23628As a more serious example, the expression @samp{exp(x)/x} cannot be 23629integrated in terms of the standard functions, so the ``exponential 23630integral'' function 23631@texline @math{{\rm Ei}(x)} 23632@infoline @expr{Ei(x)} 23633was invented to describe it. 23634We can get Calc to do this integral in terms of a made-up @code{Ei} 23635function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]} 23636to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack 23637and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will 23638work with Calc's various built-in integration methods (such as 23639integration by substitution) to solve a variety of other problems 23640involving @code{Ei}: For example, now Calc will also be able to 23641integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))} 23642and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively). 23643 23644Your rule may do further integration by calling @code{integ}. For 23645example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc 23646to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}. 23647Note that @code{integ} was called with only one argument. This notation 23648is allowed only within @code{IntegRules}; it means ``integrate this 23649with respect to the same integration variable.'' If Calc is unable 23650to integrate @code{u}, the integration that invoked @code{IntegRules} 23651also fails. Thus integrating @samp{twice(f(x))} fails, returning the 23652unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid 23653to call @code{integ} with two or more arguments, however; in this case, 23654if @code{u} is not integrable, @code{twice} itself will still be 23655integrated: If the above rule is changed to @samp{... := twice(integ(u,x))}, 23656then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}. 23657 23658If a rule instead produces the formula @samp{integsubst(@var{sexpr}, 23659@var{svar})}, either replacing the top-level @code{integtry} call or 23660nested anywhere inside the expression, then Calc will apply the 23661substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to 23662integrate the original @var{expr}. For example, the rule 23663@samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds 23664a square root in the integrand, it should attempt the substitution 23665@samp{u = sqrt(x)}. (This particular rule is unnecessary because 23666Calc always tries ``obvious'' substitutions where @var{sexpr} actually 23667appears in the integrand.) The variable @var{svar} may be the same 23668as the @var{var} that appeared in the call to @code{integtry}, but 23669it need not be. 23670 23671When integrating according to an @code{integsubst}, Calc uses the 23672equation solver to find the inverse of @var{sexpr} (if the integrand 23673refers to @var{var} anywhere except in subexpressions that exactly 23674match @var{sexpr}). It uses the differentiator to find the derivative 23675of @var{sexpr} and/or its inverse (it has two methods that use one 23676derivative or the other). You can also specify these items by adding 23677extra arguments to the @code{integsubst} your rules construct; the 23678general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv}, 23679@var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still 23680written as a function of @var{svar}), and @var{sprime} is the 23681derivative of @var{sexpr} with respect to @var{svar}. If you don't 23682specify these things, and Calc is not able to work them out on its 23683own with the information it knows, then your substitution rule will 23684work only in very specific, simple cases. 23685 23686Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules}; 23687in other words, Calc stops rewriting as soon as any rule in your rule 23688set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)} 23689example above would keep on adding layers of @code{integsubst} calls 23690forever!) 23691 23692@vindex IntegSimpRules 23693Another set of rules, stored in @code{IntegSimpRules}, are applied 23694every time the integrator uses algebraic simplifications to simplify an 23695intermediate result. For example, putting the rule 23696@samp{twice(x) := 2 x} into @code{IntegSimpRules} would tell Calc to 23697convert the @code{twice} function into a form it knows whenever 23698integration is attempted. 23699 23700One more way to influence the integrator is to define a function with 23701the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's 23702integrator automatically expands such functions according to their 23703defining formulas, even if you originally asked for the function to 23704be left unevaluated for symbolic arguments. (Certain other Calc 23705systems, such as the differentiator and the equation solver, also 23706do this.) 23707 23708@vindex IntegAfterRules 23709Sometimes Calc is able to find a solution to your integral, but it 23710expresses the result in a way that is unnecessarily complicated. If 23711this happens, you can either use @code{integsubst} as described 23712above to try to hint at a more direct path to the desired result, or 23713you can use @code{IntegAfterRules}. This is an extra rule set that 23714runs after the main integrator returns its result; basically, Calc does 23715an @kbd{a r IntegAfterRules} on the result before showing it to you. 23716(It also does algebraic simplifications, without @code{IntegSimpRules}, 23717after that to further simplify the result.) For example, Calc's integrator 23718sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)}; 23719the default @code{IntegAfterRules} rewrite this into the more readable 23720form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules}, 23721@code{IntegSimpRules} and @code{IntegAfterRules} are applied any number 23722of times until no further changes are possible. Rewriting by 23723@code{IntegAfterRules} occurs only after the main integrator has 23724finished, not at every step as for @code{IntegRules} and 23725@code{IntegSimpRules}. 23726 23727@node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus 23728@subsection Numerical Integration 23729 23730@noindent 23731@kindex a I 23732@pindex calc-num-integral 23733@tindex ninteg 23734If you want a purely numerical answer to an integration problem, you can 23735use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This 23736command prompts for an integration variable, a lower limit, and an 23737upper limit. Except for the integration variable, all other variables 23738that appear in the integrand formula must have stored values. (A stored 23739value, if any, for the integration variable itself is ignored.) 23740 23741Numerical integration works by evaluating your formula at many points in 23742the specified interval. Calc uses an ``open Romberg'' method; this means 23743that it does not evaluate the formula actually at the endpoints (so that 23744it is safe to integrate @samp{sin(x)/x} from zero, for example). Also, 23745the Romberg method works especially well when the function being 23746integrated is fairly smooth. If the function is not smooth, Calc will 23747have to evaluate it at quite a few points before it can accurately 23748determine the value of the integral. 23749 23750Integration is much faster when the current precision is small. It is 23751best to set the precision to the smallest acceptable number of digits 23752before you use @kbd{a I}. If Calc appears to be taking too long, press 23753@kbd{C-g} to halt it and try a lower precision. If Calc still appears 23754to need hundreds of evaluations, check to make sure your function is 23755well-behaved in the specified interval. 23756 23757It is possible for the lower integration limit to be @samp{-inf} (minus 23758infinity). Likewise, the upper limit may be plus infinity. Calc 23759internally transforms the integral into an equivalent one with finite 23760limits. However, integration to or across singularities is not supported: 23761The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found 23762by Calc's symbolic integrator, for example), but @kbd{a I} will fail 23763because the integrand goes to infinity at one of the endpoints. 23764 23765@node Taylor Series, , Numerical Integration, Calculus 23766@subsection Taylor Series 23767 23768@noindent 23769@kindex a t 23770@pindex calc-taylor 23771@tindex taylor 23772The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a 23773power series expansion or Taylor series of a function. You specify the 23774variable and the desired number of terms. You may give an expression of 23775the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead 23776of just a variable to produce a Taylor expansion about the point @var{a}. 23777You may specify the number of terms with a numeric prefix argument; 23778otherwise the command will prompt you for the number of terms. Note that 23779many series expansions have coefficients of zero for some terms, so you 23780may appear to get fewer terms than you asked for. 23781 23782If the @kbd{a i} command is unable to find a symbolic integral for a 23783function, you can get an approximation by integrating the function's 23784Taylor series. 23785 23786@node Solving Equations, Numerical Solutions, Calculus, Algebra 23787@section Solving Equations 23788 23789@noindent 23790@kindex a S 23791@pindex calc-solve-for 23792@tindex solve 23793@cindex Equations, solving 23794@cindex Solving equations 23795The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges 23796an equation to solve for a specific variable. An equation is an 23797expression of the form @expr{L = R}. For example, the command @kbd{a S x} 23798will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the 23799input is not an equation, it is treated like an equation of the 23800form @expr{X = 0}. 23801 23802This command also works for inequalities, as in @expr{y < 3x + 6}. 23803Some inequalities cannot be solved where the analogous equation could 23804be; for example, solving 23805@texline @math{a < b \, c} 23806@infoline @expr{a < b c} 23807for @expr{b} is impossible 23808without knowing the sign of @expr{c}. In this case, @kbd{a S} will 23809produce the result 23810@texline @math{b \mathbin{\hbox{\code{!=}}} a/c} 23811@infoline @expr{b != a/c} 23812(using the not-equal-to operator) to signify that the direction of the 23813inequality is now unknown. The inequality 23814@texline @math{a \le b \, c} 23815@infoline @expr{a <= b c} 23816is not even partially solved. @xref{Declarations}, for a way to tell 23817Calc that the signs of the variables in a formula are in fact known. 23818 23819Two useful commands for working with the result of @kbd{a S} are 23820@kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2} 23821to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates 23822another formula with @expr{x} set equal to @expr{y/3 - 2}. 23823 23824@menu 23825* Multiple Solutions:: 23826* Solving Systems of Equations:: 23827* Decomposing Polynomials:: 23828@end menu 23829 23830@node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations 23831@subsection Multiple Solutions 23832 23833@noindent 23834@kindex H a S 23835@tindex fsolve 23836Some equations have more than one solution. The Hyperbolic flag 23837(@code{H a S}) [@code{fsolve}] tells the solver to report the fully 23838general family of solutions. It will invent variables @code{n1}, 23839@code{n2}, @dots{}, which represent independent arbitrary integers, and 23840@code{s1}, @code{s2}, @dots{}, which represent independent arbitrary 23841signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic 23842flag, Calc will use zero in place of all arbitrary integers, and plus 23843one in place of all arbitrary signs. Note that variables like @code{n1} 23844and @code{s1} are not given any special interpretation in Calc except by 23845the equation solver itself. As usual, you can use the @w{@kbd{s l}} 23846(@code{calc-let}) command to obtain solutions for various actual values 23847of these variables. 23848 23849For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to 23850get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the 23851equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to 23852think about it is that the square-root operation is really a 23853two-valued function; since every Calc function must return a 23854single result, @code{sqrt} chooses to return the positive result. 23855Then @kbd{H a S} doctors this result using @code{s1} to indicate 23856the full set of possible values of the mathematical square-root. 23857 23858There is a similar phenomenon going the other direction: Suppose 23859we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides 23860to get @samp{y = x^2}. This is correct, except that it introduces 23861some dubious solutions. Consider solving @samp{sqrt(y) = -3}: 23862Calc will report @expr{y = 9} as a valid solution, which is true 23863in the mathematical sense of square-root, but false (there is no 23864solution) for the actual Calc positive-valued @code{sqrt}. This 23865happens for both @kbd{a S} and @kbd{H a S}. 23866 23867@cindex @code{GenCount} variable 23868@vindex GenCount 23869@ignore 23870@starindex 23871@end ignore 23872@tindex an 23873@ignore 23874@starindex 23875@end ignore 23876@tindex as 23877If you store a positive integer in the Calc variable @code{GenCount}, 23878then Calc will generate formulas of the form @samp{as(@var{n})} for 23879arbitrary signs, and @samp{an(@var{n})} for arbitrary integers, 23880where @var{n} represents successive values taken by incrementing 23881@code{GenCount} by one. While the normal arbitrary sign and 23882integer symbols start over at @code{s1} and @code{n1} with each 23883new Calc command, the @code{GenCount} approach will give each 23884arbitrary value a name that is unique throughout the entire Calc 23885session. Also, the arbitrary values are function calls instead 23886of variables, which is advantageous in some cases. For example, 23887you can make a rewrite rule that recognizes all arbitrary signs 23888using a pattern like @samp{as(n)}. The @kbd{s l} command only works 23889on variables, but you can use the @kbd{a b} (@code{calc-substitute}) 23890command to substitute actual values for function calls like @samp{as(3)}. 23891 23892The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient 23893way to create or edit this variable. Press @kbd{C-c C-c} to finish. 23894 23895If you have not stored a value in @code{GenCount}, or if the value 23896in that variable is not a positive integer, the regular 23897@code{s1}/@code{n1} notation is used. 23898 23899@kindex I a S 23900@kindex H I a S 23901@tindex finv 23902@tindex ffinv 23903With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression 23904on top of the stack as a function of the specified variable and solves 23905to find the inverse function, written in terms of the same variable. 23906For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}. 23907You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a 23908fully general inverse, as described above. 23909 23910@kindex a P 23911@pindex calc-poly-roots 23912@tindex roots 23913Some equations, specifically polynomials, have a known, finite number 23914of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}] 23915command uses @kbd{H a S} to solve an equation in general form, then, for 23916all arbitrary-sign variables like @code{s1}, and all arbitrary-integer 23917variables like @code{n1} for which @code{n1} only usefully varies over 23918a finite range, it expands these variables out to all their possible 23919values. The results are collected into a vector, which is returned. 23920For example, @samp{roots(x^4 = 1, x)} returns the four solutions 23921@samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree 23922polynomial will always have @var{n} roots on the complex plane. 23923(If you have given a @code{real} declaration for the solution 23924variable, then only the real-valued solutions, if any, will be 23925reported; @pxref{Declarations}.) 23926 23927Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver 23928symbolic solutions if the polynomial has symbolic coefficients. Also 23929note that Calc's solver is not able to get exact symbolic solutions 23930to all polynomials. Polynomials containing powers up to @expr{x^4} 23931can always be solved exactly; polynomials of higher degree sometimes 23932can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1}, 23933which can be solved for @expr{x^3} using the quadratic equation, and then 23934for @expr{x} by taking cube roots. But in many cases, like 23935@expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial 23936into a form it can solve. The @kbd{a P} command can still deliver a 23937list of numerical roots, however, provided that Symbolic mode (@kbd{m s}) 23938is not turned on. (If you work with Symbolic mode on, recall that the 23939@kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the 23940formula on the stack with Symbolic mode temporarily off.) Naturally, 23941@kbd{a P} can only provide numerical roots if the polynomial coefficients 23942are all numbers (real or complex). 23943 23944@node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations 23945@subsection Solving Systems of Equations 23946 23947@noindent 23948@cindex Systems of equations, symbolic 23949You can also use the commands described above to solve systems of 23950simultaneous equations. Just create a vector of equations, then 23951specify a vector of variables for which to solve. (You can omit 23952the surrounding brackets when entering the vector of variables 23953at the prompt.) 23954 23955For example, putting @samp{[x + y = a, x - y = b]} on the stack 23956and typing @kbd{a S x,y @key{RET}} produces the vector of solutions 23957@samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will 23958have the same length as the variables vector, and the variables 23959will be listed in the same order there. Note that the solutions 23960are not always simplified as far as possible; the solution for 23961@expr{x} here could be improved by an application of the @kbd{a n} 23962command. 23963 23964Calc's algorithm works by trying to eliminate one variable at a 23965time by solving one of the equations for that variable and then 23966substituting into the other equations. Calc will try all the 23967possibilities, but you can speed things up by noting that Calc 23968first tries to eliminate the first variable with the first 23969equation, then the second variable with the second equation, 23970and so on. It also helps to put the simpler (e.g., more linear) 23971equations toward the front of the list. Calc's algorithm will 23972solve any system of linear equations, and also many kinds of 23973nonlinear systems. 23974 23975@ignore 23976@starindex 23977@end ignore 23978@tindex elim 23979Normally there will be as many variables as equations. If you 23980give fewer variables than equations (an ``over-determined'' system 23981of equations), Calc will find a partial solution. For example, 23982typing @kbd{a S y @key{RET}} with the above system of equations 23983would produce @samp{[y = a - x]}. There are now several ways to 23984express this solution in terms of the original variables; Calc uses 23985the first one that it finds. You can control the choice by adding 23986variable specifiers of the form @samp{elim(@var{v})} to the 23987variables list. This says that @var{v} should be eliminated from 23988the equations; the variable will not appear at all in the solution. 23989For example, typing @kbd{a S y,elim(x)} would yield 23990@samp{[y = a - (b+a)/2]}. 23991 23992If the variables list contains only @code{elim} specifiers, 23993Calc simply eliminates those variables from the equations 23994and then returns the resulting set of equations. For example, 23995@kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable 23996eliminated will reduce the number of equations in the system 23997by one. 23998 23999Again, @kbd{a S} gives you one solution to the system of 24000equations. If there are several solutions, you can use @kbd{H a S} 24001to get a general family of solutions, or, if there is a finite 24002number of solutions, you can use @kbd{a P} to get a list. (In 24003the latter case, the result will take the form of a matrix where 24004the rows are different solutions and the columns correspond to the 24005variables you requested.) 24006 24007Another way to deal with certain kinds of overdetermined systems of 24008equations is the @kbd{a F} command, which does least-squares fitting 24009to satisfy the equations. @xref{Curve Fitting}. 24010 24011@node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations 24012@subsection Decomposing Polynomials 24013 24014@noindent 24015@ignore 24016@starindex 24017@end ignore 24018@tindex poly 24019The @code{poly} function takes a polynomial and a variable as 24020arguments, and returns a vector of polynomial coefficients (constant 24021coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns 24022@expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x}, 24023the call to @code{poly} is left in symbolic form. If the input does 24024not involve the variable @expr{x}, the input is returned in a list 24025of length one, representing a polynomial with only a constant 24026coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}. 24027The last element of the returned vector is guaranteed to be nonzero; 24028note that @samp{poly(0, x)} returns the empty vector @expr{[]}. 24029Note also that @expr{x} may actually be any formula; for example, 24030@samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}. 24031 24032@cindex Coefficients of polynomial 24033@cindex Degree of polynomial 24034To get the @expr{x^k} coefficient of polynomial @expr{p}, use 24035@samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p}, 24036use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)} 24037returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)} 24038gives the @expr{x^2} coefficient of this polynomial, 6. 24039 24040@ignore 24041@starindex 24042@end ignore 24043@tindex gpoly 24044One important feature of the solver is its ability to recognize 24045formulas which are ``essentially'' polynomials. This ability is 24046made available to the user through the @code{gpoly} function, which 24047is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}. 24048If @var{expr} is a polynomial in some term which includes @var{var}, then 24049this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]} 24050where @var{x} is the term that depends on @var{var}, @var{c} is a 24051vector of polynomial coefficients (like the one returned by @code{poly}), 24052and @var{a} is a multiplier which is usually 1. Basically, 24053@samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} + 24054@var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is 24055guaranteed to be non-zero, and @var{c} will not equal @samp{[1]} 24056(i.e., the trivial decomposition @var{expr} = @var{x} is not 24057considered a polynomial). One side effect is that @samp{gpoly(x, x)} 24058and @samp{gpoly(6, x)}, both of which might be expected to recognize 24059their arguments as polynomials, will not because the decomposition 24060is considered trivial. 24061 24062For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]}, 24063since the expanded form of this polynomial is @expr{4 - 4 x + x^2}. 24064 24065The term @var{x} may itself be a polynomial in @var{var}. This is 24066done to reduce the size of the @var{c} vector. For example, 24067@samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]}, 24068since a quadratic polynomial in @expr{x^2} is easier to solve than 24069a quartic polynomial in @expr{x}. 24070 24071A few more examples of the kinds of polynomials @code{gpoly} can 24072discover: 24073 24074@smallexample 24075sin(x) - 1 [sin(x), [-1, 1], 1] 24076x + 1/x - 1 [x, [1, -1, 1], 1/x] 24077x + 1/x [x^2, [1, 1], 1/x] 24078x^3 + 2 x [x^2, [2, 1], x] 24079x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2] 24080x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1] 24081(exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x] 24082@end smallexample 24083 24084The @code{poly} and @code{gpoly} functions accept a third integer argument 24085which specifies the largest degree of polynomial that is acceptable. 24086If this is @expr{n}, then only @var{c} vectors of length @expr{n+1} 24087or less will be returned. Otherwise, the @code{poly} or @code{gpoly} 24088call will remain in symbolic form. For example, the equation solver 24089can handle quartics and smaller polynomials, so it calls 24090@samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr} 24091can be treated by its linear, quadratic, cubic, or quartic formulas. 24092 24093@ignore 24094@starindex 24095@end ignore 24096@tindex pdeg 24097The @code{pdeg} function computes the degree of a polynomial; 24098@samp{pdeg(p,x)} is the highest power of @code{x} that appears in 24099@code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is 24100much more efficient. If @code{p} is constant with respect to @code{x}, 24101then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x} 24102(e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated. 24103It is possible to omit the second argument @code{x}, in which case 24104@samp{pdeg(p)} returns the highest total degree of any term of the 24105polynomial, counting all variables that appear in @code{p}. Note 24106that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c}; 24107the degree of the constant zero is considered to be @code{-inf} 24108(minus infinity). 24109 24110@ignore 24111@starindex 24112@end ignore 24113@tindex plead 24114The @code{plead} function finds the leading term of a polynomial. 24115Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))}, 24116though again more efficient. In particular, @samp{plead((2x+1)^10, x)} 24117returns 1024 without expanding out the list of coefficients. The 24118value of @code{plead(p,x)} will be zero only if @expr{p = 0}. 24119 24120@ignore 24121@starindex 24122@end ignore 24123@tindex pcont 24124The @code{pcont} function finds the @dfn{content} of a polynomial. This 24125is the greatest common divisor of all the coefficients of the polynomial. 24126With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)} 24127to get a list of coefficients, then uses @code{pgcd} (the polynomial 24128GCD function) to combine these into an answer. For example, 24129@samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is 24130basically the ``biggest'' polynomial that can be divided into @code{p} 24131exactly. The sign of the content is the same as the sign of the leading 24132coefficient. 24133 24134With only one argument, @samp{pcont(p)} computes the numerical 24135content of the polynomial, i.e., the @code{gcd} of the numerical 24136coefficients of all the terms in the formula. Note that @code{gcd} 24137is defined on rational numbers as well as integers; it computes 24138the @code{gcd} of the numerators and the @code{lcm} of the 24139denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3. 24140Dividing the polynomial by this number will clear all the 24141denominators, as well as dividing by any common content in the 24142numerators. The numerical content of a polynomial is negative only 24143if all the coefficients in the polynomial are negative. 24144 24145@ignore 24146@starindex 24147@end ignore 24148@tindex pprim 24149The @code{pprim} function finds the @dfn{primitive part} of a 24150polynomial, which is simply the polynomial divided (using @code{pdiv} 24151if necessary) by its content. If the input polynomial has rational 24152coefficients, the result will have integer coefficients in simplest 24153terms. 24154 24155@node Numerical Solutions, Curve Fitting, Solving Equations, Algebra 24156@section Numerical Solutions 24157 24158@noindent 24159Not all equations can be solved symbolically. The commands in this 24160section use numerical algorithms that can find a solution to a specific 24161instance of an equation to any desired accuracy. Note that the 24162numerical commands are slower than their algebraic cousins; it is a 24163good idea to try @kbd{a S} before resorting to these commands. 24164 24165(@xref{Curve Fitting}, for some other, more specialized, operations 24166on numerical data.) 24167 24168@menu 24169* Root Finding:: 24170* Minimization:: 24171* Numerical Systems of Equations:: 24172@end menu 24173 24174@node Root Finding, Minimization, Numerical Solutions, Numerical Solutions 24175@subsection Root Finding 24176 24177@noindent 24178@kindex a R 24179@pindex calc-find-root 24180@tindex root 24181@cindex Newton's method 24182@cindex Roots of equations 24183@cindex Numerical root-finding 24184The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a 24185numerical solution (or @dfn{root}) of an equation. (This command treats 24186inequalities the same as equations. If the input is any other kind 24187of formula, it is interpreted as an equation of the form @expr{X = 0}.) 24188 24189The @kbd{a R} command requires an initial guess on the top of the 24190stack, and a formula in the second-to-top position. It prompts for a 24191solution variable, which must appear in the formula. All other variables 24192that appear in the formula must have assigned values, i.e., when 24193a value is assigned to the solution variable and the formula is 24194evaluated with @kbd{=}, it should evaluate to a number. Any assigned 24195value for the solution variable itself is ignored and unaffected by 24196this command. 24197 24198When the command completes, the initial guess is replaced on the stack 24199by a vector of two numbers: The value of the solution variable that 24200solves the equation, and the difference between the lefthand and 24201righthand sides of the equation at that value. Ordinarily, the second 24202number will be zero or very nearly zero. (Note that Calc uses a 24203slightly higher precision while finding the root, and thus the second 24204number may be slightly different from the value you would compute from 24205the equation yourself.) 24206 24207The @kbd{v h} (@code{calc-head}) command is a handy way to extract 24208the first element of the result vector, discarding the error term. 24209 24210The initial guess can be a real number, in which case Calc searches 24211for a real solution near that number, or a complex number, in which 24212case Calc searches the whole complex plane near that number for a 24213solution, or it can be an interval form which restricts the search 24214to real numbers inside that interval. 24215 24216Calc tries to use @kbd{a d} to take the derivative of the equation. 24217If this succeeds, it uses Newton's method. If the equation is not 24218differentiable Calc uses a bisection method. (If Newton's method 24219appears to be going astray, Calc switches over to bisection if it 24220can, or otherwise gives up. In this case it may help to try again 24221with a slightly different initial guess.) If the initial guess is a 24222complex number, the function must be differentiable. 24223 24224If the formula (or the difference between the sides of an equation) 24225is negative at one end of the interval you specify and positive at 24226the other end, the root finder is guaranteed to find a root. 24227Otherwise, Calc subdivides the interval into small parts looking for 24228positive and negative values to bracket the root. When your guess is 24229an interval, Calc will not look outside that interval for a root. 24230 24231@kindex H a R 24232@tindex wroot 24233The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except 24234that if the initial guess is an interval for which the function has 24235the same sign at both ends, then rather than subdividing the interval 24236Calc attempts to widen it to enclose a root. Use this mode if 24237you are not sure if the function has a root in your interval. 24238 24239If the function is not differentiable, and you give a simple number 24240instead of an interval as your initial guess, Calc uses this widening 24241process even if you did not type the Hyperbolic flag. (If the function 24242@emph{is} differentiable, Calc uses Newton's method which does not 24243require a bounding interval in order to work.) 24244 24245If Calc leaves the @code{root} or @code{wroot} function in symbolic 24246form on the stack, it will normally display an explanation for why 24247no root was found. If you miss this explanation, press @kbd{w} 24248(@code{calc-why}) to get it back. 24249 24250@node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions 24251@subsection Minimization 24252 24253@noindent 24254@kindex a N 24255@kindex H a N 24256@kindex a X 24257@kindex H a X 24258@pindex calc-find-minimum 24259@pindex calc-find-maximum 24260@tindex minimize 24261@tindex maximize 24262@cindex Minimization, numerical 24263The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command 24264finds a minimum value for a formula. It is very similar in operation 24265to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial 24266guess on the stack, and are prompted for the name of a variable. The guess 24267may be either a number near the desired minimum, or an interval enclosing 24268the desired minimum. The function returns a vector containing the 24269value of the variable which minimizes the formula's value, along 24270with the minimum value itself. 24271 24272Note that this command looks for a @emph{local} minimum. Many functions 24273have more than one minimum; some, like 24274@texline @math{x \sin x}, 24275@infoline @expr{x sin(x)}, 24276have infinitely many. In fact, there is no easy way to define the 24277``global'' minimum of 24278@texline @math{x \sin x} 24279@infoline @expr{x sin(x)} 24280but Calc can still locate any particular local minimum 24281for you. Calc basically goes downhill from the initial guess until it 24282finds a point at which the function's value is greater both to the left 24283and to the right. Calc does not use derivatives when minimizing a function. 24284 24285If your initial guess is an interval and it looks like the minimum 24286occurs at one or the other endpoint of the interval, Calc will return 24287that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x} 24288over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over 24289@expr{(2..3]} would report no minimum found. In general, you should 24290use closed intervals to find literally the minimum value in that 24291range of @expr{x}, or open intervals to find the local minimum, if 24292any, that happens to lie in that range. 24293 24294Most functions are smooth and flat near their minimum values. Because 24295of this flatness, if the current precision is, say, 12 digits, the 24296variable can only be determined meaningfully to about six digits. Thus 24297you should set the precision to twice as many digits as you need in your 24298answer. 24299 24300@ignore 24301@mindex wmin@idots 24302@end ignore 24303@tindex wminimize 24304@ignore 24305@mindex wmax@idots 24306@end ignore 24307@tindex wmaximize 24308The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R}, 24309expands the guess interval to enclose a minimum rather than requiring 24310that the minimum lie inside the interval you supply. 24311 24312The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and 24313@kbd{H a X} [@code{wmaximize}] commands effectively minimize the 24314negative of the formula you supply. 24315 24316The formula must evaluate to a real number at all points inside the 24317interval (or near the initial guess if the guess is a number). If 24318the initial guess is a complex number the variable will be minimized 24319over the complex numbers; if it is real or an interval it will 24320be minimized over the reals. 24321 24322@node Numerical Systems of Equations, , Minimization, Numerical Solutions 24323@subsection Systems of Equations 24324 24325@noindent 24326@cindex Systems of equations, numerical 24327The @kbd{a R} command can also solve systems of equations. In this 24328case, the equation should instead be a vector of equations, the 24329guess should instead be a vector of numbers (intervals are not 24330supported), and the variable should be a vector of variables. You 24331can omit the brackets while entering the list of variables. Each 24332equation must be differentiable by each variable for this mode to 24333work. The result will be a vector of two vectors: The variable 24334values that solved the system of equations, and the differences 24335between the sides of the equations with those variable values. 24336There must be the same number of equations as variables. Since 24337only plain numbers are allowed as guesses, the Hyperbolic flag has 24338no effect when solving a system of equations. 24339 24340It is also possible to minimize over many variables with @kbd{a N} 24341(or maximize with @kbd{a X}). Once again the variable name should 24342be replaced by a vector of variables, and the initial guess should 24343be an equal-sized vector of initial guesses. But, unlike the case of 24344multidimensional @kbd{a R}, the formula being minimized should 24345still be a single formula, @emph{not} a vector. Beware that 24346multidimensional minimization is currently @emph{very} slow. 24347 24348@node Curve Fitting, Summations, Numerical Solutions, Algebra 24349@section Curve Fitting 24350 24351@noindent 24352The @kbd{a F} command fits a set of data to a @dfn{model formula}, 24353such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters 24354to be determined. For a typical set of measured data there will be 24355no single @expr{m} and @expr{b} that exactly fit the data; in this 24356case, Calc chooses values of the parameters that provide the closest 24357possible fit. The model formula can be entered in various ways after 24358the key sequence @kbd{a F} is pressed. 24359 24360If the letter @kbd{P} is pressed after @kbd{a F} but before the model 24361description is entered, the data as well as the model formula will be 24362plotted after the formula is determined. This will be indicated by a 24363``P'' in the minibuffer after the help message. 24364 24365@menu 24366* Linear Fits:: 24367* Polynomial and Multilinear Fits:: 24368* Error Estimates for Fits:: 24369* Standard Nonlinear Models:: 24370* Curve Fitting Details:: 24371* Interpolation:: 24372@end menu 24373 24374@node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting 24375@subsection Linear Fits 24376 24377@noindent 24378@kindex a F 24379@pindex calc-curve-fit 24380@tindex fit 24381@cindex Linear regression 24382@cindex Least-squares fits 24383The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts 24384to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a 24385straight line, polynomial, or other function of @expr{x}. For the 24386moment we will consider only the case of fitting to a line, and we 24387will ignore the issue of whether or not the model was in fact a good 24388fit for the data. 24389 24390In a standard linear least-squares fit, we have a set of @expr{(x,y)} 24391data points that we wish to fit to the model @expr{y = m x + b} 24392by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y} 24393values calculated from the formula be as close as possible to the actual 24394@expr{y} values in the data set. (In a polynomial fit, the model is 24395instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit, 24396we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is 24397@expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.) 24398 24399In the model formula, variables like @expr{x} and @expr{x_2} are called 24400the @dfn{independent variables}, and @expr{y} is the @dfn{dependent 24401variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called 24402the @dfn{parameters} of the model. 24403 24404The @kbd{a F} command takes the data set to be fitted from the stack. 24405By default, it expects the data in the form of a matrix. For example, 24406for a linear or polynomial fit, this would be a 24407@texline @math{2\times N} 24408@infoline 2xN 24409matrix where the first row is a list of @expr{x} values and the second 24410row has the corresponding @expr{y} values. For the multilinear fit 24411shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2}, 24412@expr{x_3}, and @expr{y}, respectively). 24413 24414If you happen to have an 24415@texline @math{N\times2} 24416@infoline Nx2 24417matrix instead of a 24418@texline @math{2\times N} 24419@infoline 2xN 24420matrix, just press @kbd{v t} first to transpose the matrix. 24421 24422After you type @kbd{a F}, Calc prompts you to select a model. For a 24423linear fit, press the digit @kbd{1}. 24424 24425Calc then prompts for you to name the variables. By default it chooses 24426high letters like @expr{x} and @expr{y} for independent variables and 24427low letters like @expr{a} and @expr{b} for parameters. (The dependent 24428variable doesn't need a name.) The two kinds of variables are separated 24429by a semicolon. Since you generally care more about the names of the 24430independent variables than of the parameters, Calc also allows you to 24431name only those and let the parameters use default names. 24432 24433For example, suppose the data matrix 24434 24435@ifnottex 24436@example 24437@group 24438[ [ 1, 2, 3, 4, 5 ] 24439 [ 5, 7, 9, 11, 13 ] ] 24440@end group 24441@end example 24442@end ifnottex 24443@tex 24444\beforedisplay 24445$$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr 24446 5 & 7 & 9 & 11 & 13 } 24447$$ 24448\afterdisplay 24449@end tex 24450 24451@noindent 24452is on the stack and we wish to do a simple linear fit. Type 24453@kbd{a F}, then @kbd{1} for the model, then @key{RET} to use 24454the default names. The result will be the formula @expr{3. + 2. x} 24455on the stack. Calc has created the model expression @kbd{a + b x}, 24456then found the optimal values of @expr{a} and @expr{b} to fit the 24457data. (In this case, it was able to find an exact fit.) Calc then 24458substituted those values for @expr{a} and @expr{b} in the model 24459formula. 24460 24461The @kbd{a F} command puts two entries in the trail. One is, as 24462always, a copy of the result that went to the stack; the other is 24463a vector of the actual parameter values, written as equations: 24464@expr{[a = 3, b = 2]}, in case you'd rather read them in a list 24465than pick them out of the formula. (You can type @kbd{t y} 24466to move this vector to the stack; see @ref{Trail Commands}. 24467 24468Specifying a different independent variable name will affect the 24469resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}. 24470Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect 24471the equations that go into the trail. 24472 24473@tex 24474\bigskip 24475@end tex 24476 24477To see what happens when the fit is not exact, we could change 24478the number 13 in the data matrix to 14 and try the fit again. 24479The result is: 24480 24481@example 244822.6 + 2.2 x 24483@end example 24484 24485Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows 24486a reasonably close match to the y-values in the data. 24487 24488@example 24489[4.8, 7., 9.2, 11.4, 13.6] 24490@end example 24491 24492Since there is no line which passes through all the @var{n} data points, 24493Calc has chosen a line that best approximates the data points using 24494the method of least squares. The idea is to define the @dfn{chi-square} 24495error measure 24496 24497@ifnottex 24498@example 24499chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N) 24500@end example 24501@end ifnottex 24502@tex 24503\beforedisplay 24504$$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$ 24505\afterdisplay 24506@end tex 24507 24508@noindent 24509which is clearly zero if @expr{a + b x} exactly fits all data points, 24510and increases as various @expr{a + b x_i} values fail to match the 24511corresponding @expr{y_i} values. There are several reasons why the 24512summand is squared, one of them being to ensure that 24513@texline @math{\chi^2 \ge 0}. 24514@infoline @expr{chi^2 >= 0}. 24515Least-squares fitting simply chooses the values of @expr{a} and @expr{b} 24516for which the error 24517@texline @math{\chi^2} 24518@infoline @expr{chi^2} 24519is as small as possible. 24520 24521Other kinds of models do the same thing but with a different model 24522formula in place of @expr{a + b x_i}. 24523 24524@tex 24525\bigskip 24526@end tex 24527 24528A numeric prefix argument causes the @kbd{a F} command to take the 24529data in some other form than one big matrix. A positive argument @var{n} 24530will take @var{N} items from the stack, corresponding to the @var{n} rows 24531of a data matrix. In the linear case, @var{n} must be 2 since there 24532is always one independent variable and one dependent variable. 24533 24534A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two 24535items from the stack, an @var{n}-row matrix of @expr{x} values, and a 24536vector of @expr{y} values. If there is only one independent variable, 24537the @expr{x} values can be either a one-row matrix or a plain vector, 24538in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix. 24539 24540@node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting 24541@subsection Polynomial and Multilinear Fits 24542 24543@noindent 24544To fit the data to higher-order polynomials, just type one of the 24545digits @kbd{2} through @kbd{9} when prompted for a model. For example, 24546we could fit the original data matrix from the previous section 24547(with 13, not 14) to a parabola instead of a line by typing 24548@kbd{a F 2 @key{RET}}. 24549 24550@example 245512.00000000001 x - 1.5e-12 x^2 + 2.99999999999 24552@end example 24553 24554Note that since the constant and linear terms are enough to fit the 24555data exactly, it's no surprise that Calc chose a tiny contribution 24556for @expr{x^2}. (The fact that it's not exactly zero is due only 24557to roundoff error. Since our data are exact integers, we could get 24558an exact answer by typing @kbd{m f} first to get Fraction mode. 24559Then the @expr{x^2} term would vanish altogether. Usually, though, 24560the data being fitted will be approximate floats so Fraction mode 24561won't help.) 24562 24563Doing the @kbd{a F 2} fit on the data set with 14 instead of 13 24564gives a much larger @expr{x^2} contribution, as Calc bends the 24565line slightly to improve the fit. 24566 24567@example 245680.142857142855 x^2 + 1.34285714287 x + 3.59999999998 24569@end example 24570 24571An important result from the theory of polynomial fitting is that it 24572is always possible to fit @var{n} data points exactly using a polynomial 24573of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}. 24574Using the modified (14) data matrix, a model number of 4 gives 24575a polynomial that exactly matches all five data points: 24576 24577@example 245780.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4. 24579@end example 24580 24581The actual coefficients we get with a precision of 12, like 24582@expr{0.0416666663588}, clearly suffer from loss of precision. 24583It is a good idea to increase the working precision to several 24584digits beyond what you need when you do a fitting operation. 24585Or, if your data are exact, use Fraction mode to get exact 24586results. 24587 24588You can type @kbd{i} instead of a digit at the model prompt to fit 24589the data exactly to a polynomial. This just counts the number of 24590columns of the data matrix to choose the degree of the polynomial 24591automatically. 24592 24593Fitting data ``exactly'' to high-degree polynomials is not always 24594a good idea, though. High-degree polynomials have a tendency to 24595wiggle uncontrollably in between the fitting data points. Also, 24596if the exact-fit polynomial is going to be used to interpolate or 24597extrapolate the data, it is numerically better to use the @kbd{a p} 24598command described below. @xref{Interpolation}. 24599 24600@tex 24601\bigskip 24602@end tex 24603 24604Another generalization of the linear model is to assume the 24605@expr{y} values are a sum of linear contributions from several 24606@expr{x} values. This is a @dfn{multilinear} fit, and it is also 24607selected by the @kbd{1} digit key. (Calc decides whether the fit 24608is linear or multilinear by counting the rows in the data matrix.) 24609 24610Given the data matrix, 24611 24612@example 24613@group 24614[ [ 1, 2, 3, 4, 5 ] 24615 [ 7, 2, 3, 5, 2 ] 24616 [ 14.5, 15, 18.5, 22.5, 24 ] ] 24617@end group 24618@end example 24619 24620@noindent 24621the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the 24622second row @expr{y}, and will fit the values in the third row to the 24623model @expr{a + b x + c y}. 24624 24625@example 246268. + 3. x + 0.5 y 24627@end example 24628 24629Calc can do multilinear fits with any number of independent variables 24630(i.e., with any number of data rows). 24631 24632@tex 24633\bigskip 24634@end tex 24635 24636Yet another variation is @dfn{homogeneous} linear models, in which 24637the constant term is known to be zero. In the linear case, this 24638means the model formula is simply @expr{a x}; in the multilinear 24639case, the model might be @expr{a x + b y + c z}; and in the polynomial 24640case, the model could be @expr{a x + b x^2 + c x^3}. You can get 24641a homogeneous linear or multilinear model by pressing the letter 24642@kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}. 24643This will be indicated by an ``h'' in the minibuffer after the help 24644message. 24645 24646It is certainly possible to have other constrained linear models, 24647like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single 24648key to select models like these, a later section shows how to enter 24649any desired model by hand. In the first case, for example, you 24650would enter @kbd{a F ' 2.3 + a x}. 24651 24652Another class of models that will work but must be entered by hand 24653are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}. 24654 24655@node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting 24656@subsection Error Estimates for Fits 24657 24658@noindent 24659@kindex H a F 24660@tindex efit 24661With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same 24662fitting operation as @kbd{a F}, but reports the coefficients as error 24663forms instead of plain numbers. Fitting our two data matrices (first 24664with 13, then with 14) to a line with @kbd{H a F} gives the results, 24665 24666@example 246673. + 2. x 246682.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x 24669@end example 24670 24671In the first case the estimated errors are zero because the linear 24672fit is perfect. In the second case, the errors are nonzero but 24673moderately small, because the data are still very close to linear. 24674 24675It is also possible for the @emph{input} to a fitting operation to 24676contain error forms. The data values must either all include errors 24677or all be plain numbers. Error forms can go anywhere but generally 24678go on the numbers in the last row of the data matrix. If the last 24679row contains error forms 24680@texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}', 24681@infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}', 24682then the 24683@texline @math{\chi^2} 24684@infoline @expr{chi^2} 24685statistic is now, 24686 24687@ifnottex 24688@example 24689chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N) 24690@end example 24691@end ifnottex 24692@tex 24693\beforedisplay 24694$$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$ 24695\afterdisplay 24696@end tex 24697 24698@noindent 24699so that data points with larger error estimates contribute less to 24700the fitting operation. 24701 24702If there are error forms on other rows of the data matrix, all the 24703errors for a given data point are combined; the square root of the 24704sum of the squares of the errors forms the 24705@texline @math{\sigma_i} 24706@infoline @expr{sigma_i} 24707used for the data point. 24708 24709Both @kbd{a F} and @kbd{H a F} can accept error forms in the input 24710matrix, although if you are concerned about error analysis you will 24711probably use @kbd{H a F} so that the output also contains error 24712estimates. 24713 24714If the input contains error forms but all the 24715@texline @math{\sigma_i} 24716@infoline @expr{sigma_i} 24717values are the same, it is easy to see that the resulting fitted model 24718will be the same as if the input did not have error forms at all 24719@texline (@math{\chi^2} 24720@infoline (@expr{chi^2} 24721is simply scaled uniformly by 24722@texline @math{1 / \sigma^2}, 24723@infoline @expr{1 / sigma^2}, 24724which doesn't affect where it has a minimum). But there @emph{will} be 24725a difference in the estimated errors of the coefficients reported by 24726@kbd{H a F}. 24727 24728Consult any text on statistical modeling of data for a discussion 24729of where these error estimates come from and how they should be 24730interpreted. 24731 24732@tex 24733\bigskip 24734@end tex 24735 24736@kindex I a F 24737@tindex xfit 24738With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more 24739information. The result is a vector of six items: 24740 24741@enumerate 24742@item 24743The model formula with error forms for its coefficients or 24744parameters. This is the result that @kbd{H a F} would have 24745produced. 24746 24747@item 24748A vector of ``raw'' parameter values for the model. These are the 24749polynomial coefficients or other parameters as plain numbers, in the 24750same order as the parameters appeared in the final prompt of the 24751@kbd{I a F} command. For polynomials of degree @expr{d}, this vector 24752will have length @expr{M = d+1} with the constant term first. 24753 24754@item 24755The covariance matrix @expr{C} computed from the fit. This is 24756an @var{m}x@var{m} symmetric matrix; the diagonal elements 24757@texline @math{C_{jj}} 24758@infoline @expr{C_j_j} 24759are the variances 24760@texline @math{\sigma_j^2} 24761@infoline @expr{sigma_j^2} 24762of the parameters. The other elements are covariances 24763@texline @math{\sigma_{ij}^2} 24764@infoline @expr{sigma_i_j^2} 24765that describe the correlation between pairs of parameters. (A related 24766set of numbers, the @dfn{linear correlation coefficients} 24767@texline @math{r_{ij}}, 24768@infoline @expr{r_i_j}, 24769are defined as 24770@texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.) 24771@infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.) 24772 24773@item 24774A vector of @expr{M} ``parameter filter'' functions whose 24775meanings are described below. If no filters are necessary this 24776will instead be an empty vector; this is always the case for the 24777polynomial and multilinear fits described so far. 24778 24779@item 24780The value of 24781@texline @math{\chi^2} 24782@infoline @expr{chi^2} 24783for the fit, calculated by the formulas shown above. This gives a 24784measure of the quality of the fit; statisticians consider 24785@texline @math{\chi^2 \approx N - M} 24786@infoline @expr{chi^2 = N - M} 24787to indicate a moderately good fit (where again @expr{N} is the number of 24788data points and @expr{M} is the number of parameters). 24789 24790@item 24791A measure of goodness of fit expressed as a probability @expr{Q}. 24792This is computed from the @code{utpc} probability distribution 24793function using 24794@texline @math{\chi^2} 24795@infoline @expr{chi^2} 24796with @expr{N - M} degrees of freedom. A 24797value of 0.5 implies a good fit; some texts recommend that often 24798@expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In 24799particular, 24800@texline @math{\chi^2} 24801@infoline @expr{chi^2} 24802statistics assume the errors in your inputs 24803follow a normal (Gaussian) distribution; if they don't, you may 24804have to accept smaller values of @expr{Q}. 24805 24806The @expr{Q} value is computed only if the input included error 24807estimates. Otherwise, Calc will report the symbol @code{nan} 24808for @expr{Q}. The reason is that in this case the 24809@texline @math{\chi^2} 24810@infoline @expr{chi^2} 24811value has effectively been used to estimate the original errors 24812in the input, and thus there is no redundant information left 24813over to use for a confidence test. 24814@end enumerate 24815 24816@node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting 24817@subsection Standard Nonlinear Models 24818 24819@noindent 24820The @kbd{a F} command also accepts other kinds of models besides 24821lines and polynomials. Some common models have quick single-key 24822abbreviations; others must be entered by hand as algebraic formulas. 24823 24824Here is a complete list of the standard models recognized by @kbd{a F}: 24825 24826@table @kbd 24827@item 1 24828Linear or multilinear. @mathit{a + b x + c y + d z}. 24829@item 2-9 24830Polynomials. @mathit{a + b x + c x^2 + d x^3}. 24831@item e 24832Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}. 24833@item E 24834Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}. 24835@item x 24836Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}. 24837@item X 24838Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}. 24839@item l 24840Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}. 24841@item L 24842Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}. 24843@item ^ 24844General exponential. @mathit{a b^x c^y}. 24845@item p 24846Power law. @mathit{a x^b y^c}. 24847@item q 24848Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}. 24849@item g 24850Gaussian. 24851@texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}. 24852@infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}. 24853@item s 24854Logistic @emph{s} curve. 24855@texline @math{a/(1+e^{b(x-c)})}. 24856@infoline @mathit{a/(1 + exp(b (x - c)))}. 24857@item b 24858Logistic bell curve. 24859@texline @math{ae^{b(x-c)}/(1+e^{b(x-c)})^2}. 24860@infoline @mathit{a exp(b (x - c))/(1 + exp(b (x - c)))^2}. 24861@item o 24862Hubbert linearization. 24863@texline @math{{y \over x} = a(1-x/b)}. 24864@infoline @mathit{(y/x) = a (1 - x/b)}. 24865@end table 24866 24867All of these models are used in the usual way; just press the appropriate 24868letter at the model prompt, and choose variable names if you wish. The 24869result will be a formula as shown in the above table, with the best-fit 24870values of the parameters substituted. (You may find it easier to read 24871the parameter values from the vector that is placed in the trail.) 24872 24873All models except Gaussian, logistics, Hubbert and polynomials can 24874generalize as shown to any number of independent variables. Also, all 24875the built-in models except for the logistic and Hubbert curves have an 24876additive or multiplicative parameter shown as @expr{a} in the above table 24877which can be replaced by zero or one, as appropriate, by typing @kbd{h} 24878before the model key. 24879 24880Note that many of these models are essentially equivalent, but express 24881the parameters slightly differently. For example, @expr{a b^x} and 24882the other two exponential models are all algebraic rearrangements of 24883each other. Also, the ``quadratic'' model is just a degree-2 polynomial 24884with the parameters expressed differently. Use whichever form best 24885matches the problem. 24886 24887The HP-28/48 calculators support four different models for curve 24888fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}. 24889These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)}, 24890@samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case, 24891@expr{a} is what the HP-48 identifies as the ``intercept,'' and 24892@expr{b} is what it calls the ``slope.'' 24893 24894@tex 24895\bigskip 24896@end tex 24897 24898If the model you want doesn't appear on this list, press @kbd{'} 24899(the apostrophe key) at the model prompt to enter any algebraic 24900formula, such as @kbd{m x - b}, as the model. (Not all models 24901will work, though---see the next section for details.) 24902 24903The model can also be an equation like @expr{y = m x + b}. 24904In this case, Calc thinks of all the rows of the data matrix on 24905equal terms; this model effectively has two parameters 24906(@expr{m} and @expr{b}) and two independent variables (@expr{x} 24907and @expr{y}), with no ``dependent'' variables. Model equations 24908do not need to take this @expr{y =} form. For example, the 24909implicit line equation @expr{a x + b y = 1} works fine as a 24910model. 24911 24912When you enter a model, Calc makes an alphabetical list of all 24913the variables that appear in the model. These are used for the 24914default parameters, independent variables, and dependent variable 24915(in that order). If you enter a plain formula (not an equation), 24916Calc assumes the dependent variable does not appear in the formula 24917and thus does not need a name. 24918 24919For example, if the model formula has the variables @expr{a,mu,sigma,t,x}, 24920and the data matrix has three rows (meaning two independent variables), 24921Calc will use @expr{a,mu,sigma} as the default parameters, and the 24922data rows will be named @expr{t} and @expr{x}, respectively. If you 24923enter an equation instead of a plain formula, Calc will use @expr{a,mu} 24924as the parameters, and @expr{sigma,t,x} as the three independent 24925variables. 24926 24927You can, of course, override these choices by entering something 24928different at the prompt. If you leave some variables out of the list, 24929those variables must have stored values and those stored values will 24930be used as constants in the model. (Stored values for the parameters 24931and independent variables are ignored by the @kbd{a F} command.) 24932If you list only independent variables, all the remaining variables 24933in the model formula will become parameters. 24934 24935If there are @kbd{$} signs in the model you type, they will stand 24936for parameters and all other variables (in alphabetical order) 24937will be independent. Use @kbd{$} for one parameter, @kbd{$$} for 24938another, and so on. Thus @kbd{$ x + $$} is another way to describe 24939a linear model. 24940 24941If you type a @kbd{$} instead of @kbd{'} at the model prompt itself, 24942Calc will take the model formula from the stack. (The data must then 24943appear at the second stack level.) The same conventions are used to 24944choose which variables in the formula are independent by default and 24945which are parameters. 24946 24947Models taken from the stack can also be expressed as vectors of 24948two or three elements, @expr{[@var{model}, @var{vars}]} or 24949@expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars} 24950and @var{params} may be either a variable or a vector of variables. 24951(If @var{params} is omitted, all variables in @var{model} except 24952those listed as @var{vars} are parameters.) 24953 24954When you enter a model manually with @kbd{'}, Calc puts a 3-vector 24955describing the model in the trail so you can get it back if you wish. 24956 24957@tex 24958\bigskip 24959@end tex 24960 24961@vindex Model1 24962@vindex Model2 24963Finally, you can store a model in one of the Calc variables 24964@code{Model1} or @code{Model2}, then use this model by typing 24965@kbd{a F u} or @kbd{a F U} (respectively). The value stored in 24966the variable can be any of the formats that @kbd{a F $} would 24967accept for a model on the stack. 24968 24969@tex 24970\bigskip 24971@end tex 24972 24973Calc uses the principal values of inverse functions like @code{ln} 24974and @code{arcsin} when doing fits. For example, when you enter 24975the model @samp{y = sin(a t + b)} Calc actually uses the easier 24976form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always 24977returns results in the range from @mathit{-90} to 90 degrees (or the 24978equivalent range in radians). Suppose you had data that you 24979believed to represent roughly three oscillations of a sine wave, 24980so that the argument of the sine might go from zero to 24981@texline @math{3\times360} 24982@infoline @mathit{3*360} 24983degrees. 24984The above model would appear to be a good way to determine the 24985true frequency and phase of the sine wave, but in practice it 24986would fail utterly. The righthand side of the actual model 24987@samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but 24988the lefthand side will bounce back and forth between @mathit{-90} and 90. 24989No values of @expr{a} and @expr{b} can make the two sides match, 24990even approximately. 24991 24992There is no good solution to this problem at present. You could 24993restrict your data to small enough ranges so that the above problem 24994doesn't occur (i.e., not straddling any peaks in the sine wave). 24995Or, in this case, you could use a totally different method such as 24996Fourier analysis, which is beyond the scope of the @kbd{a F} command. 24997(Unfortunately, Calc does not currently have any facilities for 24998taking Fourier and related transforms.) 24999 25000@node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting 25001@subsection Curve Fitting Details 25002 25003@noindent 25004Calc's internal least-squares fitter can only handle multilinear 25005models. More precisely, it can handle any model of the form 25006@expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c} 25007are the parameters and @expr{x,y,z} are the independent variables 25008(of course there can be any number of each, not just three). 25009 25010In a simple multilinear or polynomial fit, it is easy to see how 25011to convert the model into this form. For example, if the model 25012is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x}, 25013and @expr{h(x) = x^2} are suitable functions. 25014 25015For most other models, Calc uses a variety of algebraic manipulations 25016to try to put the problem into the form 25017 25018@smallexample 25019Y(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) 25020@end smallexample 25021 25022@noindent 25023where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes 25024@expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points, 25025does a standard linear fit to find the values of @expr{A}, @expr{B}, 25026and @expr{C}, then uses the equation solver to solve for @expr{a,b,c} 25027in terms of @expr{A,B,C}. 25028 25029A remarkable number of models can be cast into this general form. 25030We'll look at two examples here to see how it works. The power-law 25031model @expr{y = a x^b} with two independent variables and two parameters 25032can be rewritten as follows: 25033 25034@example 25035y = a x^b 25036y = a exp(b ln(x)) 25037y = exp(ln(a) + b ln(x)) 25038ln(y) = ln(a) + b ln(x) 25039@end example 25040 25041@noindent 25042which matches the desired form with 25043@texline @math{Y = \ln(y)}, 25044@infoline @expr{Y = ln(y)}, 25045@texline @math{A = \ln(a)}, 25046@infoline @expr{A = ln(a)}, 25047@expr{F = 1}, @expr{B = b}, and 25048@texline @math{G = \ln(x)}. 25049@infoline @expr{G = ln(x)}. 25050Calc thus computes the logarithms of your @expr{y} and @expr{x} values, 25051does a linear fit for @expr{A} and @expr{B}, then solves to get 25052@texline @math{a = \exp(A)} 25053@infoline @expr{a = exp(A)} 25054and @expr{b = B}. 25055 25056Another interesting example is the ``quadratic'' model, which can 25057be handled by expanding according to the distributive law. 25058 25059@example 25060y = a + b*(x - c)^2 25061y = a + b c^2 - 2 b c x + b x^2 25062@end example 25063 25064@noindent 25065which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1}, 25066@expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily 25067have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and 25068@expr{H = x^2}. 25069 25070The Gaussian model looks quite complicated, but a closer examination 25071shows that it's actually similar to the quadratic model but with an 25072exponential that can be brought to the top and moved into @expr{Y}. 25073 25074The logistic models cannot be put into general linear form. For these 25075models, and the Hubbert linearization, Calc computes a rough 25076approximation for the parameters, then uses the Levenberg-Marquardt 25077iterative method to refine the approximations. 25078 25079Another model that cannot be put into general linear 25080form is a Gaussian with a constant background added on, i.e., 25081@expr{d} + the regular Gaussian formula. If you have a model like 25082this, your best bet is to replace enough of your parameters with 25083constants to make the model linearizable, then adjust the constants 25084manually by doing a series of fits. You can compare the fits by 25085graphing them, by examining the goodness-of-fit measures returned by 25086@kbd{I a F}, or by some other method suitable to your application. 25087Note that some models can be linearized in several ways. The 25088Gaussian-plus-@var{d} model can be linearized by setting @expr{d} 25089(the background) to a constant, or by setting @expr{b} (the standard 25090deviation) and @expr{c} (the mean) to constants. 25091 25092To fit a model with constants substituted for some parameters, just 25093store suitable values in those parameter variables, then omit them 25094from the list of parameters when you answer the variables prompt. 25095 25096@tex 25097\bigskip 25098@end tex 25099 25100A last desperate step would be to use the general-purpose 25101@code{minimize} function rather than @code{fit}. After all, both 25102functions solve the problem of minimizing an expression (the 25103@texline @math{\chi^2} 25104@infoline @expr{chi^2} 25105sum) by adjusting certain parameters in the expression. The @kbd{a F} 25106command is able to use a vastly more efficient algorithm due to its 25107special knowledge about linear chi-square sums, but the @kbd{a N} 25108command can do the same thing by brute force. 25109 25110A compromise would be to pick out a few parameters without which the 25111fit is linearizable, and use @code{minimize} on a call to @code{fit} 25112which efficiently takes care of the rest of the parameters. The thing 25113to be minimized would be the value of 25114@texline @math{\chi^2} 25115@infoline @expr{chi^2} 25116returned as the fifth result of the @code{xfit} function: 25117 25118@smallexample 25119minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess) 25120@end smallexample 25121 25122@noindent 25123where @code{gaus} represents the Gaussian model with background, 25124@code{data} represents the data matrix, and @code{guess} represents 25125the initial guess for @expr{d} that @code{minimize} requires. 25126This operation will only be, shall we say, extraordinarily slow 25127rather than astronomically slow (as would be the case if @code{minimize} 25128were used by itself to solve the problem). 25129 25130@tex 25131\bigskip 25132@end tex 25133 25134The @kbd{I a F} [@code{xfit}] command is somewhat trickier when 25135nonlinear models are used. The second item in the result is the 25136vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The 25137covariance matrix is written in terms of those raw parameters. 25138The fifth item is a vector of @dfn{filter} expressions. This 25139is the empty vector @samp{[]} if the raw parameters were the same 25140as the requested parameters, i.e., if @expr{A = a}, @expr{B = b}, 25141and so on (which is always true if the model is already linear 25142in the parameters as written, e.g., for polynomial fits). If the 25143parameters had to be rearranged, the fifth item is instead a vector 25144of one formula per parameter in the original model. The raw 25145parameters are expressed in these ``filter'' formulas as 25146@samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B}, 25147and so on. 25148 25149When Calc needs to modify the model to return the result, it replaces 25150@samp{fitdummy(1)} in all the filters with the first item in the raw 25151parameters list, and so on for the other raw parameters, then 25152evaluates the resulting filter formulas to get the actual parameter 25153values to be substituted into the original model. In the case of 25154@kbd{H a F} and @kbd{I a F} where the parameters must be error forms, 25155Calc uses the square roots of the diagonal entries of the covariance 25156matrix as error values for the raw parameters, then lets Calc's 25157standard error-form arithmetic take it from there. 25158 25159If you use @kbd{I a F} with a nonlinear model, be sure to remember 25160that the covariance matrix is in terms of the raw parameters, 25161@emph{not} the actual requested parameters. It's up to you to 25162figure out how to interpret the covariances in the presence of 25163nontrivial filter functions. 25164 25165Things are also complicated when the input contains error forms. 25166Suppose there are three independent and dependent variables, @expr{x}, 25167@expr{y}, and @expr{z}, one or more of which are error forms in the 25168data. Calc combines all the error values by taking the square root 25169of the sum of the squares of the errors. It then changes @expr{x} 25170and @expr{y} to be plain numbers, and makes @expr{z} into an error 25171form with this combined error. The @expr{Y(x,y,z)} part of the 25172linearized model is evaluated, and the result should be an error 25173form. The error part of that result is used for 25174@texline @math{\sigma_i} 25175@infoline @expr{sigma_i} 25176for the data point. If for some reason @expr{Y(x,y,z)} does not return 25177an error form, the combined error from @expr{z} is used directly for 25178@texline @math{\sigma_i}. 25179@infoline @expr{sigma_i}. 25180Finally, @expr{z} is also stripped of its error 25181for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on; 25182the righthand side of the linearized model is computed in regular 25183arithmetic with no error forms. 25184 25185(While these rules may seem complicated, they are designed to do 25186the most reasonable thing in the typical case that @expr{Y(x,y,z)} 25187depends only on the dependent variable @expr{z}, and in fact is 25188often simply equal to @expr{z}. For common cases like polynomials 25189and multilinear models, the combined error is simply used as the 25190@texline @math{\sigma} 25191@infoline @expr{sigma} 25192for the data point with no further ado.) 25193 25194@tex 25195\bigskip 25196@end tex 25197 25198@vindex FitRules 25199It may be the case that the model you wish to use is linearizable, 25200but Calc's built-in rules are unable to figure it out. Calc uses 25201its algebraic rewrite mechanism to linearize a model. The rewrite 25202rules are kept in the variable @code{FitRules}. You can edit this 25203variable using the @kbd{s e FitRules} command; in fact, there is 25204a special @kbd{s F} command just for editing @code{FitRules}. 25205@xref{Operations on Variables}. 25206 25207@xref{Rewrite Rules}, for a discussion of rewrite rules. 25208 25209@ignore 25210@starindex 25211@end ignore 25212@tindex fitvar 25213@ignore 25214@starindex 25215@end ignore 25216@ignore 25217@mindex @idots 25218@end ignore 25219@tindex fitparam 25220@ignore 25221@starindex 25222@end ignore 25223@ignore 25224@mindex @null 25225@end ignore 25226@tindex fitmodel 25227@ignore 25228@starindex 25229@end ignore 25230@ignore 25231@mindex @null 25232@end ignore 25233@tindex fitsystem 25234@ignore 25235@starindex 25236@end ignore 25237@ignore 25238@mindex @null 25239@end ignore 25240@tindex fitdummy 25241Calc uses @code{FitRules} as follows. First, it converts the model 25242to an equation if necessary and encloses the model equation in a 25243call to the function @code{fitmodel} (which is not actually a defined 25244function in Calc; it is only used as a placeholder by the rewrite rules). 25245Parameter variables are renamed to function calls @samp{fitparam(1)}, 25246@samp{fitparam(2)}, and so on, and independent variables are renamed 25247to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable 25248is the highest-numbered @code{fitvar}. For example, the power law 25249model @expr{a x^b} is converted to @expr{y = a x^b}, then to 25250 25251@smallexample 25252@group 25253fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2)) 25254@end group 25255@end smallexample 25256 25257Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}. 25258(The zero prefix means that rewriting should continue until no further 25259changes are possible.) 25260 25261When rewriting is complete, the @code{fitmodel} call should have 25262been replaced by a @code{fitsystem} call that looks like this: 25263 25264@example 25265fitsystem(@var{Y}, @var{FGH}, @var{abc}) 25266@end example 25267 25268@noindent 25269where @var{Y} is a formula that describes the function @expr{Y(x,y,z)}, 25270@var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]}, 25271and @var{abc} is the vector of parameter filters which refer to the 25272raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} 25273for @expr{B}, etc. While the number of raw parameters (the length of 25274the @var{FGH} vector) is usually the same as the number of original 25275parameters (the length of the @var{abc} vector), this is not required. 25276 25277The power law model eventually boils down to 25278 25279@smallexample 25280@group 25281fitsystem(ln(fitvar(2)), 25282 [1, ln(fitvar(1))], 25283 [exp(fitdummy(1)), fitdummy(2)]) 25284@end group 25285@end smallexample 25286 25287The actual implementation of @code{FitRules} is complicated; it 25288proceeds in four phases. First, common rearrangements are done 25289to try to bring linear terms together and to isolate functions like 25290@code{exp} and @code{ln} either all the way ``out'' (so that they 25291can be put into @var{Y}) or all the way ``in'' (so that they can 25292be put into @var{abc} or @var{FGH}). In particular, all 25293non-constant powers are converted to logs-and-exponentials form, 25294and the distributive law is used to expand products of sums. 25295Quotients are rewritten to use the @samp{fitinv} function, where 25296@samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules} 25297are operating. (The use of @code{fitinv} makes recognition of 25298linear-looking forms easier.) If you modify @code{FitRules}, you 25299will probably only need to modify the rules for this phase. 25300 25301Phase two, whose rules can actually also apply during phases one 25302and three, first rewrites @code{fitmodel} to a two-argument 25303form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is 25304initially zero and @var{model} has been changed from @expr{a=b} 25305to @expr{a-b} form. It then tries to peel off invertible functions 25306from the outside of @var{model} and put them into @var{Y} instead, 25307calling the equation solver to invert the functions. Finally, when 25308this is no longer possible, the @code{fitmodel} is changed to a 25309four-argument @code{fitsystem}, where the fourth argument is 25310@var{model} and the @var{FGH} and @var{abc} vectors are initially 25311empty. (The last vector is really @var{ABC}, corresponding to 25312raw parameters, for now.) 25313 25314Phase three converts a sum of items in the @var{model} to a sum 25315of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent 25316terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a} 25317is all factors that do not involve any variables, @var{b} is all 25318factors that involve only parameters, and @var{c} is the factors 25319that involve only independent variables. (If this decomposition 25320is not possible, the rule set will not complete and Calc will 25321complain that the model is too complex.) Then @code{fitpart}s 25322with equal @var{b} or @var{c} components are merged back together 25323using the distributive law in order to minimize the number of 25324raw parameters needed. 25325 25326Phase four moves the @code{fitpart} terms into the @var{FGH} and 25327@var{ABC} vectors. Also, some of the algebraic expansions that 25328were done in phase 1 are undone now to make the formulas more 25329computationally efficient. Finally, it calls the solver one more 25330time to convert the @var{ABC} vector to an @var{abc} vector, and 25331removes the fourth @var{model} argument (which by now will be zero) 25332to obtain the three-argument @code{fitsystem} that the linear 25333least-squares solver wants to see. 25334 25335@ignore 25336@starindex 25337@end ignore 25338@ignore 25339@mindex hasfit@idots 25340@end ignore 25341@tindex hasfitparams 25342@ignore 25343@starindex 25344@end ignore 25345@ignore 25346@mindex @null 25347@end ignore 25348@tindex hasfitvars 25349Two functions which are useful in connection with @code{FitRules} 25350are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check 25351whether @expr{x} refers to any parameters or independent variables, 25352respectively. Specifically, these functions return ``true'' if the 25353argument contains any @code{fitparam} (or @code{fitvar}) function 25354calls, and ``false'' otherwise. (Recall that ``true'' means a 25355nonzero number, and ``false'' means zero. The actual nonzero number 25356returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s 25357or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.) 25358 25359@tex 25360\bigskip 25361@end tex 25362 25363The @code{fit} function in algebraic notation normally takes four 25364arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})}, 25365where @var{model} is the model formula as it would be typed after 25366@kbd{a F '}, @var{vars} is the independent variable or a vector of 25367independent variables, @var{params} likewise gives the parameter(s), 25368and @var{data} is the data matrix. Note that the length of @var{vars} 25369must be equal to the number of rows in @var{data} if @var{model} is 25370an equation, or one less than the number of rows if @var{model} is 25371a plain formula. (Actually, a name for the dependent variable is 25372allowed but will be ignored in the plain-formula case.) 25373 25374If @var{params} is omitted, the parameters are all variables in 25375@var{model} except those that appear in @var{vars}. If @var{vars} 25376is also omitted, Calc sorts all the variables that appear in 25377@var{model} alphabetically and uses the higher ones for @var{vars} 25378and the lower ones for @var{params}. 25379 25380Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed 25381where @var{modelvec} is a 2- or 3-vector describing the model 25382and variables, as discussed previously. 25383 25384If Calc is unable to do the fit, the @code{fit} function is left 25385in symbolic form, ordinarily with an explanatory message. The 25386message will be ``Model expression is too complex'' if the 25387linearizer was unable to put the model into the required form. 25388 25389The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit} 25390(for @kbd{I a F}) functions are completely analogous. 25391 25392@node Interpolation, , Curve Fitting Details, Curve Fitting 25393@subsection Polynomial Interpolation 25394 25395@kindex a p 25396@pindex calc-poly-interp 25397@tindex polint 25398The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does 25399a polynomial interpolation at a particular @expr{x} value. It takes 25400two arguments from the stack: A data matrix of the sort used by 25401@kbd{a F}, and a single number which represents the desired @expr{x} 25402value. Calc effectively does an exact polynomial fit as if by @kbd{a F i}, 25403then substitutes the @expr{x} value into the result in order to get an 25404approximate @expr{y} value based on the fit. (Calc does not actually 25405use @kbd{a F i}, however; it uses a direct method which is both more 25406efficient and more numerically stable.) 25407 25408The result of @kbd{a p} is actually a vector of two values: The @expr{y} 25409value approximation, and an error measure @expr{dy} that reflects Calc's 25410estimation of the probable error of the approximation at that value of 25411@expr{x}. If the input @expr{x} is equal to any of the @expr{x} values 25412in the data matrix, the output @expr{y} will be the corresponding @expr{y} 25413value from the matrix, and the output @expr{dy} will be exactly zero. 25414 25415A prefix argument of 2 causes @kbd{a p} to take separate x- and 25416y-vectors from the stack instead of one data matrix. 25417 25418If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of 25419interpolated results for each of those @expr{x} values. (The matrix will 25420have two columns, the @expr{y} values and the @expr{dy} values.) 25421If @expr{x} is a formula instead of a number, the @code{polint} function 25422remains in symbolic form; use the @kbd{a "} command to expand it out to 25423a formula that describes the fit in symbolic terms. 25424 25425In all cases, the @kbd{a p} command leaves the data vectors or matrix 25426on the stack. Only the @expr{x} value is replaced by the result. 25427 25428@kindex H a p 25429@tindex ratint 25430The @kbd{H a p} [@code{ratint}] command does a rational function 25431interpolation. It is used exactly like @kbd{a p}, except that it 25432uses as its model the quotient of two polynomials. If there are 25433@expr{N} data points, the numerator and denominator polynomials will 25434each have degree @expr{N/2} (if @expr{N} is odd, the denominator will 25435have degree one higher than the numerator). 25436 25437Rational approximations have the advantage that they can accurately 25438describe functions that have poles (points at which the function's value 25439goes to infinity, so that the denominator polynomial of the approximation 25440goes to zero). If @expr{x} corresponds to a pole of the fitted rational 25441function, then the result will be a division by zero. If Infinite mode 25442is enabled, the result will be @samp{[uinf, uinf]}. 25443 25444There is no way to get the actual coefficients of the rational function 25445used by @kbd{H a p}. (The algorithm never generates these coefficients 25446explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s 25447capabilities to fit.) 25448 25449@node Summations, Logical Operations, Curve Fitting, Algebra 25450@section Summations 25451 25452@noindent 25453@cindex Summation of a series 25454@kindex a + 25455@pindex calc-summation 25456@tindex sum 25457The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes 25458the sum of a formula over a certain range of index values. The formula 25459is taken from the top of the stack; the command prompts for the 25460name of the summation index variable, the lower limit of the 25461sum (any formula), and the upper limit of the sum. If you 25462enter a blank line at any of these prompts, that prompt and 25463any later ones are answered by reading additional elements from 25464the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}} 25465produces the result 55. 25466@tex 25467$$ \sum_{k=1}^5 k^2 = 55 $$ 25468@end tex 25469 25470The choice of index variable is arbitrary, but it's best not to 25471use a variable with a stored value. In particular, while 25472@code{i} is often a favorite index variable, it should be avoided 25473in Calc because @code{i} has the imaginary constant @expr{(0, 1)} 25474as a value. If you pressed @kbd{=} on a sum over @code{i}, it would 25475be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}! 25476If you really want to use @code{i} as an index variable, use 25477@w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable. 25478(@xref{Storing Variables}.) 25479 25480A numeric prefix argument steps the index by that amount rather 25481than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}} 25482yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix 25483argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the 25484step value, in which case you can enter any formula or enter 25485a blank line to take the step value from the stack. With the 25486@kbd{C-u} prefix, @kbd{a +} can take up to five arguments from 25487the stack: The formula, the variable, the lower limit, the 25488upper limit, and (at the top of the stack), the step value. 25489 25490Calc knows how to do certain sums in closed form. For example, 25491@samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular, 25492this is possible if the formula being summed is polynomial or 25493exponential in the index variable. Sums of logarithms are 25494transformed into logarithms of products. Sums of trigonometric 25495and hyperbolic functions are transformed to sums of exponentials 25496and then done in closed form. Also, of course, sums in which the 25497lower and upper limits are both numbers can always be evaluated 25498just by grinding them out, although Calc will use closed forms 25499whenever it can for the sake of efficiency. 25500 25501The notation for sums in algebraic formulas is 25502@samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}. 25503If @var{step} is omitted, it defaults to one. If @var{high} is 25504omitted, @var{low} is actually the upper limit and the lower limit 25505is one. If @var{low} is also omitted, the limits are @samp{-inf} 25506and @samp{inf}, respectively. 25507 25508Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)} 25509returns @expr{1}. This is done by evaluating the sum in closed 25510form (to @samp{1. - 0.5^n} in this case), then evaluating this 25511formula with @code{n} set to @code{inf}. Calc's usual rules 25512for ``infinite'' arithmetic can find the answer from there. If 25513infinite arithmetic yields a @samp{nan}, or if the sum cannot be 25514solved in closed form, Calc leaves the @code{sum} function in 25515symbolic form. @xref{Infinities}. 25516 25517As a special feature, if the limits are infinite (or omitted, as 25518described above) but the formula includes vectors subscripted by 25519expressions that involve the iteration variable, Calc narrows 25520the limits to include only the range of integers which result in 25521valid subscripts for the vector. For example, the sum 25522@samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}. 25523 25524The limits of a sum do not need to be integers. For example, 25525@samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}. 25526Calc computes the number of iterations using the formula 25527@samp{1 + (@var{high} - @var{low}) / @var{step}}, which must, 25528after algebraic simplification, evaluate to an integer. 25529 25530If the number of iterations according to the above formula does 25531not come out to an integer, the sum is invalid and will be left 25532in symbolic form. However, closed forms are still supplied, and 25533you are on your honor not to misuse the resulting formulas by 25534substituting mismatched bounds into them. For example, 25535@samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and 25536evaluate the closed form solution for the limits 1 and 10 to get 25537the rather dubious answer, 29.25. 25538 25539If the lower limit is greater than the upper limit (assuming a 25540positive step size), the result is generally zero. However, 25541Calc only guarantees a zero result when the upper limit is 25542exactly one step less than the lower limit, i.e., if the number 25543of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero 25544but the sum from @samp{n} to @samp{n-2} may report a nonzero value 25545if Calc used a closed form solution. 25546 25547Calc's logical predicates like @expr{a < b} return 1 for ``true'' 25548and 0 for ``false.'' @xref{Logical Operations}. This can be 25549used to advantage for building conditional sums. For example, 25550@samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all 25551prime numbers from 1 to 20; the @code{prime} predicate returns 1 if 25552its argument is prime and 0 otherwise. You can read this expression 25553as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed, 25554@samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes 25555squared, since the limits default to plus and minus infinity, but 25556there are no such sums that Calc's built-in rules can do in 25557closed form. 25558 25559As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the 25560sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding 25561one value @expr{k_0}. Slightly more tricky is the summand 25562@samp{(k != k_0) / (k - k_0)}, which is an attempt to describe 25563the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where 25564this would be a division by zero. But at @expr{k = k_0}, this 25565formula works out to the indeterminate form @expr{0 / 0}, which 25566Calc will not assume is zero. Better would be to use 25567@samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does 25568an ``if-then-else'' test: This expression says, ``if 25569@texline @math{k \ne k_0}, 25570@infoline @expr{k != k_0}, 25571then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)} 25572will not even be evaluated by Calc when @expr{k = k_0}. 25573 25574@cindex Alternating sums 25575@kindex a - 25576@pindex calc-alt-summation 25577@tindex asum 25578The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command 25579computes an alternating sum. Successive terms of the sequence 25580are given alternating signs, with the first term (corresponding 25581to the lower index value) being positive. Alternating sums 25582are converted to normal sums with an extra term of the form 25583@samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately 25584if the step value is other than one. For example, the Taylor 25585series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}. 25586(Calc cannot evaluate this infinite series, but it can approximate 25587it if you replace @code{inf} with any particular odd number.) 25588Calc converts this series to a regular sum with a step of one, 25589namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}. 25590 25591@cindex Product of a sequence 25592@kindex a * 25593@pindex calc-product 25594@tindex prod 25595The @kbd{a *} (@code{calc-product}) [@code{prod}] command is 25596the analogous way to take a product of many terms. Calc also knows 25597some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}. 25598Conditional products can be written @samp{prod(k^prime(k), k, 1, n)} 25599or @samp{prod(prime(k) ? k : 1, k, 1, n)}. 25600 25601@kindex a T 25602@pindex calc-tabulate 25603@tindex table 25604The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command 25605evaluates a formula at a series of iterated index values, just 25606like @code{sum} and @code{prod}, but its result is simply a 25607vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)} 25608produces @samp{[a_1, a_3, a_5, a_7]}. 25609 25610@node Logical Operations, Rewrite Rules, Summations, Algebra 25611@section Logical Operations 25612 25613@noindent 25614The following commands and algebraic functions return true/false values, 25615where 1 represents ``true'' and 0 represents ``false.'' In cases where 25616a truth value is required (such as for the condition part of a rewrite 25617rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any 25618nonzero value is accepted to mean ``true.'' (Specifically, anything 25619for which @code{dnonzero} returns 1 is ``true,'' and anything for 25620which @code{dnonzero} returns 0 or cannot decide is assumed ``false.'' 25621Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then'' 25622portion if its condition is provably true, but it will execute the 25623``else'' portion for any condition like @expr{a = b} that is not 25624provably true, even if it might be true. Algebraic functions that 25625have conditions as arguments, like @code{? :} and @code{&&}, remain 25626unevaluated if the condition is neither provably true nor provably 25627false. @xref{Declarations}.) 25628 25629@kindex a = 25630@pindex calc-equal-to 25631@tindex eq 25632@tindex = 25633@tindex == 25634The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function 25635(which can also be written @samp{a = b} or @samp{a == b} in an algebraic 25636formula) is true if @expr{a} and @expr{b} are equal, either because they 25637are identical expressions, or because they are numbers which are 25638numerically equal. (Thus the integer 1 is considered equal to the float 256391.0.) If the equality of @expr{a} and @expr{b} cannot be determined, 25640the comparison is left in symbolic form. Note that as a command, this 25641operation pops two values from the stack and pushes back either a 1 or 25642a 0, or a formula @samp{a = b} if the values' equality cannot be determined. 25643 25644Many Calc commands use @samp{=} formulas to represent @dfn{equations}. 25645For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges 25646an equation to solve for a given variable. The @kbd{a M} 25647(@code{calc-map-equation}) command can be used to apply any 25648function to both sides of an equation; for example, @kbd{2 a M *} 25649multiplies both sides of the equation by two. Note that just 25650@kbd{2 *} would not do the same thing; it would produce the formula 25651@samp{2 (a = b)} which represents 2 if the equality is true or 25652zero if not. 25653 25654The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =} 25655or @samp{a = b = c}) tests if all of its arguments are equal. In 25656algebraic notation, the @samp{=} operator is unusual in that it is 25657neither left- nor right-associative: @samp{a = b = c} is not the 25658same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare 25659one variable with the 1 or 0 that results from comparing two other 25660variables). 25661 25662@kindex a # 25663@pindex calc-not-equal-to 25664@tindex neq 25665@tindex != 25666The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or 25667@samp{a != b} function, is true if @expr{a} and @expr{b} are not equal. 25668This also works with more than two arguments; @samp{a != b != c != d} 25669tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are 25670distinct numbers. 25671 25672@kindex a < 25673@tindex lt 25674@ignore 25675@mindex @idots 25676@end ignore 25677@kindex a > 25678@ignore 25679@mindex @null 25680@end ignore 25681@kindex a [ 25682@ignore 25683@mindex @null 25684@end ignore 25685@kindex a ] 25686@pindex calc-less-than 25687@pindex calc-greater-than 25688@pindex calc-less-equal 25689@pindex calc-greater-equal 25690@ignore 25691@mindex @null 25692@end ignore 25693@tindex gt 25694@ignore 25695@mindex @null 25696@end ignore 25697@tindex leq 25698@ignore 25699@mindex @null 25700@end ignore 25701@tindex geq 25702@ignore 25703@mindex @null 25704@end ignore 25705@tindex < 25706@ignore 25707@mindex @null 25708@end ignore 25709@tindex > 25710@ignore 25711@mindex @null 25712@end ignore 25713@tindex <= 25714@ignore 25715@mindex @null 25716@end ignore 25717@tindex >= 25718The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}] 25719operation is true if @expr{a} is less than @expr{b}. Similar functions 25720are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}], 25721@kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and 25722@kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}]. 25723 25724While the inequality functions like @code{lt} do not accept more 25725than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an 25726equivalent expression involving intervals: @samp{b in [a .. c)}. 25727(See the description of @code{in} below.) All four combinations 25728of @samp{<} and @samp{<=} are allowed, or any of the four combinations 25729of @samp{>} and @samp{>=}. Four-argument constructions like 25730@samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that 25731involve both equations and inequalities, are not allowed. 25732 25733@kindex a . 25734@pindex calc-remove-equal 25735@tindex rmeq 25736The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts 25737the righthand side of the equation or inequality on the top of the 25738stack. It also works elementwise on vectors. For example, if 25739@samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces 25740@samp{[2.34, z / 2]}. As a special case, if the righthand side is a 25741variable and the lefthand side is a number (as in @samp{2.34 = x}), then 25742Calc keeps the lefthand side instead. Finally, this command works with 25743assignments @samp{x := 2.34} as well as equations, always taking the 25744righthand side, and for @samp{=>} (evaluates-to) operators, always 25745taking the lefthand side. 25746 25747@kindex a & 25748@pindex calc-logical-and 25749@tindex land 25750@tindex && 25751The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}] 25752function is true if both of its arguments are true, i.e., are 25753non-zero numbers. In this case, the result will be either @expr{a} or 25754@expr{b}, chosen arbitrarily. If either argument is zero, the result is 25755zero. Otherwise, the formula is left in symbolic form. 25756 25757@kindex a | 25758@pindex calc-logical-or 25759@tindex lor 25760@tindex || 25761The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}] 25762function is true if either or both of its arguments are true (nonzero). 25763The result is whichever argument was nonzero, choosing arbitrarily if both 25764are nonzero. If both @expr{a} and @expr{b} are zero, the result is 25765zero. 25766 25767@kindex a ! 25768@pindex calc-logical-not 25769@tindex lnot 25770@tindex ! 25771The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}] 25772function is true if @expr{a} is false (zero), or false if @expr{a} is 25773true (nonzero). It is left in symbolic form if @expr{a} is not a 25774number. 25775 25776@kindex a : 25777@pindex calc-logical-if 25778@tindex if 25779@ignore 25780@mindex ? : 25781@end ignore 25782@tindex ? 25783@ignore 25784@mindex @null 25785@end ignore 25786@tindex : 25787@cindex Arguments, not evaluated 25788The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}] 25789function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero 25790number or zero, respectively. If @expr{a} is not a number, the test is 25791left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in 25792any way. In algebraic formulas, this is one of the few Calc functions 25793whose arguments are not automatically evaluated when the function itself 25794is evaluated. The others are @code{lambda}, @code{quote}, and 25795@code{condition}. 25796 25797One minor surprise to watch out for is that the formula @samp{a?3:4} 25798will not work because the @samp{3:4} is parsed as a fraction instead of 25799as three separate symbols. Type something like @samp{a ? 3 : 4} or 25800@samp{a?(3):4} instead. 25801 25802As a special case, if @expr{a} evaluates to a vector, then both @expr{b} 25803and @expr{c} are evaluated; the result is a vector of the same length 25804as @expr{a} whose elements are chosen from corresponding elements of 25805@expr{b} and @expr{c} according to whether each element of @expr{a} 25806is zero or nonzero. Each of @expr{b} and @expr{c} must be either a 25807vector of the same length as @expr{a}, or a non-vector which is matched 25808with all elements of @expr{a}. 25809 25810@kindex a @{ 25811@pindex calc-in-set 25812@tindex in 25813The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if 25814the number @expr{a} is in the set of numbers represented by @expr{b}. 25815If @expr{b} is an interval form, @expr{a} must be one of the values 25816encompassed by the interval. If @expr{b} is a vector, @expr{a} must be 25817equal to one of the elements of the vector. (If any vector elements are 25818intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a 25819plain number, @expr{a} must be numerically equal to @expr{b}. 25820@xref{Set Operations}, for a group of commands that manipulate sets 25821of this sort. 25822 25823@ignore 25824@starindex 25825@end ignore 25826@tindex typeof 25827The @samp{typeof(a)} function produces an integer or variable which 25828characterizes @expr{a}. If @expr{a} is a number, vector, or variable, 25829the result will be one of the following numbers: 25830 25831@example 25832 1 Integer 25833 2 Fraction 25834 3 Floating-point number 25835 4 HMS form 25836 5 Rectangular complex number 25837 6 Polar complex number 25838 7 Error form 25839 8 Interval form 25840 9 Modulo form 2584110 Date-only form 2584211 Date/time form 2584312 Infinity (inf, uinf, or nan) 25844100 Variable 25845101 Vector (but not a matrix) 25846102 Matrix 25847@end example 25848 25849Otherwise, @expr{a} is a formula, and the result is a variable which 25850represents the name of the top-level function call. 25851 25852@ignore 25853@starindex 25854@end ignore 25855@tindex integer 25856@ignore 25857@starindex 25858@end ignore 25859@tindex real 25860@ignore 25861@starindex 25862@end ignore 25863@tindex constant 25864The @samp{integer(a)} function returns true if @expr{a} is an integer. 25865The @samp{real(a)} function 25866is true if @expr{a} is a real number, either integer, fraction, or 25867float. The @samp{constant(a)} function returns true if @expr{a} is 25868any of the objects for which @code{typeof} would produce an integer 25869code result except for variables, and provided that the components of 25870an object like a vector or error form are themselves constant. 25871Note that infinities do not satisfy any of these tests, nor do 25872special constants like @code{pi} and @code{e}. 25873 25874@xref{Declarations}, for a set of similar functions that recognize 25875formulas as well as actual numbers. For example, @samp{dint(floor(x))} 25876is true because @samp{floor(x)} is provably integer-valued, but 25877@samp{integer(floor(x))} does not because @samp{floor(x)} is not 25878literally an integer constant. 25879 25880@ignore 25881@starindex 25882@end ignore 25883@tindex refers 25884The @samp{refers(a,b)} function is true if the variable (or sub-expression) 25885@expr{b} appears in @expr{a}, or false otherwise. Unlike the other 25886tests described here, this function returns a definite ``no'' answer 25887even if its arguments are still in symbolic form. The only case where 25888@code{refers} will be left unevaluated is if @expr{a} is a plain 25889variable (different from @expr{b}). 25890 25891@ignore 25892@starindex 25893@end ignore 25894@tindex negative 25895The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative, 25896because it is a negative number, because it is of the form @expr{-x}, 25897or because it is a product or quotient with a term that looks negative. 25898This is most useful in rewrite rules. Beware that @samp{negative(a)} 25899evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only 25900be stored in a formula if the default simplifications are turned off 25901first with @kbd{m O} (or if it appears in an unevaluated context such 25902as a rewrite rule condition). 25903 25904@ignore 25905@starindex 25906@end ignore 25907@tindex variable 25908The @samp{variable(a)} function is true if @expr{a} is a variable, 25909or false if not. If @expr{a} is a function call, this test is left 25910in symbolic form. Built-in variables like @code{pi} and @code{inf} 25911are considered variables like any others by this test. 25912 25913@ignore 25914@starindex 25915@end ignore 25916@tindex nonvar 25917The @samp{nonvar(a)} function is true if @expr{a} is a non-variable. 25918If its argument is a variable it is left unsimplified; it never 25919actually returns zero. However, since Calc's condition-testing 25920commands consider ``false'' anything not provably true, this is 25921often good enough. 25922 25923@ignore 25924@starindex 25925@end ignore 25926@tindex lin 25927@ignore 25928@starindex 25929@end ignore 25930@tindex linnt 25931@ignore 25932@starindex 25933@end ignore 25934@tindex islin 25935@ignore 25936@starindex 25937@end ignore 25938@tindex islinnt 25939@cindex Linearity testing 25940The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt} 25941check if an expression is ``linear,'' i.e., can be written in the form 25942@expr{a + b x} for some constants @expr{a} and @expr{b}, and some 25943variable or subformula @expr{x}. The function @samp{islin(f,x)} checks 25944if formula @expr{f} is linear in @expr{x}, returning 1 if so. For 25945example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and 25946@samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function 25947is similar, except that instead of returning 1 it returns the vector 25948@expr{[a, b, x]}. For the above examples, this vector would be 25949@expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and 25950@expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin} 25951generally remain unevaluated for expressions which are not linear, 25952e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second 25953argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))} 25954returns true. 25955 25956The @code{linnt} and @code{islinnt} functions perform a similar check, 25957but require a ``non-trivial'' linear form, which means that the 25958@expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)} 25959returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]}, 25960but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated 25961(in other words, these formulas are considered to be only ``trivially'' 25962linear in @expr{x}). 25963 25964All four linearity-testing functions allow you to omit the second 25965argument, in which case the input may be linear in any non-constant 25966formula. Here, the @expr{a=0}, @expr{b=1} case is also considered 25967trivial, and only constant values for @expr{a} and @expr{b} are 25968recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]}, 25969@samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)} 25970returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the 25971first two cases but not the third. Also, neither @code{lin} nor 25972@code{linnt} accept plain constants as linear in the one-argument 25973case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false. 25974 25975@ignore 25976@starindex 25977@end ignore 25978@tindex istrue 25979The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero 25980number or provably nonzero formula, or 0 if @expr{a} is anything else. 25981Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is 25982used to make sure they are not evaluated prematurely. (Note that 25983declarations are used when deciding whether a formula is true; 25984@code{istrue} returns 1 when @code{dnonzero} would return 1, and 25985it returns 0 when @code{dnonzero} would return 0 or leave itself 25986in symbolic form.) 25987 25988@node Rewrite Rules, , Logical Operations, Algebra 25989@section Rewrite Rules 25990 25991@noindent 25992@cindex Rewrite rules 25993@cindex Transformations 25994@cindex Pattern matching 25995@kindex a r 25996@pindex calc-rewrite 25997@tindex rewrite 25998The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes 25999substitutions in a formula according to a specified pattern or patterns 26000known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute}) 26001matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)} 26002matches only the @code{sin} function applied to the variable @code{x}, 26003rewrite rules match general kinds of formulas; rewriting using the rule 26004@samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces 26005it with @code{cos} of that same argument. The only significance of the 26006name @code{x} is that the same name is used on both sides of the rule. 26007 26008Rewrite rules rearrange formulas already in Calc's memory. 26009@xref{Syntax Tables}, to read about @dfn{syntax rules}, which are 26010similar to algebraic rewrite rules but operate when new algebraic 26011entries are being parsed, converting strings of characters into 26012Calc formulas. 26013 26014@menu 26015* Entering Rewrite Rules:: 26016* Basic Rewrite Rules:: 26017* Conditional Rewrite Rules:: 26018* Algebraic Properties of Rewrite Rules:: 26019* Other Features of Rewrite Rules:: 26020* Composing Patterns in Rewrite Rules:: 26021* Nested Formulas with Rewrite Rules:: 26022* Multi-Phase Rewrite Rules:: 26023* Selections with Rewrite Rules:: 26024* Matching Commands:: 26025* Automatic Rewrites:: 26026* Debugging Rewrites:: 26027* Examples of Rewrite Rules:: 26028@end menu 26029 26030@node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules 26031@subsection Entering Rewrite Rules 26032 26033@noindent 26034Rewrite rules normally use the ``assignment'' operator 26035@samp{@var{old} := @var{new}}. 26036This operator is equivalent to the function call @samp{assign(old, new)}. 26037The @code{assign} function is undefined by itself in Calc, so an 26038assignment formula such as a rewrite rule will be left alone by ordinary 26039Calc commands. But certain commands, like the rewrite system, interpret 26040assignments in special ways. 26041 26042For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace 26043every occurrence of the sine of something, squared, with one minus the 26044square of the cosine of that same thing. All by itself as a formula 26045on the stack it does nothing, but when given to the @kbd{a r} command 26046it turns that command into a sine-squared-to-cosine-squared converter. 26047 26048To specify a set of rules to be applied all at once, make a vector of 26049rules. 26050 26051When @kbd{a r} prompts you to enter the rewrite rules, you can answer 26052in several ways: 26053 26054@enumerate 26055@item 26056With a rule: @kbd{f(x) := g(x) @key{RET}}. 26057@item 26058With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}. 26059(You can omit the enclosing square brackets if you wish.) 26060@item 26061With the name of a variable that contains the rule or rules vector: 26062@kbd{myrules @key{RET}}. 26063@item 26064With any formula except a rule, a vector, or a variable name; this 26065will be interpreted as the @var{old} half of a rewrite rule, 26066and you will be prompted a second time for the @var{new} half: 26067@kbd{f(x) @key{RET} g(x) @key{RET}}. 26068@item 26069With a blank line, in which case the rule, rules vector, or variable 26070will be taken from the top of the stack (and the formula to be 26071rewritten will come from the second-to-top position). 26072@end enumerate 26073 26074If you enter the rules directly (as opposed to using rules stored 26075in a variable), those rules will be put into the Trail so that you 26076can retrieve them later. @xref{Trail Commands}. 26077 26078It is most convenient to store rules you use often in a variable and 26079invoke them by giving the variable name. The @kbd{s e} 26080(@code{calc-edit-variable}) command is an easy way to create or edit a 26081rule set stored in a variable. You may also wish to use @kbd{s p} 26082(@code{calc-permanent-variable}) to save your rules permanently; 26083@pxref{Operations on Variables}. 26084 26085Rewrite rules are compiled into a special internal form for faster 26086matching. If you enter a rule set directly it must be recompiled 26087every time. If you store the rules in a variable and refer to them 26088through that variable, they will be compiled once and saved away 26089along with the variable for later reference. This is another good 26090reason to store your rules in a variable. 26091 26092Calc also accepts an obsolete notation for rules, as vectors 26093@samp{[@var{old}, @var{new}]}. But because it is easily confused with a 26094vector of two rules, the use of this notation is no longer recommended. 26095 26096@node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules 26097@subsection Basic Rewrite Rules 26098 26099@noindent 26100To match a particular formula @expr{x} with a particular rewrite rule 26101@samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with 26102the structure of @var{old}. Variables that appear in @var{old} are 26103treated as @dfn{meta-variables}; the corresponding positions in @expr{x} 26104may contain any sub-formulas. For example, the pattern @samp{f(x,y)} 26105would match the expression @samp{f(12, a+1)} with the meta-variable 26106@samp{x} corresponding to 12 and with @samp{y} corresponding to 26107@samp{a+1}. However, this pattern would not match @samp{f(12)} or 26108@samp{g(12, a+1)}, since there is no assignment of the meta-variables 26109that will make the pattern match these expressions. Notice that if 26110the pattern is a single meta-variable, it will match any expression. 26111 26112If a given meta-variable appears more than once in @var{old}, the 26113corresponding sub-formulas of @expr{x} must be identical. Thus 26114the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and 26115@samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}. 26116(@xref{Conditional Rewrite Rules}, for a way to match the latter.) 26117 26118Things other than variables must match exactly between the pattern 26119and the target formula. To match a particular variable exactly, use 26120the pseudo-function @samp{quote(v)} in the pattern. For example, the 26121pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or 26122@samp{sin(a)+y}. 26123 26124The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, 26125@samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match 26126literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like 26127@samp{sin(d + quote(e) + f)}. 26128 26129If the @var{old} pattern is found to match a given formula, that 26130formula is replaced by @var{new}, where any occurrences in @var{new} 26131of meta-variables from the pattern are replaced with the sub-formulas 26132that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)} 26133to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}. 26134 26135The normal @kbd{a r} command applies rewrite rules over and over 26136throughout the target formula until no further changes are possible 26137(up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one 26138change at a time. 26139 26140@node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules 26141@subsection Conditional Rewrite Rules 26142 26143@noindent 26144A rewrite rule can also be @dfn{conditional}, written in the form 26145@samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete 26146form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part 26147is present in the 26148rule, this is an additional condition that must be satisfied before 26149the rule is accepted. Once @var{old} has been successfully matched 26150to the target expression, @var{cond} is evaluated (with all the 26151meta-variables substituted for the values they matched) and simplified 26152with Calc's algebraic simplifications. If the result is a nonzero 26153number or any other object known to be nonzero (@pxref{Declarations}), 26154the rule is accepted. If the result is zero or if it is a symbolic 26155formula that is not known to be nonzero, the rule is rejected. 26156@xref{Logical Operations}, for a number of functions that return 261571 or 0 according to the results of various tests. 26158 26159For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n} 26160is replaced by a positive or nonpositive number, respectively (or if 26161@expr{n} has been declared to be positive or nonpositive). Thus, 26162the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to 26163@samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)} 26164(assuming no outstanding declarations for @expr{a}). In the case of 26165@samp{f(-3, 2)}, the condition can be shown not to be satisfied; in 26166the case of @samp{f(12, a+1)}, the condition merely cannot be shown 26167to be satisfied, but that is enough to reject the rule. 26168 26169While Calc will use declarations to reason about variables in the 26170formula being rewritten, declarations do not apply to meta-variables. 26171For example, the rule @samp{f(a) := g(a+1)} will match for any values 26172of @samp{a}, such as complex numbers, vectors, or formulas, even if 26173@samp{a} has been declared to be real or scalar. If you want the 26174meta-variable @samp{a} to match only literal real numbers, use 26175@samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only 26176reals and formulas which are provably real, use @samp{dreal(a)} as 26177the condition. 26178 26179The @samp{::} operator is a shorthand for the @code{condition} 26180function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to 26181the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}. 26182 26183If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3} 26184or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent. 26185 26186It is also possible to embed conditions inside the pattern: 26187@samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational 26188convenience, though; where a condition appears in a rule has no 26189effect on when it is tested. The rewrite-rule compiler automatically 26190decides when it is best to test each condition while a rule is being 26191matched. 26192 26193Certain conditions are handled as special cases by the rewrite rule 26194system and are tested very efficiently: Where @expr{x} is any 26195meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)}, 26196@samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y} 26197is either a constant or another meta-variable and @samp{>=} may be 26198replaced by any of the six relational operators, and @samp{x % a = b} 26199where @expr{a} and @expr{b} are constants. Other conditions, like 26200@samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check 26201since Calc must bring the whole evaluator and simplifier into play. 26202 26203An interesting property of @samp{::} is that neither of its arguments 26204will be touched by Calc's default simplifications. This is important 26205because conditions often are expressions that cannot safely be 26206evaluated early. For example, the @code{typeof} function never 26207remains in symbolic form; entering @samp{typeof(a)} will put the 26208number 100 (the type code for variables like @samp{a}) on the stack. 26209But putting the condition @samp{... :: typeof(a) = 6} on the stack 26210is safe since @samp{::} prevents the @code{typeof} from being 26211evaluated until the condition is actually used by the rewrite system. 26212 26213Since @samp{::} protects its lefthand side, too, you can use a dummy 26214condition to protect a rule that must itself not evaluate early. 26215For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on 26216the stack because it will immediately evaluate to @samp{a(f,x) := f(x)}, 26217where the meta-variable-ness of @code{f} on the righthand side has been 26218lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course 26219the condition @samp{1} is always true (nonzero) so it has no effect on 26220the functioning of the rule. (The rewrite compiler will ensure that 26221it doesn't even impact the speed of matching the rule.) 26222 26223@node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules 26224@subsection Algebraic Properties of Rewrite Rules 26225 26226@noindent 26227The rewrite mechanism understands the algebraic properties of functions 26228like @samp{+} and @samp{*}. In particular, pattern matching takes 26229the associativity and commutativity of the following functions into 26230account: 26231 26232@smallexample 26233+ - * = != && || and or xor vint vunion vxor gcd lcm max min beta 26234@end smallexample 26235 26236For example, the rewrite rule: 26237 26238@example 26239a x + b x := (a + b) x 26240@end example 26241 26242@noindent 26243will match formulas of the form, 26244 26245@example 26246a x + b x, x a + x b, a x + x b, x a + b x 26247@end example 26248 26249Rewrites also understand the relationship between the @samp{+} and @samp{-} 26250operators. The above rewrite rule will also match the formulas, 26251 26252@example 26253a x - b x, x a - x b, a x - x b, x a - b x 26254@end example 26255 26256@noindent 26257by matching @samp{b} in the pattern to @samp{-b} from the formula. 26258 26259Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this 26260pattern will check all pairs of terms for possible matches. The rewrite 26261will take whichever suitable pair it discovers first. 26262 26263In general, a pattern using an associative operator like @samp{a + b} 26264will try @var{2 n} different ways to match a sum of @var{n} terms 26265like @samp{x + y + z - w}. First, @samp{a} is matched against each 26266of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b} 26267being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc. 26268If none of these succeed, then @samp{b} is matched against each of the 26269four terms with @samp{a} matching the remainder. Half-and-half matches, 26270like @samp{(x + y) + (z - w)}, are not tried. 26271 26272Note that @samp{*} is not commutative when applied to matrices, but 26273rewrite rules pretend that it is. If you type @kbd{m v} to enable 26274Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*} 26275literally, ignoring its usual commutativity property. (In the 26276current implementation, the associativity also vanishes---it is as 26277if the pattern had been enclosed in a @code{plain} marker; see below.) 26278If you are applying rewrites to formulas with matrices, it's best to 26279enable Matrix mode first to prevent algebraically incorrect rewrites 26280from occurring. 26281 26282The pattern @samp{-x} will actually match any expression. For example, 26283the rule 26284 26285@example 26286f(-x) := -f(x) 26287@end example 26288 26289@noindent 26290will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use 26291a @code{plain} marker as described below, or add a @samp{negative(x)} 26292condition. The @code{negative} function is true if its argument 26293``looks'' negative, for example, because it is a negative number or 26294because it is a formula like @samp{-x}. The new rule using this 26295condition is: 26296 26297@example 26298f(x) := -f(-x) :: negative(x) @r{or, equivalently,} 26299f(-x) := -f(x) :: negative(-x) 26300@end example 26301 26302In the same way, the pattern @samp{x - y} will match the sum @samp{a + b} 26303by matching @samp{y} to @samp{-b}. 26304 26305The pattern @samp{a b} will also match the formula @samp{x/y} if 26306@samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x} 26307will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or 26308@samp{(a + 1:2) x}, depending on the current fraction mode). 26309 26310Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and 26311@samp{^}. For example, the pattern @samp{f(a b)} will not match 26312@samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even 26313though conceivably these patterns could match with @samp{a = b = x}. 26314Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a 26315constant, even though it could be considered to match with @samp{a = x} 26316and @samp{b = 1/y}. The reasons are partly for efficiency, and partly 26317because while few mathematical operations are substantively different 26318for addition and subtraction, often it is preferable to treat the cases 26319of multiplication, division, and integer powers separately. 26320 26321Even more subtle is the rule set 26322 26323@example 26324[ f(a) + f(b) := f(a + b), -f(a) := f(-a) ] 26325@end example 26326 26327@noindent 26328attempting to match @samp{f(x) - f(y)}. You might think that Calc 26329will view this subtraction as @samp{f(x) + (-f(y))} and then apply 26330the above two rules in turn, but actually this will not work because 26331Calc only does this when considering rules for @samp{+} (like the 26332first rule in this set). So it will see first that @samp{f(x) + (-f(y))} 26333does not match @samp{f(a) + f(b)} for any assignments of the 26334meta-variables, and then it will see that @samp{f(x) - f(y)} does 26335not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc 26336tries only one rule at a time, it will not be able to rewrite 26337@samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)} 26338rule will have to be added. 26339 26340Another thing patterns will @emph{not} do is break up complex numbers. 26341The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas 26342involving the special constant @samp{i} (such as @samp{3 - 4 i}), but 26343it will not match actual complex numbers like @samp{(3, -4)}. A version 26344of the above rule for complex numbers would be 26345 26346@example 26347myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0 26348@end example 26349 26350@noindent 26351(Because the @code{re} and @code{im} functions understand the properties 26352of the special constant @samp{i}, this rule will also work for 26353@samp{3 - 4 i}. In fact, this particular rule would probably be better 26354without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the 26355righthand side of the rule will still give the correct answer for the 26356conjugate of a real number.) 26357 26358It is also possible to specify optional arguments in patterns. The rule 26359 26360@example 26361opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d) 26362@end example 26363 26364@noindent 26365will match the formula 26366 26367@example 263685 (x^2 - 4) + 3 x 26369@end example 26370 26371@noindent 26372in a fairly straightforward manner, but it will also match reduced 26373formulas like 26374 26375@example 26376x + x^2, 2(x + 1) - x, x + x 26377@end example 26378 26379@noindent 26380producing, respectively, 26381 26382@example 26383f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0) 26384@end example 26385 26386(The latter two formulas can be entered only if default simplifications 26387have been turned off with @kbd{m O}.) 26388 26389The default value for a term of a sum is zero. The default value 26390for a part of a product, for a power, or for the denominator of a 26391quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b} 26392with @samp{a = -1}. 26393 26394In particular, the distributive-law rule can be refined to 26395 26396@example 26397opt(a) x + opt(b) x := (a + b) x 26398@end example 26399 26400@noindent 26401so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}. 26402 26403The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which 26404are linear in @samp{x}. You can also use the @code{lin} and @code{islin} 26405functions with rewrite conditions to test for this; @pxref{Logical 26406Operations}. These functions are not as convenient to use in rewrite 26407rules, but they recognize more kinds of formulas as linear: 26408@samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin}, 26409but it will not match the above pattern because that pattern calls 26410for a multiplication, not a division. 26411 26412As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2} 26413by 1, 26414 26415@example 26416sin(x)^2 + cos(x)^2 := 1 26417@end example 26418 26419@noindent 26420misses many cases because the sine and cosine may both be multiplied by 26421an equal factor. Here's a more successful rule: 26422 26423@example 26424opt(a) sin(x)^2 + opt(a) cos(x)^2 := a 26425@end example 26426 26427Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2} 26428because one @expr{a} would have ``matched'' 1 while the other matched 6. 26429 26430Calc automatically converts a rule like 26431 26432@example 26433f(x-1, x) := g(x) 26434@end example 26435 26436@noindent 26437into the form 26438 26439@example 26440f(temp, x) := g(x) :: temp = x-1 26441@end example 26442 26443@noindent 26444(where @code{temp} stands for a new, invented meta-variable that 26445doesn't actually have a name). This modified rule will successfully 26446match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7, 26447respectively, then verifying that they differ by one even though 26448@samp{6} does not superficially look like @samp{x-1}. 26449 26450However, Calc does not solve equations to interpret a rule. The 26451following rule, 26452 26453@example 26454f(x-1, x+1) := g(x) 26455@end example 26456 26457@noindent 26458will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)} 26459but not @samp{f(6, 8)}. Calc always interprets at least one occurrence 26460of a variable by literal matching. If the variable appears ``isolated'' 26461then Calc is smart enough to use it for literal matching. But in this 26462last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp) 26463:= g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an 26464actual ``something-minus-one'' in the target formula. 26465 26466A successful way to write this would be @samp{f(x, x+2) := g(x+1)}. 26467You could make this resemble the original form more closely by using 26468@code{let} notation, which is described in the next section: 26469 26470@example 26471f(xm1, x+1) := g(x) :: let(x := xm1+1) 26472@end example 26473 26474Calc does this rewriting or ``conditionalizing'' for any sub-pattern 26475which involves only the functions in the following list, operating 26476only on constants and meta-variables which have already been matched 26477elsewhere in the pattern. When matching a function call, Calc is 26478careful to match arguments which are plain variables before arguments 26479which are calls to any of the functions below, so that a pattern like 26480@samp{f(x-1, x)} can be conditionalized even though the isolated 26481@samp{x} comes after the @samp{x-1}. 26482 26483@smallexample 26484+ - * / \ % ^ abs sign round rounde roundu trunc floor ceil 26485max min re im conj arg 26486@end smallexample 26487 26488You can suppress all of the special treatments described in this 26489section by surrounding a function call with a @code{plain} marker. 26490This marker causes the function call which is its argument to be 26491matched literally, without regard to commutativity, associativity, 26492negation, or conditionalization. When you use @code{plain}, the 26493``deep structure'' of the formula being matched can show through. 26494For example, 26495 26496@example 26497plain(a - a b) := f(a, b) 26498@end example 26499 26500@noindent 26501will match only literal subtractions. However, the @code{plain} 26502marker does not affect its arguments' arguments. In this case, 26503commutativity and associativity is still considered while matching 26504the @w{@samp{a b}} sub-pattern, so the whole pattern will match 26505@samp{x - y x} as well as @samp{x - x y}. We could go still 26506further and use 26507 26508@example 26509plain(a - plain(a b)) := f(a, b) 26510@end example 26511 26512@noindent 26513which would do a completely strict match for the pattern. 26514 26515By contrast, the @code{quote} marker means that not only the 26516function name but also the arguments must be literally the same. 26517The above pattern will match @samp{x - x y} but 26518 26519@example 26520quote(a - a b) := f(a, b) 26521@end example 26522 26523@noindent 26524will match only the single formula @samp{a - a b}. Also, 26525 26526@example 26527quote(a - quote(a b)) := f(a, b) 26528@end example 26529 26530@noindent 26531will match only @samp{a - quote(a b)}---probably not the desired 26532effect! 26533 26534A certain amount of algebra is also done when substituting the 26535meta-variables on the righthand side of a rule. For example, 26536in the rule 26537 26538@example 26539a + f(b) := f(a + b) 26540@end example 26541 26542@noindent 26543matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if 26544taken literally, but the rewrite mechanism will simplify the 26545righthand side to @samp{f(x - y)} automatically. (Of course, 26546the default simplifications would do this anyway, so this 26547special simplification is only noticeable if you have turned the 26548default simplifications off.) This rewriting is done only when 26549a meta-variable expands to a ``negative-looking'' expression. 26550If this simplification is not desirable, you can use a @code{plain} 26551marker on the righthand side: 26552 26553@example 26554a + f(b) := f(plain(a + b)) 26555@end example 26556 26557@noindent 26558In this example, we are still allowing the pattern-matcher to 26559use all the algebra it can muster, but the righthand side will 26560always simplify to a literal addition like @samp{f((-y) + x)}. 26561 26562@node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules 26563@subsection Other Features of Rewrite Rules 26564 26565@noindent 26566Certain ``function names'' serve as markers in rewrite rules. 26567Here is a complete list of these markers. First are listed the 26568markers that work inside a pattern; then come the markers that 26569work in the righthand side of a rule. 26570 26571@ignore 26572@starindex 26573@end ignore 26574@tindex import 26575One kind of marker, @samp{import(x)}, takes the place of a whole 26576rule. Here @expr{x} is the name of a variable containing another 26577rule set; those rules are ``spliced into'' the rule set that 26578imports them. For example, if @samp{[f(a+b) := f(a) + f(b), 26579f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF}, 26580then the rule set @samp{[f(0) := 0, import(linearF)]} will apply 26581all three rules. It is possible to modify the imported rules 26582slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports 26583the rule set @expr{x} with all occurrences of 26584@texline @math{v_1}, 26585@infoline @expr{v1}, 26586as either a variable name or a function name, replaced with 26587@texline @math{x_1} 26588@infoline @expr{x1} 26589and so on. (If 26590@texline @math{v_1} 26591@infoline @expr{v1} 26592is used as a function name, then 26593@texline @math{x_1} 26594@infoline @expr{x1} 26595must be either a function name itself or a @w{@samp{< >}} nameless 26596function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0, 26597import(linearF, f, g)]} applies the linearity rules to the function 26598@samp{g} instead of @samp{f}. Imports can be nested, but the 26599import-with-renaming feature may fail to rename sub-imports properly. 26600 26601The special functions allowed in patterns are: 26602 26603@table @samp 26604@item quote(x) 26605@ignore 26606@starindex 26607@end ignore 26608@tindex quote 26609This pattern matches exactly @expr{x}; variable names in @expr{x} are 26610not interpreted as meta-variables. The only flexibility is that 26611numbers are compared for numeric equality, so that the pattern 26612@samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}. 26613(Numbers are always treated this way by the rewrite mechanism: 26614The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}. 26615The rewrite may produce either @samp{g(12)} or @samp{g(12.0)} 26616as a result in this case.) 26617 26618@item plain(x) 26619@ignore 26620@starindex 26621@end ignore 26622@tindex plain 26623Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This 26624pattern matches a call to function @expr{f} with the specified 26625argument patterns. No special knowledge of the properties of the 26626function @expr{f} is used in this case; @samp{+} is not commutative or 26627associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}} 26628are treated as patterns. If you wish them to be treated ``plainly'' 26629as well, you must enclose them with more @code{plain} markers: 26630@samp{plain(plain(@w{-a}) + plain(b c))}. 26631 26632@item opt(x,def) 26633@ignore 26634@starindex 26635@end ignore 26636@tindex opt 26637Here @expr{x} must be a variable name. This must appear as an 26638argument to a function or an element of a vector; it specifies that 26639the argument or element is optional. 26640As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||}, 26641or as the second argument to @samp{/} or @samp{^}, the value @var{def} 26642may be omitted. The pattern @samp{x + opt(y)} matches a sum by 26643binding one summand to @expr{x} and the other to @expr{y}, and it 26644matches anything else by binding the whole expression to @expr{x} and 26645zero to @expr{y}. The other operators above work similarly. 26646 26647For general miscellaneous functions, the default value @code{def} 26648must be specified. Optional arguments are dropped starting with 26649the rightmost one during matching. For example, the pattern 26650@samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)}, 26651or @samp{f(a,b,c)}. Default values of zero and @expr{b} are 26652supplied in this example for the omitted arguments. Note that 26653the literal variable @expr{b} will be the default in the latter 26654case, @emph{not} the value that matched the meta-variable @expr{b}. 26655In other words, the default @var{def} is effectively quoted. 26656 26657@item condition(x,c) 26658@ignore 26659@starindex 26660@end ignore 26661@tindex condition 26662@tindex :: 26663This matches the pattern @expr{x}, with the attached condition 26664@expr{c}. It is the same as @samp{x :: c}. 26665 26666@item pand(x,y) 26667@ignore 26668@starindex 26669@end ignore 26670@tindex pand 26671@tindex &&& 26672This matches anything that matches both pattern @expr{x} and 26673pattern @expr{y}. It is the same as @samp{x &&& y}. 26674@pxref{Composing Patterns in Rewrite Rules}. 26675 26676@item por(x,y) 26677@ignore 26678@starindex 26679@end ignore 26680@tindex por 26681@tindex ||| 26682This matches anything that matches either pattern @expr{x} or 26683pattern @expr{y}. It is the same as @w{@samp{x ||| y}}. 26684 26685@item pnot(x) 26686@ignore 26687@starindex 26688@end ignore 26689@tindex pnot 26690@tindex !!! 26691This matches anything that does not match pattern @expr{x}. 26692It is the same as @samp{!!! x}. 26693 26694@item cons(h,t) 26695@ignore 26696@mindex cons 26697@end ignore 26698@tindex cons (rewrites) 26699This matches any vector of one or more elements. The first 26700element is matched to @expr{h}; a vector of the remaining 26701elements is matched to @expr{t}. Note that vectors of fixed 26702length can also be matched as actual vectors: The rule 26703@samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent 26704to the rule @samp{[a,b] := [a+b]}. 26705 26706@item rcons(t,h) 26707@ignore 26708@mindex rcons 26709@end ignore 26710@tindex rcons (rewrites) 26711This is like @code{cons}, except that the @emph{last} element 26712is matched to @expr{h}, with the remaining elements matched 26713to @expr{t}. 26714 26715@item apply(f,args) 26716@ignore 26717@mindex apply 26718@end ignore 26719@tindex apply (rewrites) 26720This matches any function call. The name of the function, in 26721the form of a variable, is matched to @expr{f}. The arguments 26722of the function, as a vector of zero or more objects, are 26723matched to @samp{args}. Constants, variables, and vectors 26724do @emph{not} match an @code{apply} pattern. For example, 26725@samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)} 26726matches any call to the function @samp{f}, @samp{apply(f,[a,b])} 26727matches any function call with exactly two arguments, and 26728@samp{apply(quote(f), cons(a,cons(b,x)))} matches any call 26729to the function @samp{f} with two or more arguments. Another 26730way to implement the latter, if the rest of the rule does not 26731need to refer to the first two arguments of @samp{f} by name, 26732would be @samp{apply(quote(f), x :: vlen(x) >= 2)}. 26733Here's a more interesting sample use of @code{apply}: 26734 26735@example 26736apply(f,[x+n]) := n + apply(f,[x]) 26737 :: in(f, [floor,ceil,round,trunc]) :: integer(n) 26738@end example 26739 26740Note, however, that this will be slower to match than a rule 26741set with four separate rules. The reason is that Calc sorts 26742the rules of a rule set according to top-level function name; 26743if the top-level function is @code{apply}, Calc must try the 26744rule for every single formula and sub-formula. If the top-level 26745function in the pattern is, say, @code{floor}, then Calc invokes 26746the rule only for sub-formulas which are calls to @code{floor}. 26747 26748Formulas normally written with operators like @code{+} are still 26749considered function calls: @code{apply(f,x)} matches @samp{a+b} 26750with @samp{f = add}, @samp{x = [a,b]}. 26751 26752You must use @code{apply} for meta-variables with function names 26753on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)} 26754is @emph{not} correct, because it rewrites @samp{spam(6)} into 26755@samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}. 26756Also note that you will have to use No-Simplify mode (@kbd{m O}) 26757when entering this rule so that the @code{apply} isn't 26758evaluated immediately to get the new rule @samp{f(x) := f(x+1)}. 26759Or, use @kbd{s e} to enter the rule without going through the stack, 26760or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}. 26761@xref{Conditional Rewrite Rules}. 26762 26763@item select(x) 26764@ignore 26765@starindex 26766@end ignore 26767@tindex select 26768This is used for applying rules to formulas with selections; 26769@pxref{Selections with Rewrite Rules}. 26770@end table 26771 26772Special functions for the righthand sides of rules are: 26773 26774@table @samp 26775@item quote(x) 26776The notation @samp{quote(x)} is changed to @samp{x} when the 26777righthand side is used. As far as the rewrite rule is concerned, 26778@code{quote} is invisible. However, @code{quote} has the special 26779property in Calc that its argument is not evaluated. Thus, 26780while it will not work to put the rule @samp{t(a) := typeof(a)} 26781on the stack because @samp{typeof(a)} is evaluated immediately 26782to produce @samp{t(a) := 100}, you can use @code{quote} to 26783protect the righthand side: @samp{t(a) := quote(typeof(a))}. 26784(@xref{Conditional Rewrite Rules}, for another trick for 26785protecting rules from evaluation.) 26786 26787@item plain(x) 26788Special properties of and simplifications for the function call 26789@expr{x} are not used. One interesting case where @code{plain} 26790is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a 26791shorthand notation for the @code{quote} function. This rule will 26792not work as shown; instead of replacing @samp{q(foo)} with 26793@samp{quote(foo)}, it will replace it with @samp{foo}! The correct 26794rule would be @samp{q(x) := plain(quote(x))}. 26795 26796@item cons(h,t) 26797Where @expr{t} is a vector, this is converted into an expanded 26798vector during rewrite processing. Note that @code{cons} is a regular 26799Calc function which normally does this anyway; the only way @code{cons} 26800is treated specially by rewrites is that @code{cons} on the righthand 26801side of a rule will be evaluated even if default simplifications 26802have been turned off. 26803 26804@item rcons(t,h) 26805Analogous to @code{cons} except putting @expr{h} at the @emph{end} of 26806the vector @expr{t}. 26807 26808@item apply(f,args) 26809Where @expr{f} is a variable and @var{args} is a vector, this 26810is converted to a function call. Once again, note that @code{apply} 26811is also a regular Calc function. 26812 26813@item eval(x) 26814@ignore 26815@starindex 26816@end ignore 26817@tindex eval 26818The formula @expr{x} is handled in the usual way, then the 26819default simplifications are applied to it even if they have 26820been turned off normally. This allows you to treat any function 26821similarly to the way @code{cons} and @code{apply} are always 26822treated. However, there is a slight difference: @samp{cons(2+3, [])} 26823with default simplifications off will be converted to @samp{[2+3]}, 26824whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}. 26825 26826@item evalsimp(x) 26827@ignore 26828@starindex 26829@end ignore 26830@tindex evalsimp 26831The formula @expr{x} has meta-variables substituted in the usual 26832way, then algebraically simplified. 26833 26834@item evalextsimp(x) 26835@ignore 26836@starindex 26837@end ignore 26838@tindex evalextsimp 26839The formula @expr{x} has meta-variables substituted in the normal 26840way, then ``extendedly'' simplified as if by the @kbd{a e} command. 26841 26842@item select(x) 26843@xref{Selections with Rewrite Rules}. 26844@end table 26845 26846There are also some special functions you can use in conditions. 26847 26848@table @samp 26849@item let(v := x) 26850@ignore 26851@starindex 26852@end ignore 26853@tindex let 26854The expression @expr{x} is evaluated with meta-variables substituted. 26855The algebraic simplifications are @emph{not} applied by 26856default, but @expr{x} can include calls to @code{evalsimp} or 26857@code{evalextsimp} as described above to invoke higher levels 26858of simplification. The result of @expr{x} is then bound to the 26859meta-variable @expr{v}. As usual, if this meta-variable has already 26860been matched to something else the two values must be equal; if the 26861meta-variable is new then it is bound to the result of the expression. 26862This variable can then appear in later conditions, and on the righthand 26863side of the rule. 26864In fact, @expr{v} may be any pattern in which case the result of 26865evaluating @expr{x} is matched to that pattern, binding any 26866meta-variables that appear in that pattern. Note that @code{let} 26867can only appear by itself as a condition, or as one term of an 26868@samp{&&} which is a whole condition: It cannot be inside 26869an @samp{||} term or otherwise buried. 26870 26871The alternate, equivalent form @samp{let(v, x)} is also recognized. 26872Note that the use of @samp{:=} by @code{let}, while still being 26873assignment-like in character, is unrelated to the use of @samp{:=} 26874in the main part of a rewrite rule. 26875 26876As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)} 26877replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if 26878that inverse exists and is constant. For example, if @samp{a} is a 26879singular matrix the operation @samp{1/a} is left unsimplified and 26880@samp{constant(ia)} fails, but if @samp{a} is an invertible matrix 26881then the rule succeeds. Without @code{let} there would be no way 26882to express this rule that didn't have to invert the matrix twice. 26883Note that, because the meta-variable @samp{ia} is otherwise unbound 26884in this rule, the @code{let} condition itself always ``succeeds'' 26885because no matter what @samp{1/a} evaluates to, it can successfully 26886be bound to @code{ia}. 26887 26888Here's another example, for integrating cosines of linear 26889terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}. 26890The @code{lin} function returns a 3-vector if its argument is linear, 26891or leaves itself unevaluated if not. But an unevaluated @code{lin} 26892call will not match the 3-vector on the lefthand side of the @code{let}, 26893so this @code{let} both verifies that @code{y} is linear, and binds 26894the coefficients @code{a} and @code{b} for use elsewhere in the rule. 26895(It would have been possible to use @samp{sin(a x + b)/b} for the 26896righthand side instead, but using @samp{sin(y)/b} avoids gratuitous 26897rearrangement of the argument of the sine.) 26898 26899@ignore 26900@starindex 26901@end ignore 26902@tindex ierf 26903Similarly, here is a rule that implements an inverse-@code{erf} 26904function. It uses @code{root} to search for a solution. If 26905@code{root} succeeds, it will return a vector of two numbers 26906where the first number is the desired solution. If no solution 26907is found, @code{root} remains in symbolic form. So we use 26908@code{let} to check that the result was indeed a vector. 26909 26910@example 26911ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5)) 26912@end example 26913 26914@item matches(v,p) 26915The meta-variable @var{v}, which must already have been matched 26916to something elsewhere in the rule, is compared against pattern 26917@var{p}. Since @code{matches} is a standard Calc function, it 26918can appear anywhere in a condition. But if it appears alone or 26919as a term of a top-level @samp{&&}, then you get the special 26920extra feature that meta-variables which are bound to things 26921inside @var{p} can be used elsewhere in the surrounding rewrite 26922rule. 26923 26924The only real difference between @samp{let(p := v)} and 26925@samp{matches(v, p)} is that the former evaluates @samp{v} using 26926the default simplifications, while the latter does not. 26927 26928@item remember 26929@vindex remember 26930This is actually a variable, not a function. If @code{remember} 26931appears as a condition in a rule, then when that rule succeeds 26932the original expression and rewritten expression are added to the 26933front of the rule set that contained the rule. If the rule set 26934was not stored in a variable, @code{remember} is ignored. The 26935lefthand side is enclosed in @code{quote} in the added rule if it 26936contains any variables. 26937 26938For example, the rule @samp{f(n) := n f(n-1) :: remember} applied 26939to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front 26940of the rule set. The rule set @code{EvalRules} works slightly 26941differently: There, the evaluation of @samp{f(6)} will complete before 26942the result is added to the rule set, in this case as @samp{f(7) := 5040}. 26943Thus @code{remember} is most useful inside @code{EvalRules}. 26944 26945It is up to you to ensure that the optimization performed by 26946@code{remember} is safe. For example, the rule @samp{foo(n) := n 26947:: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is 26948the function equivalent of the @kbd{=} command); if the variable 26949@code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will 26950be added to the rule set and will continue to operate even if 26951@code{eatfoo} is later changed to 0. 26952 26953@item remember(c) 26954@ignore 26955@starindex 26956@end ignore 26957@tindex remember 26958Remember the match as described above, but only if condition @expr{c} 26959is true. For example, @samp{remember(n % 4 = 0)} in the above factorial 26960rule remembers only every fourth result. Note that @samp{remember(1)} 26961is equivalent to @samp{remember}, and @samp{remember(0)} has no effect. 26962@end table 26963 26964@node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules 26965@subsection Composing Patterns in Rewrite Rules 26966 26967@noindent 26968There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!}, 26969that combine rewrite patterns to make larger patterns. The 26970combinations are ``and,'' ``or,'' and ``not,'' respectively, and 26971these operators are the pattern equivalents of @samp{&&}, @samp{||} 26972and @samp{!} (which operate on zero-or-nonzero logical values). 26973 26974Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic 26975form by all regular Calc features; they have special meaning only in 26976the context of rewrite rule patterns. 26977 26978The pattern @samp{@var{p1} &&& @var{p2}} matches anything that 26979matches both @var{p1} and @var{p2}. One especially useful case is 26980when one of @var{p1} or @var{p2} is a meta-variable. For example, 26981here is a rule that operates on error forms: 26982 26983@example 26984f(x &&& a +/- b, x) := g(x) 26985@end example 26986 26987This does the same thing, but is arguably simpler than, the rule 26988 26989@example 26990f(a +/- b, a +/- b) := g(a +/- b) 26991@end example 26992 26993@ignore 26994@starindex 26995@end ignore 26996@tindex ends 26997Here's another interesting example: 26998 26999@example 27000ends(cons(a, x) &&& rcons(y, b)) := [a, b] 27001@end example 27002 27003@noindent 27004which effectively clips out the middle of a vector leaving just 27005the first and last elements. This rule will change a one-element 27006vector @samp{[a]} to @samp{[a, a]}. The similar rule 27007 27008@example 27009ends(cons(a, rcons(y, b))) := [a, b] 27010@end example 27011 27012@noindent 27013would do the same thing except that it would fail to match a 27014one-element vector. 27015 27016@tex 27017\bigskip 27018@end tex 27019 27020The pattern @samp{@var{p1} ||| @var{p2}} matches anything that 27021matches either @var{p1} or @var{p2}. Calc first tries matching 27022against @var{p1}; if that fails, it goes on to try @var{p2}. 27023 27024@ignore 27025@starindex 27026@end ignore 27027@tindex curve 27028A simple example of @samp{|||} is 27029 27030@example 27031curve(inf ||| -inf) := 0 27032@end example 27033 27034@noindent 27035which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero. 27036 27037Here is a larger example: 27038 27039@example 27040log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b) 27041@end example 27042 27043This matches both generalized and natural logarithms in a single rule. 27044Note that the @samp{::} term must be enclosed in parentheses because 27045that operator has lower precedence than @samp{|||} or @samp{:=}. 27046 27047(In practice this rule would probably include a third alternative, 27048omitted here for brevity, to take care of @code{log10}.) 27049 27050While Calc generally treats interior conditions exactly the same as 27051conditions on the outside of a rule, it does guarantee that if all the 27052variables in the condition are special names like @code{e}, or already 27053bound in the pattern to which the condition is attached (say, if 27054@samp{a} had appeared in this condition), then Calc will process this 27055condition right after matching the pattern to the left of the @samp{::}. 27056Thus, we know that @samp{b} will be bound to @samp{e} only if the 27057@code{ln} branch of the @samp{|||} was taken. 27058 27059Note that this rule was careful to bind the same set of meta-variables 27060on both sides of the @samp{|||}. Calc does not check this, but if 27061you bind a certain meta-variable only in one branch and then use that 27062meta-variable elsewhere in the rule, results are unpredictable: 27063 27064@example 27065f(a,b) ||| g(b) := h(a,b) 27066@end example 27067 27068Here if the pattern matches @samp{g(17)}, Calc makes no promises about 27069the value that will be substituted for @samp{a} on the righthand side. 27070 27071@tex 27072\bigskip 27073@end tex 27074 27075The pattern @samp{!!! @var{pat}} matches anything that does not 27076match @var{pat}. Any meta-variables that are bound while matching 27077@var{pat} remain unbound outside of @var{pat}. 27078 27079For example, 27080 27081@example 27082f(x &&& !!! a +/- b, !!![]) := g(x) 27083@end example 27084 27085@noindent 27086converts @code{f} whose first argument is anything @emph{except} an 27087error form, and whose second argument is not the empty vector, into 27088a similar call to @code{g} (but without the second argument). 27089 27090If we know that the second argument will be a vector (empty or not), 27091then an equivalent rule would be: 27092 27093@example 27094f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0 27095@end example 27096 27097@noindent 27098where of course 7 is the @code{typeof} code for error forms. 27099Another final condition, that works for any kind of @samp{y}, 27100would be @samp{!istrue(y == [])}. (The @code{istrue} function 27101returns an explicit 0 if its argument was left in symbolic form; 27102plain @samp{!(y == [])} or @samp{y != []} would not work to replace 27103@samp{!!![]} since these would be left unsimplified, and thus cause 27104the rule to fail, if @samp{y} was something like a variable name.) 27105 27106It is possible for a @samp{!!!} to refer to meta-variables bound 27107elsewhere in the pattern. For example, 27108 27109@example 27110f(a, !!!a) := g(a) 27111@end example 27112 27113@noindent 27114matches any call to @code{f} with different arguments, changing 27115this to @code{g} with only the first argument. 27116 27117If a function call is to be matched and one of the argument patterns 27118contains a @samp{!!!} somewhere inside it, that argument will be 27119matched last. Thus 27120 27121@example 27122f(!!!a, a) := g(a) 27123@end example 27124 27125@noindent 27126will be careful to bind @samp{a} to the second argument of @code{f} 27127before testing the first argument. If Calc had tried to match the 27128first argument of @code{f} first, the results would have been 27129disastrous: since @code{a} was unbound so far, the pattern @samp{a} 27130would have matched anything at all, and the pattern @samp{!!!a} 27131therefore would @emph{not} have matched anything at all! 27132 27133@node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules 27134@subsection Nested Formulas with Rewrite Rules 27135 27136@noindent 27137When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from 27138the top of the stack and attempts to match any of the specified rules 27139to any part of the expression, starting with the whole expression 27140and then, if that fails, trying deeper and deeper sub-expressions. 27141For each part of the expression, the rules are tried in the order 27142they appear in the rules vector. The first rule to match the first 27143sub-expression wins; it replaces the matched sub-expression according 27144to the @var{new} part of the rule. 27145 27146Often, the rule set will match and change the formula several times. 27147The top-level formula is first matched and substituted repeatedly until 27148it no longer matches the pattern; then, sub-formulas are tried, and 27149so on. Once every part of the formula has gotten its chance, the 27150rewrite mechanism starts over again with the top-level formula 27151(in case a substitution of one of its arguments has caused it again 27152to match). This continues until no further matches can be made 27153anywhere in the formula. 27154 27155It is possible for a rule set to get into an infinite loop. The 27156most obvious case, replacing a formula with itself, is not a problem 27157because a rule is not considered to ``succeed'' unless the righthand 27158side actually comes out to something different from the original 27159formula or sub-formula that was matched. But if you accidentally 27160had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse 27161@samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would 27162run forever switching a formula back and forth between the two 27163forms. 27164 27165To avoid disaster, Calc normally stops after 100 changes have been 27166made to the formula. This will be enough for most multiple rewrites, 27167but it will keep an endless loop of rewrites from locking up the 27168computer forever. (On most systems, you can also type @kbd{C-g} to 27169halt any Emacs command prematurely.) 27170 27171To change this limit, give a positive numeric prefix argument. 27172In particular, @kbd{M-1 a r} applies only one rewrite at a time, 27173useful when you are first testing your rule (or just if repeated 27174rewriting is not what is called for by your application). 27175 27176@ignore 27177@starindex 27178@end ignore 27179@ignore 27180@mindex iter@idots 27181@end ignore 27182@tindex iterations 27183You can also put a ``function call'' @samp{iterations(@var{n})} 27184in place of a rule anywhere in your rules vector (but usually at 27185the top). Then, @var{n} will be used instead of 100 as the default 27186number of iterations for this rule set. You can use 27187@samp{iterations(inf)} if you want no iteration limit by default. 27188A prefix argument will override the @code{iterations} limit in the 27189rule set. 27190 27191@example 27192[ iterations(1), 27193 f(x) := f(x+1) ] 27194@end example 27195 27196More precisely, the limit controls the number of ``iterations,'' 27197where each iteration is a successful matching of a rule pattern whose 27198righthand side, after substituting meta-variables and applying the 27199default simplifications, is different from the original sub-formula 27200that was matched. 27201 27202A prefix argument of zero sets the limit to infinity. Use with caution! 27203 27204Given a negative numeric prefix argument, @kbd{a r} will match and 27205substitute the top-level expression up to that many times, but 27206will not attempt to match the rules to any sub-expressions. 27207 27208In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})} 27209does a rewriting operation. Here @var{expr} is the expression 27210being rewritten, @var{rules} is the rule, vector of rules, or 27211variable containing the rules, and @var{n} is the optional 27212iteration limit, which may be a positive integer, a negative 27213integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted 27214the @code{iterations} value from the rule set is used; if both 27215are omitted, 100 is used. 27216 27217@node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules 27218@subsection Multi-Phase Rewrite Rules 27219 27220@noindent 27221It is possible to separate a rewrite rule set into several @dfn{phases}. 27222During each phase, certain rules will be enabled while certain others 27223will be disabled. A @dfn{phase schedule} controls the order in which 27224phases occur during the rewriting process. 27225 27226@ignore 27227@starindex 27228@end ignore 27229@tindex phase 27230@vindex all 27231If a call to the marker function @code{phase} appears in the rules 27232vector in place of a rule, all rules following that point will be 27233members of the phase(s) identified in the arguments to @code{phase}. 27234Phases are given integer numbers. The markers @samp{phase()} and 27235@samp{phase(all)} both mean the following rules belong to all phases; 27236this is the default at the start of the rule set. 27237 27238If you do not explicitly schedule the phases, Calc sorts all phase 27239numbers that appear in the rule set and executes the phases in 27240ascending order. For example, the rule set 27241 27242@example 27243@group 27244[ f0(x) := g0(x), 27245 phase(1), 27246 f1(x) := g1(x), 27247 phase(2), 27248 f2(x) := g2(x), 27249 phase(3), 27250 f3(x) := g3(x), 27251 phase(1,2), 27252 f4(x) := g4(x) ] 27253@end group 27254@end example 27255 27256@noindent 27257has three phases, 1 through 3. Phase 1 consists of the @code{f0}, 27258@code{f1}, and @code{f4} rules (in that order). Phase 2 consists of 27259@code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0} 27260and @code{f3}. 27261 27262When Calc rewrites a formula using this rule set, it first rewrites 27263the formula using only the phase 1 rules until no further changes are 27264possible. Then it switches to the phase 2 rule set and continues 27265until no further changes occur, then finally rewrites with phase 3. 27266When no more phase 3 rules apply, rewriting finishes. (This is 27267assuming @kbd{a r} with a large enough prefix argument to allow the 27268rewriting to run to completion; the sequence just described stops 27269early if the number of iterations specified in the prefix argument, 27270100 by default, is reached.) 27271 27272During each phase, Calc descends through the nested levels of the 27273formula as described previously. (@xref{Nested Formulas with Rewrite 27274Rules}.) Rewriting starts at the top of the formula, then works its 27275way down to the parts, then goes back to the top and works down again. 27276The phase 2 rules do not begin until no phase 1 rules apply anywhere 27277in the formula. 27278 27279@ignore 27280@starindex 27281@end ignore 27282@tindex schedule 27283A @code{schedule} marker appearing in the rule set (anywhere, but 27284conventionally at the top) changes the default schedule of phases. 27285In the simplest case, @code{schedule} has a sequence of phase numbers 27286for arguments; each phase number is invoked in turn until the 27287arguments to @code{schedule} are exhausted. Thus adding 27288@samp{schedule(3,2,1)} at the top of the above rule set would 27289reverse the order of the phases; @samp{schedule(1,2,3)} would have 27290no effect since this is the default schedule; and @samp{schedule(1,2,1,3)} 27291would give phase 1 a second chance after phase 2 has completed, before 27292moving on to phase 3. 27293 27294Any argument to @code{schedule} can instead be a vector of phase 27295numbers (or even of sub-vectors). Then the sub-sequence of phases 27296described by the vector are tried repeatedly until no change occurs 27297in any phase in the sequence. For example, @samp{schedule([1, 2], 3)} 27298tries phase 1, then phase 2, then, if either phase made any changes 27299to the formula, repeats these two phases until they can make no 27300further progress. Finally, it goes on to phase 3 for finishing 27301touches. 27302 27303Also, items in @code{schedule} can be variable names as well as 27304numbers. A variable name is interpreted as the name of a function 27305to call on the whole formula. For example, @samp{schedule(1, simplify)} 27306says to apply the phase-1 rules (presumably, all of them), then to 27307call @code{simplify} which is the function name equivalent of @kbd{a s}. 27308Likewise, @samp{schedule([1, simplify])} says to alternate between 27309phase 1 and @kbd{a s} until no further changes occur. 27310 27311Phases can be used purely to improve efficiency; if it is known that 27312a certain group of rules will apply only at the beginning of rewriting, 27313and a certain other group will apply only at the end, then rewriting 27314will be faster if these groups are identified as separate phases. 27315Once the phase 1 rules are done, Calc can put them aside and no longer 27316spend any time on them while it works on phase 2. 27317 27318There are also some problems that can only be solved with several 27319rewrite phases. For a real-world example of a multi-phase rule set, 27320examine the set @code{FitRules}, which is used by the curve-fitting 27321command to convert a model expression to linear form. 27322@xref{Curve Fitting Details}. This set is divided into four phases. 27323The first phase rewrites certain kinds of expressions to be more 27324easily linearizable, but less computationally efficient. After the 27325linear components have been picked out, the final phase includes the 27326opposite rewrites to put each component back into an efficient form. 27327If both sets of rules were included in one big phase, Calc could get 27328into an infinite loop going back and forth between the two forms. 27329 27330Elsewhere in @code{FitRules}, the components are first isolated, 27331then recombined where possible to reduce the complexity of the linear 27332fit, then finally packaged one component at a time into vectors. 27333If the packaging rules were allowed to begin before the recombining 27334rules were finished, some components might be put away into vectors 27335before they had a chance to recombine. By putting these rules in 27336two separate phases, this problem is neatly avoided. 27337 27338@node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules 27339@subsection Selections with Rewrite Rules 27340 27341@noindent 27342If a sub-formula of the current formula is selected (as by @kbd{j s}; 27343@pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite}) 27344command applies only to that sub-formula. Together with a negative 27345prefix argument, you can use this fact to apply a rewrite to one 27346specific part of a formula without affecting any other parts. 27347 27348@kindex j r 27349@pindex calc-rewrite-selection 27350The @kbd{j r} (@code{calc-rewrite-selection}) command allows more 27351sophisticated operations on selections. This command prompts for 27352the rules in the same way as @kbd{a r}, but it then applies those 27353rules to the whole formula in question even though a sub-formula 27354of it has been selected. However, the selected sub-formula will 27355first have been surrounded by a @samp{select( )} function call. 27356(Calc's evaluator does not understand the function name @code{select}; 27357this is only a tag used by the @kbd{j r} command.) 27358 27359For example, suppose the formula on the stack is @samp{2 (a + b)^2} 27360and the sub-formula @samp{a + b} is selected. This formula will 27361be rewritten to @samp{2 select(a + b)^2} and then the rewrite 27362rules will be applied in the usual way. The rewrite rules can 27363include references to @code{select} to tell where in the pattern 27364the selected sub-formula should appear. 27365 27366If there is still exactly one @samp{select( )} function call in 27367the formula after rewriting is done, it indicates which part of 27368the formula should be selected afterwards. Otherwise, the 27369formula will be unselected. 27370 27371You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts 27372of the rewrite rule with @samp{select()}. However, @kbd{j r} 27373allows you to use the current selection in more flexible ways. 27374Suppose you wished to make a rule which removed the exponent from 27375the selected term; the rule @samp{select(a)^x := select(a)} would 27376work. In the above example, it would rewrite @samp{2 select(a + b)^2} 27377to @samp{2 select(a + b)}. This would then be returned to the 27378stack as @samp{2 (a + b)} with the @samp{a + b} selected. 27379 27380The @kbd{j r} command uses one iteration by default, unlike 27381@kbd{a r} which defaults to 100 iterations. A numeric prefix 27382argument affects @kbd{j r} in the same way as @kbd{a r}. 27383@xref{Nested Formulas with Rewrite Rules}. 27384 27385As with other selection commands, @kbd{j r} operates on the stack 27386entry that contains the cursor. (If the cursor is on the top-of-stack 27387@samp{.} marker, it works as if the cursor were on the formula 27388at stack level 1.) 27389 27390If you don't specify a set of rules, the rules are taken from the 27391top of the stack, just as with @kbd{a r}. In this case, the 27392cursor must indicate stack entry 2 or above as the formula to be 27393rewritten (otherwise the same formula would be used as both the 27394target and the rewrite rules). 27395 27396If the indicated formula has no selection, the cursor position within 27397the formula temporarily selects a sub-formula for the purposes of this 27398command. If the cursor is not on any sub-formula (e.g., it is in 27399the line-number area to the left of the formula), the @samp{select( )} 27400markers are ignored by the rewrite mechanism and the rules are allowed 27401to apply anywhere in the formula. 27402 27403As a special feature, the normal @kbd{a r} command also ignores 27404@samp{select( )} calls in rewrite rules. For example, if you used the 27405above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply 27406the rule as if it were @samp{a^x := a}. Thus, you can write general 27407purpose rules with @samp{select( )} hints inside them so that they 27408will ``do the right thing'' in both @kbd{a r} and @kbd{j r}, 27409both with and without selections. 27410 27411@node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules 27412@subsection Matching Commands 27413 27414@noindent 27415@kindex a m 27416@pindex calc-match 27417@tindex match 27418The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a 27419vector of formulas and a rewrite-rule-style pattern, and produces 27420a vector of all formulas which match the pattern. The command 27421prompts you to enter the pattern; as for @kbd{a r}, you can enter 27422a single pattern (i.e., a formula with meta-variables), or a 27423vector of patterns, or a variable which contains patterns, or 27424you can give a blank response in which case the patterns are taken 27425from the top of the stack. The pattern set will be compiled once 27426and saved if it is stored in a variable. If there are several 27427patterns in the set, vector elements are kept if they match any 27428of the patterns. 27429 27430For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])} 27431will return @samp{[x+y, x-y, x+y+z]}. 27432 27433The @code{import} mechanism is not available for pattern sets. 27434 27435The @kbd{a m} command can also be used to extract all vector elements 27436which satisfy any condition: The pattern @samp{x :: x>0} will select 27437all the positive vector elements. 27438 27439@kindex I a m 27440@tindex matchnot 27441With the Inverse flag [@code{matchnot}], this command extracts all 27442vector elements which do @emph{not} match the given pattern. 27443 27444@ignore 27445@starindex 27446@end ignore 27447@tindex matches 27448There is also a function @samp{matches(@var{x}, @var{p})} which 27449evaluates to 1 if expression @var{x} matches pattern @var{p}, or 27450to 0 otherwise. This is sometimes useful for including into the 27451conditional clauses of other rewrite rules. 27452 27453@ignore 27454@starindex 27455@end ignore 27456@tindex vmatches 27457The function @code{vmatches} is just like @code{matches}, except 27458that if the match succeeds it returns a vector of assignments to 27459the meta-variables instead of the number 1. For example, 27460@samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}. 27461If the match fails, the function returns the number 0. 27462 27463@node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules 27464@subsection Automatic Rewrites 27465 27466@noindent 27467@cindex @code{EvalRules} variable 27468@vindex EvalRules 27469It is possible to get Calc to apply a set of rewrite rules on all 27470results, effectively adding to the built-in set of default 27471simplifications. To do this, simply store your rule set in the 27472variable @code{EvalRules}. There is a convenient @kbd{s E} command 27473for editing @code{EvalRules}; @pxref{Operations on Variables}. 27474 27475For example, suppose you want @samp{sin(a + b)} to be expanded out 27476to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and 27477similarly for @samp{cos(a + b)}. The corresponding rewrite rule 27478set would be, 27479 27480@smallexample 27481@group 27482[ sin(a + b) := cos(a) sin(b) + sin(a) cos(b), 27483 cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ] 27484@end group 27485@end smallexample 27486 27487To apply these manually, you could put them in a variable called 27488@code{trigexp} and then use @kbd{a r trigexp} every time you wanted 27489to expand trig functions. But if instead you store them in the 27490variable @code{EvalRules}, they will automatically be applied to all 27491sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on 27492the stack, typing @kbd{+ S} will (assuming Degrees mode) result in 27493@samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically. 27494 27495As each level of a formula is evaluated, the rules from 27496@code{EvalRules} are applied before the default simplifications. 27497Rewriting continues until no further @code{EvalRules} apply. 27498Note that this is different from the usual order of application of 27499rewrite rules: @code{EvalRules} works from the bottom up, simplifying 27500the arguments to a function before the function itself, while @kbd{a r} 27501applies rules from the top down. 27502 27503Because the @code{EvalRules} are tried first, you can use them to 27504override the normal behavior of any built-in Calc function. 27505 27506It is important not to write a rule that will get into an infinite 27507loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]} 27508appears to be a good definition of a factorial function, but it is 27509unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc 27510will continue to subtract 1 from this argument forever without reaching 27511zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}. 27512Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting 27513@samp{g(2, 4)}, this would bounce back and forth between that and 27514@samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules} 27515occurs, Emacs will eventually stop with a ``Computation got stuck 27516or ran too long'' message. 27517 27518Another subtle difference between @code{EvalRules} and regular rewrites 27519concerns rules that rewrite a formula into an identical formula. For 27520example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is 27521already an integer. But in @code{EvalRules} this case is detected only 27522if the righthand side literally becomes the original formula before any 27523further simplification. This means that @samp{f(n) := f(floor(n))} will 27524get into an infinite loop if it occurs in @code{EvalRules}. Calc will 27525replace @samp{f(6)} with @samp{f(floor(6))}, which is different from 27526@samp{f(6)}, so it will consider the rule to have matched and will 27527continue simplifying that formula; first the argument is simplified 27528to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))} 27529again, ad infinitum. A much safer rule would check its argument first, 27530say, with @samp{f(n) := f(floor(n)) :: !dint(n)}. 27531 27532(What really happens is that the rewrite mechanism substitutes the 27533meta-variables in the righthand side of a rule, compares to see if the 27534result is the same as the original formula and fails if so, then uses 27535the default simplifications to simplify the result and compares again 27536(and again fails if the formula has simplified back to its original 27537form). The only special wrinkle for the @code{EvalRules} is that the 27538same rules will come back into play when the default simplifications 27539are used. What Calc wants to do is build @samp{f(floor(6))}, see that 27540this is different from the original formula, simplify to @samp{f(6)}, 27541see that this is the same as the original formula, and thus halt the 27542rewriting. But while simplifying, @samp{f(6)} will again trigger 27543the same @code{EvalRules} rule and Calc will get into a loop inside 27544the rewrite mechanism itself.) 27545 27546The @code{phase}, @code{schedule}, and @code{iterations} markers do 27547not work in @code{EvalRules}. If the rule set is divided into phases, 27548only the phase 1 rules are applied, and the schedule is ignored. 27549The rules are always repeated as many times as possible. 27550 27551The @code{EvalRules} are applied to all function calls in a formula, 27552but not to numbers (and other number-like objects like error forms), 27553nor to vectors or individual variable names. (Though they will apply 27554to @emph{components} of vectors and error forms when appropriate.) You 27555might try to make a variable @code{phihat} which automatically expands 27556to its definition without the need to press @kbd{=} by writing the 27557rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule 27558will not work as part of @code{EvalRules}. 27559 27560Finally, another limitation is that Calc sometimes calls its built-in 27561functions directly rather than going through the default simplifications. 27562When it does this, @code{EvalRules} will not be able to override those 27563functions. For example, when you take the absolute value of the complex 27564number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling 27565the multiplication, addition, and square root functions directly rather 27566than applying the default simplifications to this formula. So an 27567@code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6} 27568would not apply. (However, if you put Calc into Symbolic mode so that 27569@samp{sqrt(13)} will be left in symbolic form by the built-in square 27570root function, your rule will be able to apply. But if the complex 27571number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated, 27572then Symbolic mode will not help because @samp{sqrt(25)} can be 27573evaluated exactly to 5.) 27574 27575One subtle restriction that normally only manifests itself with 27576@code{EvalRules} is that while a given rewrite rule is in the process 27577of being checked, that same rule cannot be recursively applied. Calc 27578effectively removes the rule from its rule set while checking the rule, 27579then puts it back once the match succeeds or fails. (The technical 27580reason for this is that compiled pattern programs are not reentrant.) 27581For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0} 27582attempting to match @samp{foo(8)}. This rule will be inactive while 27583the condition @samp{foo(4) > 0} is checked, even though it might be 27584an integral part of evaluating that condition. Note that this is not 27585a problem for the more usual recursive type of rule, such as 27586@samp{foo(x) := foo(x/2)}, because there the rule has succeeded and 27587been reactivated by the time the righthand side is evaluated. 27588 27589If @code{EvalRules} has no stored value (its default state), or if 27590anything but a vector is stored in it, then it is ignored. 27591 27592Even though Calc's rewrite mechanism is designed to compare rewrite 27593rules to formulas as quickly as possible, storing rules in 27594@code{EvalRules} may make Calc run substantially slower. This is 27595particularly true of rules where the top-level call is a commonly used 27596function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will 27597only activate the rewrite mechanism for calls to the function @code{f}, 27598but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator. 27599 27600@smallexample 27601apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10]) 27602@end smallexample 27603 27604@noindent 27605may seem more ``efficient'' than two separate rules for @code{ln} and 27606@code{log10}, but actually it is vastly less efficient because rules 27607with @code{apply} as the top-level pattern must be tested against 27608@emph{every} function call that is simplified. 27609 27610@cindex @code{AlgSimpRules} variable 27611@vindex AlgSimpRules 27612Suppose you want @samp{sin(a + b)} to be expanded out not all the time, 27613but only when algebraic simplifications are used to simplify the 27614formula. The variable @code{AlgSimpRules} holds rules for this purpose. 27615The @kbd{a s} command will apply @code{EvalRules} and 27616@code{AlgSimpRules} to the formula, as well as all of its built-in 27617simplifications. 27618 27619Most of the special limitations for @code{EvalRules} don't apply to 27620@code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules} 27621command with an infinite repeat count as the first step of algebraic 27622simplifications. It then applies its own built-in simplifications 27623throughout the formula, and then repeats these two steps (along with 27624applying the default simplifications) until no further changes are 27625possible. 27626 27627@cindex @code{ExtSimpRules} variable 27628@cindex @code{UnitSimpRules} variable 27629@vindex ExtSimpRules 27630@vindex UnitSimpRules 27631There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables 27632that are used by @kbd{a e} and @kbd{u s}, respectively; these commands 27633also apply @code{EvalRules} and @code{AlgSimpRules}. The variable 27634@code{IntegSimpRules} contains simplification rules that are used 27635only during integration by @kbd{a i}. 27636 27637@node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules 27638@subsection Debugging Rewrites 27639 27640@noindent 27641If a buffer named @file{*Trace*} exists, the rewrite mechanism will 27642record some useful information there as it operates. The original 27643formula is written there, as is the result of each successful rewrite, 27644and the final result of the rewriting. All phase changes are also 27645noted. 27646 27647Calc always appends to @file{*Trace*}. You must empty this buffer 27648yourself periodically if it is in danger of growing unwieldy. 27649 27650Note that the rewriting mechanism is substantially slower when the 27651@file{*Trace*} buffer exists, even if the buffer is not visible on 27652the screen. Once you are done, you will probably want to kill this 27653buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in 27654existence and forget about it, all your future rewrite commands will 27655be needlessly slow. 27656 27657@node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules 27658@subsection Examples of Rewrite Rules 27659 27660@noindent 27661Returning to the example of substituting the pattern 27662@samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule 27663@samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of 27664finding suitable cases. Another solution would be to use the rule 27665@samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification 27666if necessary. This rule will be the most effective way to do the job, 27667but at the expense of making some changes that you might not desire. 27668 27669Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}. 27670To make this work with the @w{@kbd{j r}} command so that it can be 27671easily targeted to a particular exponential in a large formula, 27672you might wish to write the rule as @samp{select(exp(x+y)) := 27673select(exp(x) exp(y))}. The @samp{select} markers will be 27674ignored by the regular @kbd{a r} command 27675(@pxref{Selections with Rewrite Rules}). 27676 27677A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}. 27678This will simplify the formula whenever @expr{b} and/or @expr{c} can 27679be made simpler by squaring. For example, applying this rule to 27680@samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming 27681Symbolic mode has been enabled to keep the square root from being 27682evaluated to a floating-point approximation). This rule is also 27683useful when working with symbolic complex numbers, e.g., 27684@samp{(a + b i) / (c + d i)}. 27685 27686As another example, we could define our own ``triangular numbers'' function 27687with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter 27688this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given 27689a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules} 27690to apply these rules repeatedly. After six applications, @kbd{a r} will 27691stop with 15 on the stack. Once these rules are debugged, it would probably 27692be most useful to add them to @code{EvalRules} so that Calc will evaluate 27693the new @code{tri} function automatically. We could then use @kbd{Z K} on 27694the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies 27695@code{tri} to the value on the top of the stack. @xref{Programming}. 27696 27697@cindex Quaternions 27698The following rule set, contributed by François 27699Pinard, implements @dfn{quaternions}, a generalization of the concept of 27700complex numbers. Quaternions have four components, and are here 27701represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y}, 27702@var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts 27703collected into a vector. Various arithmetical operations on quaternions 27704are supported. To use these rules, either add them to @code{EvalRules}, 27705or create a command based on @kbd{a r} for simplifying quaternion 27706formulas. A convenient way to enter quaternions would be a command 27707defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $]) 27708@key{RET}}. 27709 27710@smallexample 27711[ quat(w, x, y, z) := quat(w, [x, y, z]), 27712 quat(w, [0, 0, 0]) := w, 27713 abs(quat(w, v)) := hypot(w, v), 27714 -quat(w, v) := quat(-w, -v), 27715 r + quat(w, v) := quat(r + w, v) :: real(r), 27716 r - quat(w, v) := quat(r - w, -v) :: real(r), 27717 quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2), 27718 r * quat(w, v) := quat(r * w, r * v) :: real(r), 27719 plain(quat(w1, v1) * quat(w2, v2)) 27720 := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)), 27721 quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r), 27722 z / quat(w, v) := z * quatinv(quat(w, v)), 27723 quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2), 27724 quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v), 27725 quat(w, v)^k := quatsqr(quat(w, v)^(k / 2)) 27726 :: integer(k) :: k > 0 :: k % 2 = 0, 27727 quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v) 27728 :: integer(k) :: k > 2, 27729 quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ] 27730@end smallexample 27731 27732Quaternions, like matrices, have non-commutative multiplication. 27733In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if 27734@expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat} 27735rule above uses @code{plain} to prevent Calc from rearranging the 27736product. It may also be wise to add the line @samp{[quat(), matrix]} 27737to the @code{Decls} matrix, to ensure that Calc's other algebraic 27738operations will not rearrange a quaternion product. @xref{Declarations}. 27739 27740These rules also accept a four-argument @code{quat} form, converting 27741it to the preferred form in the first rule. If you would rather see 27742results in the four-argument form, just append the two items 27743@samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end 27744of the rule set. (But remember that multi-phase rule sets don't work 27745in @code{EvalRules}.) 27746 27747@node Units, Store and Recall, Algebra, Top 27748@chapter Operating on Units 27749 27750@noindent 27751One special interpretation of algebraic formulas is as numbers with units. 27752For example, the formula @samp{5 m / s^2} can be read ``five meters 27753per second squared.'' The commands in this chapter help you 27754manipulate units expressions in this form. Units-related commands 27755begin with the @kbd{u} prefix key. 27756 27757@menu 27758* Basic Operations on Units:: 27759* The Units Table:: 27760* Predefined Units:: 27761* User-Defined Units:: 27762* Logarithmic Units:: 27763* Musical Notes:: 27764@end menu 27765 27766@node Basic Operations on Units, The Units Table, Units, Units 27767@section Basic Operations on Units 27768 27769@noindent 27770A @dfn{units expression} is a formula which is basically a number 27771multiplied and/or divided by one or more @dfn{unit names}, which may 27772optionally be raised to integer powers. Actually, the value part need not 27773be a number; any product or quotient involving unit names is a units 27774expression. Many of the units commands will also accept any formula, 27775where the command applies to all units expressions which appear in the 27776formula. 27777 27778A unit name is a variable whose name appears in the @dfn{unit table}, 27779or a variable whose name is a prefix character like @samp{k} (for ``kilo'') 27780or @samp{u} (for ``micro'') followed by a name in the unit table. 27781A substantial table of built-in units is provided with Calc; 27782@pxref{Predefined Units}. You can also define your own unit names; 27783@pxref{User-Defined Units}. 27784 27785Note that if the value part of a units expression is exactly @samp{1}, 27786it will be removed by the Calculator's automatic algebra routines: The 27787formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a 27788display anomaly, however; @samp{mm} will work just fine as a 27789representation of one millimeter. 27790 27791You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working 27792with units expressions easier. Otherwise, you will have to remember 27793to hit the apostrophe key every time you wish to enter units. 27794 27795@kindex u s 27796@pindex calc-simplify-units 27797@ignore 27798@mindex usimpl@idots 27799@end ignore 27800@tindex usimplify 27801The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command 27802simplifies a units 27803expression. It uses Calc's algebraic simplifications to simplify the 27804expression first as a regular algebraic formula; it then looks for 27805features that can be further simplified by converting one object's units 27806to be compatible with another's. For example, @samp{5 m + 23 mm} will 27807simplify to @samp{5.023 m}. When different but compatible units are 27808added, the righthand term's units are converted to match those of the 27809lefthand term. @xref{Simplification Modes}, for a way to have this done 27810automatically at all times. 27811 27812Units simplification also handles quotients of two units with the same 27813dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional 27814powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and 27815@samp{sqrt(9 acre)} to a quantity in meters; and @code{floor}, 27816@code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc}, 27817@code{float}, @code{frac}, @code{abs}, and @code{clean} 27818applied to units expressions, in which case 27819the operation in question is applied only to the numeric part of the 27820expression. Finally, trigonometric functions of quantities with units 27821of angle are evaluated, regardless of the current angular mode. 27822 27823@kindex u c 27824@pindex calc-convert-units 27825The @kbd{u c} (@code{calc-convert-units}) command converts a units 27826expression to new, compatible units. For example, given the units 27827expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces 27828@samp{24.5872 m/s}. If you have previously converted a units expression 27829with the same type of units (in this case, distance over time), you will 27830be offered the previous choice of new units as a default. Continuing 27831the above example, entering the units expression @samp{100 km/hr} and 27832typing @kbd{u c @key{RET}} (without specifying new units) produces 27833@samp{27.7777777778 m/s}. 27834 27835@kindex u t 27836@pindex calc-convert-temperature 27837@cindex Temperature conversion 27838The @kbd{u c} command treats temperature units (like @samp{degC} and 27839@samp{K}) as relative temperatures. For example, @kbd{u c} converts 27840@samp{10 degC} to @samp{18 degF}: A change of 10 degrees Celsius 27841corresponds to a change of 18 degrees Fahrenheit. To convert absolute 27842temperatures, you can use the @kbd{u t} 27843(@code{calc-convert-temperature}) command. The value on the stack 27844must be a simple units expression with units of temperature only. 27845This command would convert @samp{10 degC} to @samp{50 degF}, the 27846equivalent temperature on the Fahrenheit scale. 27847 27848While many of Calc's conversion factors are exact, some are necessarily 27849approximate. If Calc is in fraction mode (@pxref{Fraction Mode}), then 27850unit conversions will try to give exact, rational conversions, but it 27851isn't always possible. Given @samp{55 mph} in fraction mode, typing 27852@kbd{u c m/s @key{RET}} produces @samp{15367:625 m/s}, for example, 27853while typing @kbd{u c au/yr @key{RET}} produces 27854@samp{5.18665819999e-3 au/yr}. 27855 27856If the units you request are inconsistent with the original units, the 27857number will be converted into your units times whatever ``remainder'' 27858units are left over. For example, converting @samp{55 mph} into acres 27859produces @samp{6.08e-3 acre / (m s)}. Remainder units are expressed in terms of 27860``fundamental'' units like @samp{m} and @samp{s}, regardless of the 27861input units. 27862 27863@kindex u n 27864@pindex calc-convert-exact-units 27865If you intend that your new units be consistent with the original 27866units, the @kbd{u n} (@code{calc-convert-exact-units}) command will 27867check the units before the conversion. For example, to change 27868@samp{mi/hr} to @samp{km/hr}, you could type @kbd{u c km @key{RET}}, 27869but @kbd{u n km @key{RET}} would signal an error. 27870You would need to type @kbd{u n km/hr @key{RET}}. 27871 27872One special exception is that if you specify a single unit name, and 27873a compatible unit appears somewhere in the units expression, then 27874that compatible unit will be converted to the new unit and the 27875remaining units in the expression will be left alone. For example, 27876given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will 27877change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}. 27878The ``remainder unit'' @samp{cm} is left alone rather than being 27879changed to the base unit @samp{m}. 27880 27881You can use explicit unit conversion instead of the @kbd{u s} command 27882to gain more control over the units of the result of an expression. 27883For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or 27884@kbd{u c mm} to express the result in either meters or millimeters. 27885(For that matter, you could type @kbd{u c fath} to express the result 27886in fathoms, if you preferred!) 27887 27888In place of a specific set of units, you can also enter one of the 27889units system names @code{si}, @code{mks} (equivalent), or @code{cgs}. 27890For example, @kbd{u c si @key{RET}} converts the expression into 27891International System of Units (SI) base units. Also, @kbd{u c base} 27892converts to Calc's base units, which are the same as @code{si} units 27893except that @code{base} uses @samp{g} as the fundamental unit of mass 27894whereas @code{si} uses @samp{kg}. 27895 27896@cindex Composite units 27897The @kbd{u c} command also accepts @dfn{composite units}, which 27898are expressed as the sum of several compatible unit names. For 27899example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles, 27900feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first 27901sorts the unit names into order of decreasing relative size. 27902It then accounts for as much of the input quantity as it can 27903using an integer number times the largest unit, then moves on 27904to the next smaller unit, and so on. Only the smallest unit 27905may have a non-integer amount attached in the result. A few 27906standard unit names exist for common combinations, such as 27907@code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}. 27908Composite units are expanded as if by @kbd{a x}, so that 27909@samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}. 27910 27911If the value on the stack does not contain any units, @kbd{u c} will 27912prompt first for the old units which this value should be considered 27913to have, then for the new units. (If the value on the stack can be 27914simplified so that it doesn't contain any units, like @samp{ft/in} can 27915be simplified to 12, then @kbd{u c} will still prompt for both old 27916units and new units. Assuming the old and new units you give are 27917consistent with each other, the result also will not contain any 27918units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts 27919the number 2 on the stack to 5.08. 27920 27921@kindex u b 27922@pindex calc-base-units 27923The @kbd{u b} (@code{calc-base-units}) command is shorthand for 27924@kbd{u c base}; it converts the units expression on the top of the 27925stack into @code{base} units. If @kbd{u s} does not simplify a 27926units expression as far as you would like, try @kbd{u b}. 27927 27928Like the @kbd{u c} command, the @kbd{u b} command treats temperature 27929units as relative temperatures. 27930 27931@kindex u r 27932@pindex calc-remove-units 27933@kindex u x 27934@pindex calc-extract-units 27935The @kbd{u r} (@code{calc-remove-units}) command removes units from the 27936formula at the top of the stack. The @kbd{u x} 27937(@code{calc-extract-units}) command extracts only the units portion of a 27938formula. These commands essentially replace every term of the formula 27939that does or doesn't (respectively) look like a unit name by the 27940constant 1, then resimplify the formula. 27941 27942@kindex u a 27943@pindex calc-autorange-units 27944The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a 27945mode in which unit prefixes like @code{k} (``kilo'') are automatically 27946applied to keep the numeric part of a units expression in a reasonable 27947range. This mode affects @kbd{u s} and all units conversion commands 27948except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz} 27949will be simplified to @samp{12.345 kHz}. Autoranging is useful for 27950some kinds of units (like @code{Hz} and @code{m}), but is probably 27951undesirable for non-metric units like @code{ft} and @code{tbsp}. 27952(Composite units are more appropriate for those; see above.) 27953 27954Autoranging always applies the prefix to the leftmost unit name. 27955Calc chooses the largest prefix that causes the number to be greater 27956than or equal to 1.0. Thus an increasing sequence of adjusted times 27957would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}. 27958Generally the rule of thumb is that the number will be adjusted 27959to be in the interval @samp{[1 .. 1000)}, although there are several 27960exceptions to this rule. First, if the unit has a power then this 27961is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}. 27962Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters), 27963but will not apply to other units. The ``deci-,'' ``deka-,'' and 27964``hecto-'' prefixes are never used. Thus the allowable interval is 27965@samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters. 27966Finally, a prefix will not be added to a unit if the resulting name 27967is also the actual name of another unit; @samp{1e-15 t} would normally 27968be considered a ``femto-ton,'' but it is written as @samp{1000 at} 27969(1000 atto-tons) instead because @code{ft} would be confused with feet. 27970 27971@node The Units Table, Predefined Units, Basic Operations on Units, Units 27972@section The Units Table 27973 27974@noindent 27975@kindex u v 27976@pindex calc-enter-units-table 27977The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table 27978in another buffer called @file{*Units Table*}. Each entry in this table 27979gives the unit name as it would appear in an expression, the definition 27980of the unit in terms of simpler units, and a full name or description of 27981the unit. Fundamental units are defined as themselves; these are the 27982units produced by the @kbd{u b} command. The fundamental units are 27983meters, seconds, grams, kelvins, amperes, candelas, moles, radians, 27984and steradians. 27985 27986The Units Table buffer also displays the Unit Prefix Table. Note that 27987two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case 27988prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M} 27989prefix. Whenever a unit name can be interpreted as either a built-in name 27990or a prefix followed by another built-in name, the former interpretation 27991wins. For example, @samp{2 pt} means two pints, not two pico-tons. 27992 27993The Units Table buffer, once created, is not rebuilt unless you define 27994new units. To force the buffer to be rebuilt, give any numeric prefix 27995argument to @kbd{u v}. 27996 27997@kindex u V 27998@pindex calc-view-units-table 27999The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except 28000that the cursor is not moved into the Units Table buffer. You can 28001type @kbd{u V} again to remove the Units Table from the display. To 28002return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c} 28003again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window}) 28004command. You can also kill the buffer with @kbd{C-x k} if you wish; 28005the actual units table is safely stored inside the Calculator. 28006 28007@kindex u g 28008@pindex calc-get-unit-definition 28009The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's 28010defining expression and pushes it onto the Calculator stack. For example, 28011@kbd{u g in} will produce the expression @samp{2.54 cm}. This is the 28012same definition for the unit that would appear in the Units Table buffer. 28013Note that this command works only for actual unit names; @kbd{u g km} 28014will report that no such unit exists, for example, because @code{km} is 28015really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a 28016definition of a unit in terms of base units, it is easier to push the 28017unit name on the stack and then reduce it to base units with @kbd{u b}. 28018 28019@kindex u e 28020@pindex calc-explain-units 28021The @kbd{u e} (@code{calc-explain-units}) command displays an English 28022description of the units of the expression on the stack. For example, 28023for the expression @samp{62 km^2 g / s^2 mol K}, the description is 28024``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This 28025command uses the English descriptions that appear in the righthand 28026column of the Units Table. 28027 28028@node Predefined Units, User-Defined Units, The Units Table, Units 28029@section Predefined Units 28030 28031@noindent 28032The definitions of many units have changed over the years. For example, 28033the meter was originally defined in 1791 as one ten-millionth of the 28034distance from the Equator to the North Pole. In order to be more 28035precise, the definition was adjusted several times, and now a meter is 28036defined as the distance that light will travel in a vacuum in 280371/299792458 of a second; consequently, the speed of light in a 28038vacuum is exactly 299792458 m/s. Many other units have been 28039redefined in terms of fundamental physical processes; a second, for 28040example, is currently defined as 9192631770 periods of a certain 28041radiation related to the cesium-133 atom. The only SI unit that is not 28042based on a fundamental physical process (although there are efforts to 28043change this) is the kilogram, which was originally defined as the mass 28044of one liter of water, but is now defined as the mass of the 28045international prototype of the kilogram (IPK), a cylinder of platinum-iridium 28046kept at the Bureau international des poids et mesures in Sèvres, 28047France. (There are several copies of the IPK throughout the world.) 28048The British imperial units, once defined in terms of physical objects, 28049were redefined in 1963 in terms of SI units. The US customary units, 28050which were the same as British units until the British imperial system 28051was created in 1824, were also defined in terms of the SI units in 1893. 28052Because of these redefinitions, conversions between metric, British 28053Imperial, and US customary units can often be done precisely. 28054 28055Since the exact definitions of many kinds of units have evolved over the 28056years, and since certain countries sometimes have local differences in 28057their definitions, it is a good idea to examine Calc's definition of a 28058unit before depending on its exact value. For example, there are three 28059different units for gallons, corresponding to the US (@code{gal}), 28060Canadian (@code{galC}), and British (@code{galUK}) definitions. Also, 28061note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy 28062ounce, and @code{ozfl} is a fluid ounce. 28063 28064The temperature units corresponding to degrees Kelvin and Centigrade 28065(Celsius) are the same in this table, since most units commands treat 28066temperatures as being relative. The @code{calc-convert-temperature} 28067command has special rules for handling the different absolute magnitudes 28068of the various temperature scales. 28069 28070The unit of volume ``liters'' can be referred to by either the lower-case 28071@code{l} or the upper-case @code{L}. 28072 28073The unit @code{A} stands for amperes; the name @code{Ang} is used 28074for angstroms. 28075 28076The unit @code{pt} stands for pints; the name @code{point} stands for 28077a typographical point, defined by @samp{72 point = 1 in}. This is 28078slightly different from the point defined by the American Typefounder's 28079Association in 1886, but the point used by Calc has become standard 28080largely due to its use by the PostScript page description language. 28081There is also @code{texpt}, which stands for a printer's point as 28082defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}. 28083Other units used by @TeX{} are available; they are @code{texpc} (a pica), 28084@code{texbp} (a ``big point'', equal to a standard point which is larger 28085than the point used by @TeX{}), @code{texdd} (a Didot point), 28086@code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point, 28087all dimensions representable in @TeX{} are multiples of this value). 28088 28089When Calc is using the @TeX{} or @LaTeX{} language mode (@pxref{TeX 28090and LaTeX Language Modes}), the @TeX{} specific unit names will not 28091use the @samp{tex} prefix; the unit name for a @TeX{} point will be 28092@samp{pt} instead of @samp{texpt}, for example. To avoid conflicts, 28093the unit names for pint and parsec will simply be @samp{pint} and 28094@samp{parsec} instead of @samp{pt} and @samp{pc}. 28095 28096The unit @code{e} stands for the elementary (electron) unit of charge; 28097because algebra command could mistake this for the special constant 28098@expr{e}, Calc provides the alternate unit name @code{ech} which is 28099preferable to @code{e}. 28100 28101The name @code{g} stands for one gram of mass; there is also @code{gf}, 28102one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.) 28103Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}. 28104 28105The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is 28106a metric ton of @samp{1000 kg}. 28107 28108The names @code{s} (or @code{sec}) and @code{min} refer to units of 28109time; @code{arcsec} and @code{arcmin} are units of angle. 28110 28111Some ``units'' are really physical constants; for example, @code{c} 28112represents the speed of light, and @code{h} represents Planck's 28113constant. You can use these just like other units: converting 28114@samp{.5 c} to @samp{m/s} expresses one-half the speed of light in 28115meters per second. You can also use this merely as a handy reference; 28116the @kbd{u g} command gets the definition of one of these constants 28117in its normal terms, and @kbd{u b} expresses the definition in base 28118units. 28119 28120Two units, @code{pi} and @code{alpha} (the fine structure constant, 28121approximately @mathit{1/137}) are dimensionless. The units simplification 28122commands simply treat these names as equivalent to their corresponding 28123values. However you can, for example, use @kbd{u c} to convert a pure 28124number into multiples of the fine structure constant, or @kbd{u b} to 28125convert this back into a pure number. (When @kbd{u c} prompts for the 28126``old units,'' just enter a blank line to signify that the value 28127really is unitless.) 28128 28129@c Describe angular units, luminosity vs. steradians problem. 28130 28131@node User-Defined Units, Logarithmic Units, Predefined Units, Units 28132@section User-Defined Units 28133 28134@noindent 28135Calc provides ways to get quick access to your selected ``favorite'' 28136units, as well as ways to define your own new units. 28137 28138@kindex u 0-9 28139@pindex calc-quick-units 28140@vindex Units 28141@cindex @code{Units} variable 28142@cindex Quick units 28143To select your favorite units, store a vector of unit names or 28144expressions in the Calc variable @code{Units}. The @kbd{u 1} 28145through @kbd{u 9} commands (@code{calc-quick-units}) provide access 28146to these units. If the value on the top of the stack is a plain 28147number (with no units attached), then @kbd{u 1} gives it the 28148specified units. (Basically, it multiplies the number by the 28149first item in the @code{Units} vector.) If the number on the 28150stack @emph{does} have units, then @kbd{u 1} converts that number 28151to the new units. For example, suppose the vector @samp{[in, ft]} 28152is stored in @code{Units}. Then @kbd{30 u 1} will create the 28153expression @samp{30 in}, and @kbd{u 2} will convert that expression 28154to @samp{2.5 ft}. 28155 28156The @kbd{u 0} command accesses the tenth element of @code{Units}. 28157Only ten quick units may be defined at a time. If the @code{Units} 28158variable has no stored value (the default), or if its value is not 28159a vector, then the quick-units commands will not function. The 28160@kbd{s U} command is a convenient way to edit the @code{Units} 28161variable; @pxref{Operations on Variables}. 28162 28163@kindex u d 28164@pindex calc-define-unit 28165@cindex User-defined units 28166The @kbd{u d} (@code{calc-define-unit}) command records the units 28167expression on the top of the stack as the definition for a new, 28168user-defined unit. For example, putting @samp{16.5 ft} on the stack and 28169typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to 2817016.5 feet. The unit conversion and simplification commands will now 28171treat @code{rod} just like any other unit of length. You will also be 28172prompted for an optional English description of the unit, which will 28173appear in the Units Table. If you wish the definition of this unit to 28174be displayed in a special way in the Units Table buffer (such as with an 28175asterisk to indicate an approximate value), then you can call this 28176command with an argument, @kbd{C-u u d}; you will then also be prompted 28177for a string that will be used to display the definition. 28178 28179@kindex u u 28180@pindex calc-undefine-unit 28181The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined 28182unit. It is not possible to remove one of the predefined units, 28183however. 28184 28185If you define a unit with an existing unit name, your new definition 28186will replace the original definition of that unit. If the unit was a 28187predefined unit, the old definition will not be replaced, only 28188``shadowed.'' The built-in definition will reappear if you later use 28189@kbd{u u} to remove the shadowing definition. 28190 28191To create a new fundamental unit, use either 1 or the unit name itself 28192as the defining expression. Otherwise the expression can involve any 28193other units that you like (except for composite units like @samp{mfi}). 28194You can create a new composite unit with a sum of other units as the 28195defining expression. The next unit operation like @kbd{u c} or @kbd{u v} 28196will rebuild the internal unit table incorporating your modifications. 28197Note that erroneous definitions (such as two units defined in terms of 28198each other) will not be detected until the unit table is next rebuilt; 28199@kbd{u v} is a convenient way to force this to happen. 28200 28201Temperature units are treated specially inside the Calculator; it is not 28202possible to create user-defined temperature units. 28203 28204@kindex u p 28205@pindex calc-permanent-units 28206@cindex Calc init file, user-defined units 28207The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined 28208units in your Calc init file (the file given by the variable 28209@code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so that the 28210units will still be available in subsequent Emacs sessions. If there 28211was already a set of user-defined units in your Calc init file, it 28212is replaced by the new set. (@xref{General Mode Commands}, for a way to 28213tell Calc to use a different file for the Calc init file.) 28214 28215@node Logarithmic Units, Musical Notes, User-Defined Units, Units 28216@section Logarithmic Units 28217 28218The units @code{dB} (decibels) and @code{Np} (nepers) are logarithmic 28219units which are manipulated differently than standard units. Calc 28220provides commands to work with these logarithmic units. 28221 28222Decibels and nepers are used to measure power quantities as well as 28223field quantities (quantities whose squares are proportional to power); 28224these two types of quantities are handled slightly different from each 28225other. By default the Calc commands work as if power quantities are 28226being used; with the @kbd{H} prefix the Calc commands work as if field 28227quantities are being used. 28228 28229The decibel level of a power 28230@infoline @math{P1}, 28231@texline @math{P_1}, 28232relative to a reference power 28233@infoline @math{P0}, 28234@texline @math{P_0}, 28235is defined to be 28236@infoline @math{10 log10(P1/P0) dB}. 28237@texline @math{10 \log_{10}(P_{1}/P_{0}) {\rm dB}}. 28238(The factor of 10 is because a decibel, as its name implies, is 28239one-tenth of a bel. The bel, named after Alexander Graham Bell, was 28240considered to be too large of a unit and was effectively replaced by 28241the decibel.) If @math{F} is a field quantity with power 28242@math{P=k F^2}, then a reference quantity of 28243@infoline @math{F0} 28244@texline @math{F_0} 28245would correspond to a power of 28246@infoline @math{P0=k F0^2}. 28247@texline @math{P_{0}=kF_{0}^2}. 28248If 28249@infoline @math{P1=k F1^2}, 28250@texline @math{P_{1}=kF_{1}^2}, 28251then 28252 28253@ifnottex 28254@example 2825510 log10(P1/P0) = 10 log10(F1^2/F0^2) = 20 log10(F1/F0). 28256@end example 28257@end ifnottex 28258@tex 28259$$ 10 \log_{10}(P_1/P_0) = 10 \log_{10}(F_1^2/F_0^2) = 20 28260\log_{10}(F_1/F_0)$$ 28261@end tex 28262 28263@noindent 28264In order to get the same decibel level regardless of whether a field 28265quantity or the corresponding power quantity is used, the decibel 28266level of a field quantity 28267@infoline @math{F1}, 28268@texline @math{F_1}, 28269relative to a reference 28270@infoline @math{F0}, 28271@texline @math{F_0}, 28272is defined as 28273@infoline @math{20 log10(F1/F0) dB}. 28274@texline @math{20 \log_{10}(F_{1}/F_{0}) {\rm dB}}. 28275For example, the decibel value of a sound pressure level of 28276@infoline @math{60 uPa} 28277@texline @math{60 \mu{\rm Pa}} 28278relative to 28279@infoline @math{20 uPa} 28280@texline @math{20 \mu{\rm Pa}} 28281(the threshold of human hearing) is 28282@infoline @math{20 log10(60 uPa/ 20 uPa) dB = 20 log10(3) dB}, 28283@texline @math{20 \log_{10}(60 \mu{\rm Pa}/20 \mu{\rm Pa}) {\rm dB} = 20 \log_{10}(3) {\rm dB}}, 28284which is about 28285@infoline @math{9.54 dB}. 28286@texline @math{9.54 {\rm dB}}. 28287Note that in taking the ratio, the original units cancel and so these 28288logarithmic units are dimensionless. 28289 28290Nepers (named after John Napier, who is credited with inventing the 28291logarithm) are similar to bels except they use natural logarithms instead 28292of common logarithms. The neper level of a power 28293@infoline @math{P1}, 28294@texline @math{P_1}, 28295relative to a reference power 28296@infoline @math{P0}, 28297@texline @math{P_0}, 28298is 28299@infoline @math{(1/2) ln(P1/P0) Np}. 28300@texline @math{(1/2) \ln(P_1/P_0) {\rm Np}}. 28301The neper level of a field 28302@infoline @math{F1}, 28303@texline @math{F_1}, 28304relative to a reference field 28305@infoline @math{F0}, 28306@texline @math{F_0}, 28307is 28308@infoline @math{ln(F1/F0) Np}. 28309@texline @math{\ln(F_1/F_0) {\rm Np}}. 28310 28311@vindex calc-lu-power-reference 28312@vindex calc-lu-field-reference 28313For power quantities, Calc uses 28314@infoline @math{1 mW} 28315@texline @math{1 {\rm mW}} 28316as the default reference quantity; this default can be changed by changing 28317the value of the customizable variable 28318@code{calc-lu-power-reference} (@pxref{Customizing Calc}). 28319For field quantities, Calc uses 28320@infoline @math{20 uPa} 28321@texline @math{20 \mu{\rm Pa}} 28322as the default reference quantity; this is the value used in acoustics 28323which is where decibels are commonly encountered. This default can be 28324changed by changing the value of the customizable variable 28325@code{calc-lu-field-reference} (@pxref{Customizing Calc}). A 28326non-default reference quantity will be read from the stack if the 28327capital @kbd{O} prefix is used. 28328 28329@kindex l q 28330@pindex calc-lu-quant 28331@tindex lupquant 28332@tindex lufquant 28333The @kbd{l q} (@code{calc-lu-quant}) [@code{lupquant}] 28334command computes the power quantity corresponding to a given number of 28335logarithmic units. With the capital @kbd{O} prefix, @kbd{O l q}, the 28336reference level will be read from the top of the stack. (In an 28337algebraic formula, @code{lupquant} can be given an optional second 28338argument which will be used for the reference level.) For example, 28339@code{20 dB @key{RET} l q} will return @code{100 mW}; 28340@code{20 dB @key{RET} 4 W @key{RET} O l q} will return @code{400 W}. 28341The @kbd{H l q} [@code{lufquant}] command behaves like @kbd{l q} but 28342computes field quantities instead of power quantities. 28343 28344@kindex l d 28345@pindex calc-db 28346@tindex dbpower 28347@tindex dbfield 28348@kindex l n 28349@pindex calc-np 28350@tindex nppower 28351@tindex npfield 28352The @kbd{l d} (@code{calc-db}) [@code{dbpower}] command will compute 28353the decibel level of a power quantity using the default reference 28354level; @kbd{H l d} [@code{dbfield}] will compute the decibel level of 28355a field quantity. The commands @kbd{l n} (@code{calc-np}) 28356[@code{nppower}] and @kbd{H l n} [@code{npfield}] will similarly 28357compute neper levels. With the capital @kbd{O} prefix these commands 28358will read a reference level from the stack; in an algebraic formula 28359the reference level can be given as an optional second argument. 28360 28361@kindex l + 28362@pindex calc-lu-plus 28363@tindex lupadd 28364@tindex lufadd 28365@kindex l - 28366@pindex calc-lu-minus 28367@tindex lupsub 28368@tindex lufsub 28369@kindex l * 28370@pindex calc-lu-times 28371@tindex lupmul 28372@tindex lufmul 28373@kindex l / 28374@pindex calc-lu-divide 28375@tindex lupdiv 28376@tindex lufdiv 28377The sum of two power or field quantities doesn't correspond to the sum 28378of the corresponding decibel or neper levels. If the powers 28379corresponding to decibel levels 28380@infoline @math{D1} 28381@texline @math{D_1} 28382and 28383@infoline @math{D2} 28384@texline @math{D_2} 28385are added, the corresponding decibel level ``sum'' will be 28386 28387@ifnottex 28388@example 28389 10 log10(10^(D1/10) + 10^(D2/10)) dB. 28390@end example 28391@end ifnottex 28392@tex 28393$$ 10 \log_{10}(10^{D_1/10} + 10^{D_2/10}) {\rm dB}.$$ 28394@end tex 28395 28396@noindent 28397When field quantities are combined, it often means the corresponding 28398powers are added and so the above formula might be used. In 28399acoustics, for example, the sound pressure level is a field quantity 28400and so the decibels are often defined using the field formula, but the 28401sound pressure levels are combined as the sound power levels, and so 28402the above formula should be used. If two field quantities themselves 28403are added, the new decibel level will be 28404 28405@ifnottex 28406@example 28407 20 log10(10^(D1/20) + 10^(D2/20)) dB. 28408@end example 28409@end ifnottex 28410@tex 28411$$ 20 \log_{10}(10^{D_1/20} + 10^{D_2/20}) {\rm dB}.$$ 28412@end tex 28413 28414@noindent 28415If the power corresponding to @math{D} dB is multiplied by a number @math{N}, 28416then the corresponding decibel level will be 28417 28418@ifnottex 28419@example 28420 D + 10 log10(N) dB, 28421@end example 28422@end ifnottex 28423@tex 28424$$ D + 10 \log_{10}(N) {\rm dB},$$ 28425@end tex 28426 28427@noindent 28428if a field quantity is multiplied by @math{N} the corresponding decibel level 28429will be 28430 28431@ifnottex 28432@example 28433 D + 20 log10(N) dB. 28434@end example 28435@end ifnottex 28436@tex 28437$$ D + 20 \log_{10}(N) {\rm dB}.$$ 28438@end tex 28439 28440@noindent 28441There are similar formulas for combining nepers. The @kbd{l +} 28442(@code{calc-lu-plus}) [@code{lupadd}] command will ``add'' two 28443logarithmic unit power levels this way; with the @kbd{H} prefix, 28444@kbd{H l +} [@code{lufadd}] will add logarithmic unit field levels. 28445Similarly, logarithmic units can be ``subtracted'' with @kbd{l -} 28446(@code{calc-lu-minus}) [@code{lupsub}] or @kbd{H l -} [@code{lufsub}]. 28447The @kbd{l *} (@code{calc-lu-times}) [@code{lupmul}] and @kbd{H l *} 28448[@code{lufmul}] commands will ``multiply'' a logarithmic unit by a 28449number; the @kbd{l /} (@code{calc-lu-divide}) [@code{lupdiv}] and 28450@kbd{H l /} [@code{lufdiv}] commands will ``divide'' a logarithmic 28451unit by a number. Note that the reference quantities don't play a role 28452in this arithmetic. 28453 28454@node Musical Notes, , Logarithmic Units, Units 28455@section Musical Notes 28456 28457Calc can convert between musical notes and their associated 28458frequencies. Notes can be given using either scientific pitch 28459notation or midi numbers. Since these note systems are basically 28460logarithmic scales, Calc uses the @kbd{l} prefix for functions 28461operating on notes. 28462 28463Scientific pitch notation refers to a note by giving a letter 28464A through G, possibly followed by a flat or sharp) with a subscript 28465indicating an octave number. Each octave starts with C and ends with 28466B and 28467@c increasing each note by a semitone will result 28468@c in the sequence @expr{C}, @expr{C} sharp, @expr{D}, @expr{E} flat, @expr{E}, 28469@c @expr{F}, @expr{F} sharp, @expr{G}, @expr{A} flat, @expr{A}, @expr{B} 28470@c flat and @expr{B}. 28471the octave numbered 0 was chosen to correspond to the lowest 28472audible frequency. Using this system, middle C (about 261.625 Hz) 28473corresponds to the note @expr{C} in octave 4 and is denoted 28474@expr{C_4}. Any frequency can be described by giving a note plus an 28475offset in cents (where a cent is a ratio of frequencies so that a 28476semitone consists of 100 cents). 28477 28478The midi note number system assigns numbers to notes so that 28479@expr{C_(-1)} corresponds to the midi note number 0 and @expr{G_9} 28480corresponds to the midi note number 127. A midi controller can have 28481up to 128 keys and each midi note number from 0 to 127 corresponds to 28482a possible key. 28483 28484@kindex l s 28485@pindex calc-spn 28486@tindex spn 28487The @kbd{l s} (@code{calc-spn}) [@code{spn}] command converts either 28488a frequency or a midi number to scientific pitch notation. For 28489example, @code{500 Hz} gets converted to 28490@code{B_4 + 21.3094853649 cents} and @code{84} to @code{C_6}. 28491 28492@kindex l m 28493@pindex calc-midi 28494@tindex midi 28495The @kbd{l m} (@code{calc-midi}) [@code{midi}] command converts either 28496a frequency or a note given in scientific pitch notation to the 28497corresponding midi number. For example, @code{C_6} gets converted to 84 28498and @code{440 Hz} to 69. 28499 28500@kindex l f 28501@pindex calc-freq 28502@tindex freq 28503The @kbd{l f} (@code{calc-freq}) [@code{freq}] command converts either 28504either a midi number or a note given in scientific pitch notation to 28505the corresponding frequency. For example, @code{Asharp_2 + 30 cents} 28506gets converted to @code{118.578040134 Hz} and @code{55} to 28507@code{195.99771799 Hz}. 28508 28509Since the frequencies of notes are not usually given exactly (and are 28510typically irrational), the customizable variable 28511@code{calc-note-threshold} determines how close (in cents) a frequency 28512needs to be to a note to be recognized as that note 28513(@pxref{Customizing Calc}). This variable has a default value of 28514@code{1}. For example, middle @var{C} is approximately 28515@expr{261.625565302 Hz}; this frequency is often shortened to 28516@expr{261.625 Hz}. Without @code{calc-note-threshold} (or a value of 28517@expr{0}), Calc would convert @code{261.625 Hz} to scientific pitch 28518notation @code{B_3 + 99.9962592773 cents}; with the default value of 28519@code{1}, Calc converts @code{261.625 Hz} to @code{C_4}. 28520 28521 28522@node Store and Recall, Graphics, Units, Top 28523@chapter Storing and Recalling 28524 28525@noindent 28526Calculator variables are really just Lisp variables that contain numbers 28527or formulas in a form that Calc can understand. The commands in this 28528section allow you to manipulate variables conveniently. Commands related 28529to variables use the @kbd{s} prefix key. 28530 28531@menu 28532* Storing Variables:: 28533* Recalling Variables:: 28534* Operations on Variables:: 28535* Let Command:: 28536* Evaluates-To Operator:: 28537@end menu 28538 28539@node Storing Variables, Recalling Variables, Store and Recall, Store and Recall 28540@section Storing Variables 28541 28542@noindent 28543@kindex s s 28544@pindex calc-store 28545@cindex Storing variables 28546@cindex Quick variables 28547@vindex q0 28548@vindex q9 28549The @kbd{s s} (@code{calc-store}) command stores the value at the top of 28550the stack into a specified variable. It prompts you to enter the 28551name of the variable. If you press a single digit, the value is stored 28552immediately in one of the ``quick'' variables @code{q0} through 28553@code{q9}. Or you can enter any variable name. 28554 28555@kindex s t 28556@pindex calc-store-into 28557The @kbd{s s} command leaves the stored value on the stack. There is 28558also an @kbd{s t} (@code{calc-store-into}) command, which removes a 28559value from the stack and stores it in a variable. 28560 28561If the top of stack value is an equation @samp{a = 7} or assignment 28562@samp{a := 7} with a variable on the lefthand side, then Calc will 28563assign that variable with that value by default, i.e., if you type 28564@kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the 28565value 7 would be stored in the variable @samp{a}. (If you do type 28566a variable name at the prompt, the top-of-stack value is stored in 28567its entirety, even if it is an equation: @samp{s s b @key{RET}} 28568with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.) 28569 28570In fact, the top of stack value can be a vector of equations or 28571assignments with different variables on their lefthand sides; the 28572default will be to store all the variables with their corresponding 28573righthand sides simultaneously. 28574 28575It is also possible to type an equation or assignment directly at 28576the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}. 28577In this case the expression to the right of the @kbd{=} or @kbd{:=} 28578symbol is evaluated as if by the @kbd{=} command, and that value is 28579stored in the variable. No value is taken from the stack; @kbd{s s} 28580and @kbd{s t} are equivalent when used in this way. 28581 28582@kindex s 0-9 28583@kindex t 0-9 28584The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a 28585digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is 28586equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used 28587for trail and time/date commands.) 28588 28589@kindex s + 28590@kindex s - 28591@ignore 28592@mindex @idots 28593@end ignore 28594@kindex s * 28595@ignore 28596@mindex @null 28597@end ignore 28598@kindex s / 28599@ignore 28600@mindex @null 28601@end ignore 28602@kindex s ^ 28603@ignore 28604@mindex @null 28605@end ignore 28606@kindex s | 28607@ignore 28608@mindex @null 28609@end ignore 28610@kindex s n 28611@ignore 28612@mindex @null 28613@end ignore 28614@kindex s & 28615@ignore 28616@mindex @null 28617@end ignore 28618@kindex s [ 28619@ignore 28620@mindex @null 28621@end ignore 28622@kindex s ] 28623@pindex calc-store-plus 28624@pindex calc-store-minus 28625@pindex calc-store-times 28626@pindex calc-store-div 28627@pindex calc-store-power 28628@pindex calc-store-concat 28629@pindex calc-store-neg 28630@pindex calc-store-inv 28631@pindex calc-store-decr 28632@pindex calc-store-incr 28633There are also several ``arithmetic store'' commands. For example, 28634@kbd{s +} removes a value from the stack and adds it to the specified 28635variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /}, 28636@kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and 28637@kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}} 28638and @kbd{s ]} which decrease or increase a variable by one. 28639 28640All the arithmetic stores accept the Inverse prefix to reverse the 28641order of the operands. If @expr{v} represents the contents of the 28642variable, and @expr{a} is the value drawn from the stack, then regular 28643@w{@kbd{s -}} assigns 28644@texline @math{v \coloneq v - a}, 28645@infoline @expr{v := v - a}, 28646but @kbd{I s -} assigns 28647@texline @math{v \coloneq a - v}. 28648@infoline @expr{v := a - v}. 28649While @kbd{I s *} might seem pointless, it is 28650useful if matrix multiplication is involved. Actually, all the 28651arithmetic stores use formulas designed to behave usefully both 28652forwards and backwards: 28653 28654@example 28655@group 28656s + v := v + a v := a + v 28657s - v := v - a v := a - v 28658s * v := v * a v := a * v 28659s / v := v / a v := a / v 28660s ^ v := v ^ a v := a ^ v 28661s | v := v | a v := a | v 28662s n v := v / (-1) v := (-1) / v 28663s & v := v ^ (-1) v := (-1) ^ v 28664s [ v := v - 1 v := 1 - v 28665s ] v := v - (-1) v := (-1) - v 28666@end group 28667@end example 28668 28669In the last four cases, a numeric prefix argument will be used in 28670place of the number one. (For example, @kbd{M-2 s ]} increases 28671a variable by 2, and @kbd{M-2 I s ]} replaces a variable by 28672minus-two minus the variable. 28673 28674The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -}, 28675etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous 28676arithmetic stores that don't remove the value @expr{a} from the stack. 28677 28678All arithmetic stores report the new value of the variable in the 28679Trail for your information. They signal an error if the variable 28680previously had no stored value. If default simplifications have been 28681turned off, the arithmetic stores temporarily turn them on for numeric 28682arguments only (i.e., they temporarily do an @kbd{m N} command). 28683@xref{Simplification Modes}. Large vectors put in the trail by 28684these commands always use abbreviated (@kbd{t .}) mode. 28685 28686@kindex s m 28687@pindex calc-store-map 28688The @kbd{s m} command is a general way to adjust a variable's value 28689using any Calc function. It is a ``mapping'' command analogous to 28690@kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see 28691how to specify a function for a mapping command. Basically, 28692all you do is type the Calc command key that would invoke that 28693function normally. For example, @kbd{s m n} applies the @kbd{n} 28694key to negate the contents of the variable, so @kbd{s m n} is 28695equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root 28696of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to 28697reverse the vector stored in the variable, and @kbd{s m H I S} 28698takes the hyperbolic arcsine of the variable contents. 28699 28700If the mapping function takes two or more arguments, the additional 28701arguments are taken from the stack; the old value of the variable 28702is provided as the first argument. Thus @kbd{s m -} with @expr{a} 28703on the stack computes @expr{v - a}, just like @kbd{s -}. With the 28704Inverse prefix, the variable's original value becomes the @emph{last} 28705argument instead of the first. Thus @kbd{I s m -} is also 28706equivalent to @kbd{I s -}. 28707 28708@kindex s x 28709@pindex calc-store-exchange 28710The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value 28711of a variable with the value on the top of the stack. Naturally, the 28712variable must already have a stored value for this to work. 28713 28714You can type an equation or assignment at the @kbd{s x} prompt. The 28715command @kbd{s x a=6} takes no values from the stack; instead, it 28716pushes the old value of @samp{a} on the stack and stores @samp{a = 6}. 28717 28718@kindex s u 28719@pindex calc-unstore 28720@cindex Void variables 28721@cindex Un-storing variables 28722Until you store something in them, most variables are ``void,'' that is, 28723they contain no value at all. If they appear in an algebraic formula 28724they will be left alone even if you press @kbd{=} (@code{calc-evaluate}). 28725The @kbd{s u} (@code{calc-unstore}) command returns a variable to the 28726void state. 28727 28728@kindex s c 28729@pindex calc-copy-variable 28730The @kbd{s c} (@code{calc-copy-variable}) command copies the stored 28731value of one variable to another. One way it differs from a simple 28732@kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is 28733that the value never goes on the stack and thus is never rounded, 28734evaluated, or simplified in any way; it is not even rounded down to the 28735current precision. 28736 28737The only variables with predefined values are the ``special constants'' 28738@code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free 28739to unstore these variables or to store new values into them if you like, 28740although some of the algebraic-manipulation functions may assume these 28741variables represent their standard values. Calc displays a warning if 28742you change the value of one of these variables, or of one of the other 28743special variables @code{inf}, @code{uinf}, and @code{nan} (which are 28744normally void). 28745 28746Note that @code{pi} doesn't actually have 3.14159265359 stored in it, 28747but rather a special magic value that evaluates to @cpi{} at the current 28748precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate 28749according to the current precision or polar mode. If you recall a value 28750from @code{pi} and store it back, this magic property will be lost. The 28751magic property is preserved, however, when a variable is copied with 28752@kbd{s c}. 28753 28754@kindex s k 28755@pindex calc-copy-special-constant 28756If one of the ``special constants'' is redefined (or undefined) so that 28757it no longer has its magic property, the property can be restored with 28758@kbd{s k} (@code{calc-copy-special-constant}). This command will prompt 28759for a special constant and a variable to store it in, and so a special 28760constant can be stored in any variable. Here, the special constant that 28761you enter doesn't depend on the value of the corresponding variable; 28762@code{pi} will represent 3.14159@dots{} regardless of what is currently 28763stored in the Calc variable @code{pi}. If one of the other special 28764variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its 28765original behavior can be restored by voiding it with @kbd{s u}. 28766 28767@node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall 28768@section Recalling Variables 28769 28770@noindent 28771@kindex s r 28772@pindex calc-recall 28773@cindex Recalling variables 28774The most straightforward way to extract the stored value from a variable 28775is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts 28776for a variable name (similarly to @code{calc-store}), looks up the value 28777of the specified variable, and pushes that value onto the stack. It is 28778an error to try to recall a void variable. 28779 28780It is also possible to recall the value from a variable by evaluating a 28781formula containing that variable. For example, @kbd{' a @key{RET} =} is 28782the same as @kbd{s r a @key{RET}} except that if the variable is void, the 28783former will simply leave the formula @samp{a} on the stack whereas the 28784latter will produce an error message. 28785 28786@kindex r 0-9 28787The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is 28788equivalent to @kbd{s r 9}. 28789 28790@node Operations on Variables, Let Command, Recalling Variables, Store and Recall 28791@section Other Operations on Variables 28792 28793@noindent 28794@kindex s e 28795@pindex calc-edit-variable 28796The @kbd{s e} (@code{calc-edit-variable}) command edits the stored 28797value of a variable without ever putting that value on the stack 28798or simplifying or evaluating the value. It prompts for the name of 28799the variable to edit. If the variable has no stored value, the 28800editing buffer will start out empty. If the editing buffer is 28801empty when you press @kbd{C-c C-c} to finish, the variable will 28802be made void. @xref{Editing Stack Entries}, for a general 28803description of editing. 28804 28805The @kbd{s e} command is especially useful for creating and editing 28806rewrite rules which are stored in variables. Sometimes these rules 28807contain formulas which must not be evaluated until the rules are 28808actually used. (For example, they may refer to @samp{deriv(x,y)}, 28809where @code{x} will someday become some expression involving @code{y}; 28810if you let Calc evaluate the rule while you are defining it, Calc will 28811replace @samp{deriv(x,y)} with 0 because the formula @code{x} does 28812not itself refer to @code{y}.) By contrast, recalling the variable, 28813editing with @kbd{`}, and storing will evaluate the variable's value 28814as a side effect of putting the value on the stack. 28815 28816@kindex s A 28817@kindex s D 28818@ignore 28819@mindex @idots 28820@end ignore 28821@kindex s E 28822@ignore 28823@mindex @null 28824@end ignore 28825@kindex s F 28826@ignore 28827@mindex @null 28828@end ignore 28829@kindex s G 28830@ignore 28831@mindex @null 28832@end ignore 28833@kindex s H 28834@ignore 28835@mindex @null 28836@end ignore 28837@kindex s I 28838@ignore 28839@mindex @null 28840@end ignore 28841@kindex s L 28842@ignore 28843@mindex @null 28844@end ignore 28845@kindex s P 28846@ignore 28847@mindex @null 28848@end ignore 28849@kindex s R 28850@ignore 28851@mindex @null 28852@end ignore 28853@kindex s T 28854@ignore 28855@mindex @null 28856@end ignore 28857@kindex s U 28858@ignore 28859@mindex @null 28860@end ignore 28861@kindex s X 28862@pindex calc-store-AlgSimpRules 28863@pindex calc-store-Decls 28864@pindex calc-store-EvalRules 28865@pindex calc-store-FitRules 28866@pindex calc-store-GenCount 28867@pindex calc-store-Holidays 28868@pindex calc-store-IntegLimit 28869@pindex calc-store-LineStyles 28870@pindex calc-store-PointStyles 28871@pindex calc-store-PlotRejects 28872@pindex calc-store-TimeZone 28873@pindex calc-store-Units 28874@pindex calc-store-ExtSimpRules 28875There are several special-purpose variable-editing commands that 28876use the @kbd{s} prefix followed by a shifted letter: 28877 28878@table @kbd 28879@item s A 28880Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}. 28881@item s D 28882Edit @code{Decls}. @xref{Declarations}. 28883@item s E 28884Edit @code{EvalRules}. @xref{Basic Simplifications}. 28885@item s F 28886Edit @code{FitRules}. @xref{Curve Fitting}. 28887@item s G 28888Edit @code{GenCount}. @xref{Solving Equations}. 28889@item s H 28890Edit @code{Holidays}. @xref{Business Days}. 28891@item s I 28892Edit @code{IntegLimit}. @xref{Calculus}. 28893@item s L 28894Edit @code{LineStyles}. @xref{Graphics}. 28895@item s P 28896Edit @code{PointStyles}. @xref{Graphics}. 28897@item s R 28898Edit @code{PlotRejects}. @xref{Graphics}. 28899@item s T 28900Edit @code{TimeZone}. @xref{Time Zones}. 28901@item s U 28902Edit @code{Units}. @xref{User-Defined Units}. 28903@item s X 28904Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}. 28905@end table 28906 28907These commands are just versions of @kbd{s e} that use fixed variable 28908names rather than prompting for the variable name. 28909 28910@kindex s p 28911@pindex calc-permanent-variable 28912@cindex Storing variables 28913@cindex Permanent variables 28914@cindex Calc init file, variables 28915The @kbd{s p} (@code{calc-permanent-variable}) command saves a 28916variable's value permanently in your Calc init file (the file given by 28917the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}), so 28918that its value will still be available in future Emacs sessions. You 28919can re-execute @w{@kbd{s p}} later on to update the saved value, but the 28920only way to remove a saved variable is to edit your calc init file 28921by hand. (@xref{General Mode Commands}, for a way to tell Calc to 28922use a different file for the Calc init file.) 28923 28924If you do not specify the name of a variable to save (i.e., 28925@kbd{s p @key{RET}}), all Calc variables with defined values 28926are saved except for the special constants @code{pi}, @code{e}, 28927@code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone} 28928and @code{PlotRejects}; 28929@code{FitRules}, @code{DistribRules}, and other built-in rewrite 28930rules; and @code{PlotData@var{n}} variables generated 28931by the graphics commands. (You can still save these variables by 28932explicitly naming them in an @kbd{s p} command.) 28933 28934@kindex s i 28935@pindex calc-insert-variables 28936The @kbd{s i} (@code{calc-insert-variables}) command writes 28937the values of all Calc variables into a specified buffer. 28938The variables are written with the prefix @code{var-} in the form of 28939Lisp @code{setq} commands 28940which store the values in string form. You can place these commands 28941in your Calc init file (or @file{.emacs}) if you wish, though in this case it 28942would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i} 28943omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference 28944is that @kbd{s i} will store the variables in any buffer, and it also 28945stores in a more human-readable format.) 28946 28947@node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall 28948@section The Let Command 28949 28950@noindent 28951@kindex s l 28952@pindex calc-let 28953@cindex Variables, temporary assignment 28954@cindex Temporary assignment to variables 28955If you have an expression like @samp{a+b^2} on the stack and you wish to 28956compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and 28957then press @kbd{=} to reevaluate the formula. This has the side-effect 28958of leaving the stored value of 3 in @expr{b} for future operations. 28959 28960The @kbd{s l} (@code{calc-let}) command evaluates a formula under a 28961@emph{temporary} assignment of a variable. It stores the value on the 28962top of the stack into the specified variable, then evaluates the 28963second-to-top stack entry, then restores the original value (or lack of one) 28964in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}}, 28965the stack will contain the formula @samp{a + 9}. The subsequent command 28966@kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14. 28967The variables @samp{a} and @samp{b} are not permanently affected in any way 28968by these commands. 28969 28970The value on the top of the stack may be an equation or assignment, or 28971a vector of equations or assignments, in which case the default will be 28972analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}. 28973 28974Also, you can answer the variable-name prompt with an equation or 28975assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack 28976and typing @kbd{s l b @key{RET}}. 28977 28978The @kbd{a b} (@code{calc-substitute}) command is another way to substitute 28979a variable with a value in a formula. It does an actual substitution 28980rather than temporarily assigning the variable and evaluating. For 28981example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will 28982produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)} 28983since the evaluation step will also evaluate @code{pi}. 28984 28985@node Evaluates-To Operator, , Let Command, Store and Recall 28986@section The Evaluates-To Operator 28987 28988@noindent 28989@tindex evalto 28990@tindex => 28991@cindex Evaluates-to operator 28992@cindex @samp{=>} operator 28993The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to 28994operator}. (It will show up as an @code{evalto} function call in 28995other language modes like Pascal and @LaTeX{}.) This is a binary 28996operator, that is, it has a lefthand and a righthand argument, 28997although it can be entered with the righthand argument omitted. 28998 28999A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as 29000follows: First, @var{a} is not simplified or modified in any 29001way. The previous value of argument @var{b} is thrown away; the 29002formula @var{a} is then copied and evaluated as if by the @kbd{=} 29003command according to all current modes and stored variable values, 29004and the result is installed as the new value of @var{b}. 29005 29006For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}. 29007The number 17 is ignored, and the lefthand argument is left in its 29008unevaluated form; the result is the formula @samp{2 + 3 => 5}. 29009 29010@kindex s = 29011@pindex calc-evalto 29012You can enter an @samp{=>} formula either directly using algebraic 29013entry (in which case the righthand side may be omitted since it is 29014going to be replaced right away anyhow), or by using the @kbd{s =} 29015(@code{calc-evalto}) command, which takes @var{a} from the stack 29016and replaces it with @samp{@var{a} => @var{b}}. 29017 29018Calc keeps track of all @samp{=>} operators on the stack, and 29019recomputes them whenever anything changes that might affect their 29020values, i.e., a mode setting or variable value. This occurs only 29021if the @samp{=>} operator is at the top level of the formula, or 29022if it is part of a top-level vector. In other words, pushing 29023@samp{2 + (a => 17)} will change the 17 to the actual value of 29024@samp{a} when you enter the formula, but the result will not be 29025dynamically updated when @samp{a} is changed later because the 29026@samp{=>} operator is buried inside a sum. However, a vector 29027of @samp{=>} operators will be recomputed, since it is convenient 29028to push a vector like @samp{[a =>, b =>, c =>]} on the stack to 29029make a concise display of all the variables in your problem. 29030(Another way to do this would be to use @samp{[a, b, c] =>}, 29031which provides a slightly different format of display. You 29032can use whichever you find easiest to read.) 29033 29034@kindex m C 29035@pindex calc-auto-recompute 29036The @kbd{m C} (@code{calc-auto-recompute}) command allows you to 29037turn this automatic recomputation on or off. If you turn 29038recomputation off, you must explicitly recompute an @samp{=>} 29039operator on the stack in one of the usual ways, such as by 29040pressing @kbd{=}. Turning recomputation off temporarily can save 29041a lot of time if you will be changing several modes or variables 29042before you look at the @samp{=>} entries again. 29043 29044Most commands are not especially useful with @samp{=>} operators 29045as arguments. For example, given @samp{x + 2 => 17}, it won't 29046work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want 29047to operate on the lefthand side of the @samp{=>} operator on 29048the top of the stack, type @kbd{j 1} (that's the digit ``one'') 29049to select the lefthand side, execute your commands, then type 29050@kbd{j u} to unselect. 29051 29052All current modes apply when an @samp{=>} operator is computed, 29053including the current simplification mode. Recall that the 29054formula @samp{arcsin(sin(x))} will not be handled by Calc's algebraic 29055simplifications, but Calc's unsafe simplifications will reduce it to 29056@samp{x}. If you enter @samp{arcsin(sin(x)) =>} normally, the result 29057will be @samp{arcsin(sin(x)) => arcsin(sin(x))}. If you change to 29058Extended Simplification mode, the result will be 29059@samp{arcsin(sin(x)) => x}. However, just pressing @kbd{a e} 29060once will have no effect on @samp{arcsin(sin(x)) => arcsin(sin(x))}, 29061because the righthand side depends only on the lefthand side 29062and the current mode settings, and the lefthand side is not 29063affected by commands like @kbd{a e}. 29064 29065The ``let'' command (@kbd{s l}) has an interesting interaction 29066with the @samp{=>} operator. The @kbd{s l} command evaluates the 29067second-to-top stack entry with the top stack entry supplying 29068a temporary value for a given variable. As you might expect, 29069if that stack entry is an @samp{=>} operator its righthand 29070side will temporarily show this value for the variable. In 29071fact, all @samp{=>}s on the stack will be updated if they refer 29072to that variable. But this change is temporary in the sense 29073that the next command that causes Calc to look at those stack 29074entries will make them revert to the old variable value. 29075 29076@smallexample 29077@group 290782: a => a 2: a => 17 2: a => a 290791: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1 29080 . . . 29081 29082 17 s l a @key{RET} p 8 @key{RET} 29083@end group 29084@end smallexample 29085 29086Here the @kbd{p 8} command changes the current precision, 29087thus causing the @samp{=>} forms to be recomputed after the 29088influence of the ``let'' is gone. The @kbd{d @key{SPC}} command 29089(@code{calc-refresh}) is a handy way to force the @samp{=>} 29090operators on the stack to be recomputed without any other 29091side effects. 29092 29093@kindex s : 29094@pindex calc-assign 29095@tindex assign 29096@tindex := 29097Embedded mode also uses @samp{=>} operators. In Embedded mode, 29098the lefthand side of an @samp{=>} operator can refer to variables 29099assigned elsewhere in the file by @samp{:=} operators. The 29100assignment operator @samp{a := 17} does not actually do anything 29101by itself. But Embedded mode recognizes it and marks it as a sort 29102of file-local definition of the variable. You can enter @samp{:=} 29103operators in Algebraic mode, or by using the @kbd{s :} 29104(@code{calc-assign}) [@code{assign}] command which takes a variable 29105and value from the stack and replaces them with an assignment. 29106 29107@xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in 29108@TeX{} language output. The @dfn{eqn} mode gives similar 29109treatment to @samp{=>}. 29110 29111@node Graphics, Kill and Yank, Store and Recall, Top 29112@chapter Graphics 29113 29114@noindent 29115The commands for graphing data begin with the @kbd{g} prefix key. Calc 29116uses GNUPLOT 2.0 or later to do graphics. These commands will only work 29117if GNUPLOT is available on your system. (While GNUPLOT sounds like 29118a relative of GNU Emacs, it is actually completely unrelated. 29119However, it is free software. It can be obtained from 29120@samp{http://www.gnuplot.info}.) 29121 29122@vindex calc-gnuplot-name 29123If you have GNUPLOT installed on your system but Calc is unable to 29124find it, you may need to set the @code{calc-gnuplot-name} variable in 29125your Calc init file or @file{.emacs}. You may also need to set some 29126Lisp variables to show Calc how to run GNUPLOT on your system; these 29127are described under @kbd{g D} and @kbd{g O} below. If you are using 29128the X window system or MS-Windows, Calc will configure GNUPLOT for you 29129automatically. If you have GNUPLOT 3.0 or later and you are using a 29130Unix or GNU system without X, Calc will configure GNUPLOT to display 29131graphs using simple character graphics that will work on any 29132POSIX-compatible terminal. 29133 29134@menu 29135* Basic Graphics:: 29136* Three Dimensional Graphics:: 29137* Managing Curves:: 29138* Graphics Options:: 29139* Devices:: 29140@end menu 29141 29142@node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics 29143@section Basic Graphics 29144 29145@noindent 29146@kindex g f 29147@pindex calc-graph-fast 29148The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}). 29149This command takes two vectors of equal length from the stack. 29150The vector at the top of the stack represents the ``y'' values of 29151the various data points. The vector in the second-to-top position 29152represents the corresponding ``x'' values. This command runs 29153GNUPLOT (if it has not already been started by previous graphing 29154commands) and displays the set of data points. The points will 29155be connected by lines, and there will also be some kind of symbol 29156to indicate the points themselves. 29157 29158The ``x'' entry may instead be an interval form, in which case suitable 29159``x'' values are interpolated between the minimum and maximum values of 29160the interval (whether the interval is open or closed is ignored). 29161 29162The ``x'' entry may also be a number, in which case Calc uses the 29163sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc. 29164(Generally the number 0 or 1 would be used for @expr{x} in this case.) 29165 29166The ``y'' entry may be any formula instead of a vector. Calc effectively 29167uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula; 29168the result of this must be a formula in a single (unassigned) variable. 29169The formula is plotted with this variable taking on the various ``x'' 29170values. Graphs of formulas by default use lines without symbols at the 29171computed data points. Note that if neither ``x'' nor ``y'' is a vector, 29172Calc guesses at a reasonable number of data points to use. See the 29173@kbd{g N} command below. (The ``x'' values must be either a vector 29174or an interval if ``y'' is a formula.) 29175 29176@ignore 29177@starindex 29178@end ignore 29179@tindex xy 29180If ``y'' is (or evaluates to) a formula of the form 29181@samp{xy(@var{x}, @var{y})} then the result is a 29182parametric plot. The two arguments of the fictitious @code{xy} function 29183are used as the ``x'' and ``y'' coordinates of the curve, respectively. 29184In this case the ``x'' vector or interval you specified is not directly 29185visible in the graph. For example, if ``x'' is the interval @samp{[0..360]} 29186and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph 29187will be a circle. 29188 29189Also, ``x'' and ``y'' may each be variable names, in which case Calc 29190looks for suitable vectors, intervals, or formulas stored in those 29191variables. 29192 29193The ``x'' and ``y'' values for the data points (as pulled from the vectors, 29194calculated from the formulas, or interpolated from the intervals) should 29195be real numbers (integers, fractions, or floats). One exception to this 29196is that the ``y'' entry can consist of a vector of numbers combined with 29197error forms, in which case the points will be plotted with the 29198appropriate error bars. Other than this, if either the ``x'' 29199value or the ``y'' value of a given data point is not a real number, that 29200data point will be omitted from the graph. The points on either side 29201of the invalid point will @emph{not} be connected by a line. 29202 29203See the documentation for @kbd{g a} below for a description of the way 29204numeric prefix arguments affect @kbd{g f}. 29205 29206@cindex @code{PlotRejects} variable 29207@vindex PlotRejects 29208If you store an empty vector in the variable @code{PlotRejects} 29209(i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to 29210this vector for every data point which was rejected because its 29211``x'' or ``y'' values were not real numbers. The result will be 29212a matrix where each row holds the curve number, data point number, 29213``x'' value, and ``y'' value for a rejected data point. 29214@xref{Evaluates-To Operator}, for a handy way to keep tabs on the 29215current value of @code{PlotRejects}. @xref{Operations on Variables}, 29216for the @kbd{s R} command which is another easy way to examine 29217@code{PlotRejects}. 29218 29219@kindex g c 29220@pindex calc-graph-clear 29221To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}). 29222If the GNUPLOT output device is an X window, the window will go away. 29223Effects on other kinds of output devices will vary. You don't need 29224to use @kbd{g c} if you don't want to---if you give another @kbd{g f} 29225or @kbd{g p} command later on, it will reuse the existing graphics 29226window if there is one. 29227 29228@node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics 29229@section Three-Dimensional Graphics 29230 29231@kindex g F 29232@pindex calc-graph-fast-3d 29233The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional 29234graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0, 29235you will see a GNUPLOT error message if you try this command. 29236 29237The @kbd{g F} command takes three values from the stack, called ``x'', 29238``y'', and ``z'', respectively. As was the case for 2D graphs, there 29239are several options for these values. 29240 29241In the first case, ``x'' and ``y'' are each vectors (not necessarily of 29242the same length); either or both may instead be interval forms. The 29243``z'' value must be a matrix with the same number of rows as elements 29244in ``x'', and the same number of columns as elements in ``y''. The 29245result is a surface plot where 29246@texline @math{z_{ij}} 29247@infoline @expr{z_ij} 29248is the height of the point 29249at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will 29250be displayed from a certain default viewpoint; you can change this 29251viewpoint by adding a @samp{set view} to the @file{*Gnuplot Commands*} 29252buffer as described later. See the GNUPLOT documentation for a 29253description of the @samp{set view} command. 29254 29255Each point in the matrix will be displayed as a dot in the graph, 29256and these points will be connected by a grid of lines (@dfn{isolines}). 29257 29258In the second case, ``x'', ``y'', and ``z'' are all vectors of equal 29259length. The resulting graph displays a 3D line instead of a surface, 29260where the coordinates of points along the line are successive triplets 29261of values from the input vectors. 29262 29263In the third case, ``x'' and ``y'' are vectors or interval forms, and 29264``z'' is any formula involving two variables (not counting variables 29265with assigned values). These variables are sorted into alphabetical 29266order; the first takes on values from ``x'' and the second takes on 29267values from ``y'' to form a matrix of results that are graphed as a 292683D surface. 29269 29270@ignore 29271@starindex 29272@end ignore 29273@tindex xyz 29274If the ``z'' formula evaluates to a call to the fictitious function 29275@samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a 29276``parametric surface.'' In this case, the axes of the graph are 29277taken from the @var{x} and @var{y} values in these calls, and the 29278``x'' and ``y'' values from the input vectors or intervals are used only 29279to specify the range of inputs to the formula. For example, plotting 29280@samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))} 29281will draw a sphere. (Since the default resolution for 3D plots is 292825 steps in each of ``x'' and ``y'', this will draw a very crude 29283sphere. You could use the @kbd{g N} command, described below, to 29284increase this resolution, or specify the ``x'' and ``y'' values as 29285vectors with more than 5 elements. 29286 29287It is also possible to have a function in a regular @kbd{g f} plot 29288evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not 29289a surface, the result will be a 3D parametric line. For example, 29290@samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a 29291helix (a three-dimensional spiral). 29292 29293As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be 29294variables containing the relevant data. 29295 29296@node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics 29297@section Managing Curves 29298 29299@noindent 29300The @kbd{g f} command is really shorthand for the following commands: 29301@kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for 29302@kbd{C-u g d g A g p}. You can gain more control over your graph 29303by using these commands directly. 29304 29305@kindex g a 29306@pindex calc-graph-add 29307The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve'' 29308represented by the two values on the top of the stack to the current 29309graph. You can have any number of curves in the same graph. When 29310you give the @kbd{g p} command, all the curves will be drawn superimposed 29311on the same axes. 29312 29313The @kbd{g a} command (and many others that affect the current graph) 29314will cause a special buffer, @file{*Gnuplot Commands*}, to be displayed 29315in another window. This buffer is a template of the commands that will 29316be sent to GNUPLOT when it is time to draw the graph. The first 29317@kbd{g a} command adds a @code{plot} command to this buffer. Succeeding 29318@kbd{g a} commands add extra curves onto that @code{plot} command. 29319Other graph-related commands put other GNUPLOT commands into this 29320buffer. In normal usage you never need to work with this buffer 29321directly, but you can if you wish. The only constraint is that there 29322must be only one @code{plot} command, and it must be the last command 29323in the buffer. If you want to save and later restore a complete graph 29324configuration, you can use regular Emacs commands to save and restore 29325the contents of the @file{*Gnuplot Commands*} buffer. 29326 29327@vindex PlotData1 29328@vindex PlotData2 29329If the values on the stack are not variable names, @kbd{g a} will invent 29330variable names for them (of the form @samp{PlotData@var{n}}) and store 29331the values in those variables. The ``x'' and ``y'' variables are what 29332go into the @code{plot} command in the template. If you add a curve 29333that uses a certain variable and then later change that variable, you 29334can replot the graph without having to delete and re-add the curve. 29335That's because the variable name, not the vector, interval or formula 29336itself, is what was added by @kbd{g a}. 29337 29338A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way 29339stack entries are interpreted as curves. With a positive prefix 29340argument @expr{n}, the top @expr{n} stack entries are ``y'' values 29341for @expr{n} different curves which share a common ``x'' value in 29342the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix 29343argument is equivalent to @kbd{C-u 1 g a}.) 29344 29345A prefix of zero or plain @kbd{C-u} means to take two stack entries, 29346``x'' and ``y'' as usual, but to interpret ``y'' as a vector of 29347``y'' values for several curves that share a common ``x''. 29348 29349A negative prefix argument tells Calc to read @expr{n} vectors from 29350the stack; each vector @expr{[x, y]} describes an independent curve. 29351This is the only form of @kbd{g a} that creates several curves at once 29352that don't have common ``x'' values. (Of course, the range of ``x'' 29353values covered by all the curves ought to be roughly the same if 29354they are to look nice on the same graph.) 29355 29356For example, to plot 29357@texline @math{\sin n x} 29358@infoline @expr{sin(n x)} 29359for integers @expr{n} 29360from 1 to 5, you could use @kbd{v x} to create a vector of integers 29361(@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)} 29362across this vector. The resulting vector of formulas is suitable 29363for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f} 29364command. 29365 29366@kindex g A 29367@pindex calc-graph-add-3d 29368The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve 29369to the graph. It is not valid to intermix 2D and 3D curves in a 29370single graph. This command takes three arguments, ``x'', ``y'', 29371and ``z'', from the stack. With a positive prefix @expr{n}, it 29372takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n} 29373separate ``z''s). With a zero prefix, it takes three stack entries 29374but the ``z'' entry is a vector of curve values. With a negative 29375prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}. 29376The @kbd{g A} command works by adding a @code{splot} (surface-plot) 29377command to the @file{*Gnuplot Commands*} buffer. 29378 29379(Although @kbd{g a} adds a 2D @code{plot} command to the 29380@file{*Gnuplot Commands*} buffer, Calc changes this to @code{splot} 29381before sending it to GNUPLOT if it notices that the data points are 29382evaluating to @code{xyz} calls. It will not work to mix 2D and 3D 29383@kbd{g a} curves in a single graph, although Calc does not currently 29384check for this.) 29385 29386@kindex g d 29387@pindex calc-graph-delete 29388The @kbd{g d} (@code{calc-graph-delete}) command deletes the most 29389recently added curve from the graph. It has no effect if there are 29390no curves in the graph. With a numeric prefix argument of any kind, 29391it deletes all of the curves from the graph. 29392 29393@kindex g H 29394@pindex calc-graph-hide 29395The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides'' 29396the most recently added curve. A hidden curve will not appear in 29397the actual plot, but information about it such as its name and line and 29398point styles will be retained. 29399 29400@kindex g j 29401@pindex calc-graph-juggle 29402The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve 29403at the end of the list (the ``most recently added curve'') to the 29404front of the list. The next-most-recent curve is thus exposed for 29405@w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work 29406with any curve in the graph even though curve-related commands only 29407affect the last curve in the list. 29408 29409@kindex g p 29410@pindex calc-graph-plot 29411The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw 29412the graph described in the @file{*Gnuplot Commands*} buffer. Any 29413GNUPLOT parameters which are not defined by commands in this buffer 29414are reset to their default values. The variables named in the @code{plot} 29415command are written to a temporary data file and the variable names 29416are then replaced by the file name in the template. The resulting 29417plotting commands are fed to the GNUPLOT program. See the documentation 29418for the GNUPLOT program for more specific information. All temporary 29419files are removed when Emacs or GNUPLOT exits. 29420 29421If you give a formula for ``y'', Calc will remember all the values that 29422it calculates for the formula so that later plots can reuse these values. 29423Calc throws out these saved values when you change any circumstances 29424that may affect the data, such as switching from Degrees to Radians 29425mode, or changing the value of a parameter in the formula. You can 29426force Calc to recompute the data from scratch by giving a negative 29427numeric prefix argument to @kbd{g p}. 29428 29429Calc uses a fairly rough step size when graphing formulas over intervals. 29430This is to ensure quick response. You can ``refine'' a plot by giving 29431a positive numeric prefix argument to @kbd{g p}. Calc goes through 29432the data points it has computed and saved from previous plots of the 29433function, and computes and inserts a new data point midway between 29434each of the existing points. You can refine a plot any number of times, 29435but beware that the amount of calculation involved doubles each time. 29436 29437Calc does not remember computed values for 3D graphs. This means the 29438numerix prefix argument, if any, to @kbd{g p} is effectively ignored if 29439the current graph is three-dimensional. 29440 29441@kindex g P 29442@pindex calc-graph-print 29443The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p}, 29444except that it sends the output to a printer instead of to the 29445screen. More precisely, @kbd{g p} looks for @samp{set terminal} 29446or @samp{set output} commands in the @file{*Gnuplot Commands*} buffer; 29447lacking these it uses the default settings. However, @kbd{g P} 29448ignores @samp{set terminal} and @samp{set output} commands and 29449uses a different set of default values. All of these values are 29450controlled by the @kbd{g D} and @kbd{g O} commands discussed below. 29451Provided everything is set up properly, @kbd{g p} will plot to 29452the screen unless you have specified otherwise and @kbd{g P} will 29453always plot to the printer. 29454 29455@node Graphics Options, Devices, Managing Curves, Graphics 29456@section Graphics Options 29457 29458@noindent 29459@kindex g g 29460@pindex calc-graph-grid 29461The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid'' 29462on and off. It is off by default; tick marks appear only at the 29463edges of the graph. With the grid turned on, dotted lines appear 29464across the graph at each tick mark. Note that this command only 29465changes the setting in @file{*Gnuplot Commands*}; to see the effects 29466of the change you must give another @kbd{g p} command. 29467 29468@kindex g b 29469@pindex calc-graph-border 29470The @kbd{g b} (@code{calc-graph-border}) command turns the border 29471(the box that surrounds the graph) on and off. It is on by default. 29472This command will only work with GNUPLOT 3.0 and later versions. 29473 29474@kindex g k 29475@pindex calc-graph-key 29476The @kbd{g k} (@code{calc-graph-key}) command turns the ``key'' 29477on and off. The key is a chart in the corner of the graph that 29478shows the correspondence between curves and line styles. It is 29479off by default, and is only really useful if you have several 29480curves on the same graph. 29481 29482@kindex g N 29483@pindex calc-graph-num-points 29484The @kbd{g N} (@code{calc-graph-num-points}) command allows you 29485to select the number of data points in the graph. This only affects 29486curves where neither ``x'' nor ``y'' is specified as a vector. 29487Enter a blank line to revert to the default value (initially 15). 29488With no prefix argument, this command affects only the current graph. 29489With a positive prefix argument this command changes or, if you enter 29490a blank line, displays the default number of points used for all 29491graphs created by @kbd{g a} that don't specify the resolution explicitly. 29492With a negative prefix argument, this command changes or displays 29493the default value (initially 5) used for 3D graphs created by @kbd{g A}. 29494Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points 29495will be computed for the surface. 29496 29497Data values in the graph of a function are normally computed to a 29498precision of five digits, regardless of the current precision at the 29499time. This is usually more than adequate, but there are cases where 29500it will not be. For example, plotting @expr{1 + x} with @expr{x} in the 29501interval @samp{[0 ..@: 1e-6]} will round all the data points down 29502to 1.0! Putting the command @samp{set precision @var{n}} in the 29503@file{*Gnuplot Commands*} buffer will cause the data to be computed 29504at precision @var{n} instead of 5. Since this is such a rare case, 29505there is no keystroke-based command to set the precision. 29506 29507@kindex g h 29508@pindex calc-graph-header 29509The @kbd{g h} (@code{calc-graph-header}) command sets the title 29510for the graph. This will show up centered above the graph. 29511The default title is blank (no title). 29512 29513@kindex g n 29514@pindex calc-graph-name 29515The @kbd{g n} (@code{calc-graph-name}) command sets the title of an 29516individual curve. Like the other curve-manipulating commands, it 29517affects the most recently added curve, i.e., the last curve on the 29518list in the @file{*Gnuplot Commands*} buffer. To set the title of 29519the other curves you must first juggle them to the end of the list 29520with @kbd{g j}, or edit the @file{*Gnuplot Commands*} buffer by hand. 29521Curve titles appear in the key; if the key is turned off they are 29522not used. 29523 29524@kindex g t 29525@kindex g T 29526@pindex calc-graph-title-x 29527@pindex calc-graph-title-y 29528The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T} 29529(@code{calc-graph-title-y}) commands set the titles on the ``x'' 29530and ``y'' axes, respectively. These titles appear next to the 29531tick marks on the left and bottom edges of the graph, respectively. 29532Calc does not have commands to control the tick marks themselves, 29533but you can edit them into the @file{*Gnuplot Commands*} buffer if 29534you wish. See the GNUPLOT documentation for details. 29535 29536@kindex g r 29537@kindex g R 29538@pindex calc-graph-range-x 29539@pindex calc-graph-range-y 29540The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R} 29541(@code{calc-graph-range-y}) commands set the range of values on the 29542``x'' and ``y'' axes, respectively. You are prompted to enter a 29543suitable range. This should be either a pair of numbers of the 29544form, @samp{@var{min}:@var{max}}, or a blank line to revert to the 29545default behavior of setting the range based on the range of values 29546in the data, or @samp{$} to take the range from the top of the stack. 29547Ranges on the stack can be represented as either interval forms or 29548vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}. 29549 29550@kindex g l 29551@kindex g L 29552@pindex calc-graph-log-x 29553@pindex calc-graph-log-y 29554The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y}) 29555commands allow you to set either or both of the axes of the graph to 29556be logarithmic instead of linear. 29557 29558@kindex g C-l 29559@kindex g C-r 29560@kindex g C-t 29561@pindex calc-graph-log-z 29562@pindex calc-graph-range-z 29563@pindex calc-graph-title-z 29564For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are 29565letters with the Control key held down) are the corresponding commands 29566for the ``z'' axis. 29567 29568@kindex g z 29569@kindex g Z 29570@pindex calc-graph-zero-x 29571@pindex calc-graph-zero-y 29572The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z} 29573(@code{calc-graph-zero-y}) commands control whether a dotted line is 29574drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same 29575dotted lines that would be drawn there anyway if you used @kbd{g g} to 29576turn the ``grid'' feature on.) Zero-axis lines are on by default, and 29577may be turned off only in GNUPLOT 3.0 and later versions. They are 29578not available for 3D plots. 29579 29580@kindex g s 29581@pindex calc-graph-line-style 29582The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting 29583lines on or off for the most recently added curve, and optionally selects 29584the style of lines to be used for that curve. Plain @kbd{g s} simply 29585toggles the lines on and off. With a numeric prefix argument, @kbd{g s} 29586turns lines on and sets a particular line style. Line style numbers 29587start at one and their meanings vary depending on the output device. 29588GNUPLOT guarantees that there will be at least six different line styles 29589available for any device. 29590 29591@kindex g S 29592@pindex calc-graph-point-style 29593The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns 29594the symbols at the data points on or off, or sets the point style. 29595If you turn both lines and points off, the data points will show as 29596tiny dots. If the ``y'' values being plotted contain error forms and 29597the connecting lines are turned off, then this command will also turn 29598the error bars on or off. 29599 29600@cindex @code{LineStyles} variable 29601@cindex @code{PointStyles} variable 29602@vindex LineStyles 29603@vindex PointStyles 29604Another way to specify curve styles is with the @code{LineStyles} and 29605@code{PointStyles} variables. These variables initially have no stored 29606values, but if you store a vector of integers in one of these variables, 29607the @kbd{g a} and @kbd{g f} commands will use those style numbers 29608instead of the defaults for new curves that are added to the graph. 29609An entry should be a positive integer for a specific style, or 0 to let 29610the style be chosen automatically, or @mathit{-1} to turn off lines or points 29611altogether. If there are more curves than elements in the vector, the 29612last few curves will continue to have the default styles. Of course, 29613you can later use @kbd{g s} and @kbd{g S} to change any of these styles. 29614 29615For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve 29616to have lines in style number 2, the second curve to have no connecting 29617lines, and the third curve to have lines in style 3. Point styles will 29618still be assigned automatically, but you could store another vector in 29619@code{PointStyles} to define them, too. 29620 29621@node Devices, , Graphics Options, Graphics 29622@section Graphical Devices 29623 29624@noindent 29625@kindex g D 29626@pindex calc-graph-device 29627The @kbd{g D} (@code{calc-graph-device}) command sets the device name 29628(or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands 29629on this graph. It does not affect the permanent default device name. 29630If you enter a blank name, the device name reverts to the default. 29631Enter @samp{?} to see a list of supported devices. 29632 29633With a positive numeric prefix argument, @kbd{g D} instead sets 29634the default device name, used by all plots in the future which do 29635not override it with a plain @kbd{g D} command. If you enter a 29636blank line this command shows you the current default. The special 29637name @code{default} signifies that Calc should choose @code{x11} if 29638the X window system is in use (as indicated by the presence of a 29639@code{DISPLAY} environment variable), @code{windows} on MS-Windows, or 29640otherwise @code{dumb} under GNUPLOT 3.0 and later, or 29641@code{postscript} under GNUPLOT 2.0. This is the initial default 29642value. 29643 29644The @code{dumb} device is an interface to ``dumb terminals,'' i.e., 29645terminals with no special graphics facilities. It writes a crude 29646picture of the graph composed of characters like @code{-} and @code{|} 29647to a buffer called @file{*Gnuplot Trail*}, which Calc then displays. 29648The graph is made the same size as the Emacs screen, which on most 29649dumb terminals will be 29650@texline @math{80\times24} 29651@infoline 80x24 29652characters. The graph is displayed in 29653an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit 29654the recursive edit and return to Calc. Note that the @code{dumb} 29655device is present only in GNUPLOT 3.0 and later versions. 29656 29657The word @code{dumb} may be followed by two numbers separated by 29658spaces. These are the desired width and height of the graph in 29659characters. Also, the device name @code{big} is like @code{dumb} 29660but creates a graph four times the width and height of the Emacs 29661screen. You will then have to scroll around to view the entire 29662graph. In the @file{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL}, 29663@kbd{<}, and @kbd{>} are defined to scroll by one screenful in each 29664of the four directions. 29665 29666With a negative numeric prefix argument, @kbd{g D} sets or displays 29667the device name used by @kbd{g P} (@code{calc-graph-print}). This 29668is initially @code{postscript}. If you don't have a PostScript 29669printer, you may decide once again to use @code{dumb} to create a 29670plot on any text-only printer. 29671 29672@kindex g O 29673@pindex calc-graph-output 29674The @kbd{g O} (@code{calc-graph-output}) command sets the name of the 29675output file used by GNUPLOT@. For some devices, notably @code{x11} and 29676@code{windows}, there is no output file and this information is not 29677used. Many other ``devices'' are really file formats like 29678@code{postscript}; in these cases the output in the desired format 29679goes into the file you name with @kbd{g O}. Type @kbd{g O stdout 29680@key{RET}} to set GNUPLOT to write to its standard output stream, 29681i.e., to @file{*Gnuplot Trail*}. This is the default setting. 29682 29683Another special output name is @code{tty}, which means that GNUPLOT 29684is going to write graphics commands directly to its standard output, 29685which you wish Emacs to pass through to your terminal. Tektronix 29686graphics terminals, among other devices, operate this way. Calc does 29687this by telling GNUPLOT to write to a temporary file, then running a 29688sub-shell executing the command @samp{cat tempfile >/dev/tty}. On 29689typical Unix systems, this will copy the temporary file directly to 29690the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l} 29691to Emacs afterwards to refresh the screen. 29692 29693Once again, @kbd{g O} with a positive or negative prefix argument 29694sets the default or printer output file names, respectively. In each 29695case you can specify @code{auto}, which causes Calc to invent a temporary 29696file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file 29697will be deleted once it has been displayed or printed. If the output file 29698name is not @code{auto}, the file is not automatically deleted. 29699 29700The default and printer devices and output files can be saved 29701permanently by the @kbd{m m} (@code{calc-save-modes}) command. The 29702default number of data points (see @kbd{g N}) and the X geometry 29703(see @kbd{g X}) are also saved. Other graph information is @emph{not} 29704saved; you can save a graph's configuration simply by saving the contents 29705of the @file{*Gnuplot Commands*} buffer. 29706 29707@vindex calc-gnuplot-plot-command 29708@vindex calc-gnuplot-default-device 29709@vindex calc-gnuplot-default-output 29710@vindex calc-gnuplot-print-command 29711@vindex calc-gnuplot-print-device 29712@vindex calc-gnuplot-print-output 29713You may wish to configure the default and 29714printer devices and output files for the whole system. The relevant 29715Lisp variables are @code{calc-gnuplot-default-device} and @code{-output}, 29716and @code{calc-gnuplot-print-device} and @code{-output}. The output 29717file names must be either strings as described above, or Lisp 29718expressions which are evaluated on the fly to get the output file names. 29719 29720Other important Lisp variables are @code{calc-gnuplot-plot-command} and 29721@code{calc-gnuplot-print-command}, which give the system commands to 29722display or print the output of GNUPLOT, respectively. These may be 29723@code{nil} if no command is necessary, or strings which can include 29724@samp{%s} to signify the name of the file to be displayed or printed. 29725Or, these variables may contain Lisp expressions which are evaluated 29726to display or print the output. These variables are customizable 29727(@pxref{Customizing Calc}). 29728 29729@kindex g x 29730@pindex calc-graph-display 29731The @kbd{g x} (@code{calc-graph-display}) command lets you specify 29732on which X window system display your graphs should be drawn. Enter 29733a blank line to see the current display name. This command has no 29734effect unless the current device is @code{x11}. 29735 29736@kindex g X 29737@pindex calc-graph-geometry 29738The @kbd{g X} (@code{calc-graph-geometry}) command is a similar 29739command for specifying the position and size of the X window. 29740The normal value is @code{default}, which generally means your 29741window manager will let you place the window interactively. 29742Entering @samp{800x500+0+0} would create an 800-by-500 pixel 29743window in the upper-left corner of the screen. This command has no 29744effect if the current device is @code{windows}. 29745 29746The buffer called @file{*Gnuplot Trail*} holds a transcript of the 29747session with GNUPLOT@. This shows the commands Calc has ``typed'' to 29748GNUPLOT and the responses it has received. Calc tries to notice when an 29749error message has appeared here and display the buffer for you when 29750this happens. You can check this buffer yourself if you suspect 29751something has gone wrong@footnote{ 29752On MS-Windows, due to the peculiarities of how the Windows version of 29753GNUPLOT (called @command{wgnuplot}) works, the GNUPLOT responses are 29754not communicated back to Calc. Instead, you need to look them up in 29755the GNUPLOT command window that is displayed as in normal interactive 29756usage of GNUPLOT. 29757}. 29758 29759@kindex g C 29760@pindex calc-graph-command 29761The @kbd{g C} (@code{calc-graph-command}) command prompts you to 29762enter any line of text, then simply sends that line to the current 29763GNUPLOT process. The @file{*Gnuplot Trail*} buffer looks deceptively 29764like a Shell buffer but you can't type commands in it yourself. 29765Instead, you must use @kbd{g C} for this purpose. 29766 29767@kindex g v 29768@kindex g V 29769@pindex calc-graph-view-commands 29770@pindex calc-graph-view-trail 29771The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V} 29772(@code{calc-graph-view-trail}) commands display the @file{*Gnuplot Commands*} 29773and @file{*Gnuplot Trail*} buffers, respectively, in another window. 29774This happens automatically when Calc thinks there is something you 29775will want to see in either of these buffers. If you type @kbd{g v} 29776or @kbd{g V} when the relevant buffer is already displayed, the 29777buffer is hidden again. (Note that on MS-Windows, the @file{*Gnuplot 29778Trail*} buffer will usually show nothing of interest, because 29779GNUPLOT's responses are not communicated back to Calc.) 29780 29781One reason to use @kbd{g v} is to add your own commands to the 29782@file{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use 29783@kbd{C-x o} to switch into that window. For example, GNUPLOT has 29784@samp{set label} and @samp{set arrow} commands that allow you to 29785annotate your plots. Since Calc doesn't understand these commands, 29786you have to add them to the @file{*Gnuplot Commands*} buffer 29787yourself, then use @w{@kbd{g p}} to replot using these new commands. Note 29788that your commands must appear @emph{before} the @code{plot} command. 29789To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}. 29790You may have to type @kbd{g C @key{RET}} a few times to clear the 29791``press return for more'' or ``subtopic of @dots{}'' requests. 29792Note that Calc always sends commands (like @samp{set nolabel}) to 29793reset all plotting parameters to the defaults before each plot, so 29794to delete a label all you need to do is delete the @samp{set label} 29795line you added (or comment it out with @samp{#}) and then replot 29796with @kbd{g p}. 29797 29798@kindex g q 29799@pindex calc-graph-quit 29800You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT 29801process that is running. The next graphing command you give will 29802start a fresh GNUPLOT process. The word @samp{Graph} appears in 29803the Calc window's mode line whenever a GNUPLOT process is currently 29804running. The GNUPLOT process is automatically killed when you 29805exit Emacs if you haven't killed it manually by then. 29806 29807@kindex g K 29808@pindex calc-graph-kill 29809The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q} 29810except that it also views the @file{*Gnuplot Trail*} buffer so that 29811you can see the process being killed. This is better if you are 29812killing GNUPLOT because you think it has gotten stuck. 29813 29814@node Kill and Yank, Keypad Mode, Graphics, Top 29815@chapter Kill and Yank Functions 29816 29817@noindent 29818The commands in this chapter move information between the Calculator and 29819other Emacs editing buffers. 29820 29821In many cases Embedded mode is an easier and more natural way to 29822work with Calc from a regular editing buffer. @xref{Embedded Mode}. 29823 29824@menu 29825* Killing From Stack:: 29826* Yanking Into Stack:: 29827* Saving Into Registers:: 29828* Inserting From Registers:: 29829* Grabbing From Buffers:: 29830* Yanking Into Buffers:: 29831* X Cut and Paste:: 29832@end menu 29833 29834@node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank 29835@section Killing from the Stack 29836 29837@noindent 29838@kindex C-k 29839@pindex calc-kill 29840@kindex M-k 29841@pindex calc-copy-as-kill 29842@kindex C-w 29843@pindex calc-kill-region 29844@kindex M-w 29845@pindex calc-copy-region-as-kill 29846@kindex M-C-w 29847@cindex Kill ring 29848@dfn{Kill} commands are Emacs commands that insert text into the ``kill 29849ring,'' from which it can later be ``yanked'' by a @kbd{C-y} command. 29850Three common kill commands in normal Emacs are @kbd{C-k}, which kills 29851one line, @kbd{C-w}, which kills the region between mark and point, and 29852@kbd{M-w}, which puts the region into the kill ring without actually 29853deleting it. All of these commands work in the Calculator, too, 29854although in the Calculator they operate on whole stack entries, so they 29855``round up'' the specified region to encompass full lines. (To copy 29856only parts of lines, the @kbd{M-C-w} command in the Calculator will copy 29857the region to the kill ring without any ``rounding up'', just like the 29858@kbd{M-w} command in normal Emacs.) Also, @kbd{M-k} has been provided 29859to complete the set; it puts the current line into the kill ring without 29860deleting anything. 29861 29862The kill commands are unusual in that they pay attention to the location 29863of the cursor in the Calculator buffer. If the cursor is on or below 29864the bottom line, the kill commands operate on the top of the stack. 29865Otherwise, they operate on whatever stack element the cursor is on. The 29866text is copied into the kill ring exactly as it appears on the screen, 29867including line numbers if they are enabled. 29868 29869A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number 29870of lines killed. A positive argument kills the current line and @expr{n-1} 29871lines below it. A negative argument kills the @expr{-n} lines above the 29872current line. Again this mirrors the behavior of the standard Emacs 29873@kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k} 29874with no argument copies only the number itself into the kill ring, whereas 29875@kbd{C-k} with a prefix argument of 1 copies the number with its trailing 29876newline. 29877 29878@node Yanking Into Stack, Saving Into Registers, Killing From Stack, Kill and Yank 29879@section Yanking into the Stack 29880 29881@noindent 29882@kindex C-y 29883@pindex calc-yank 29884The @kbd{C-y} command yanks the most recently killed text back into the 29885Calculator. It pushes this value onto the top of the stack regardless of 29886the cursor position. In general it re-parses the killed text as a number 29887or formula (or a list of these separated by commas or newlines). However if 29888the thing being yanked is something that was just killed from the Calculator 29889itself, its full internal structure is yanked. For example, if you have 29890set the floating-point display mode to show only four significant digits, 29891then killing and re-yanking 3.14159 (which displays as 3.142) will yank the 29892full 3.14159, even though yanking it into any other buffer would yank the 29893number in its displayed form, 3.142. (Since the default display modes 29894show all objects to their full precision, this feature normally makes no 29895difference.) 29896 29897The @kbd{C-y} command can be given a prefix, which will interpret the 29898text being yanked with a different radix. If the text being yanked can be 29899interpreted as a binary, octal, hexadecimal, or decimal number, then a 29900prefix of @kbd{2}, @kbd{8}, @kbd{6} or @kbd{0} will have Calc 29901interpret the yanked text as a number in the appropriate base. For example, 29902if @samp{111} has just been killed and is yanked into Calc with a command 29903of @kbd{C-2 C-y}, then the number @samp{7} will be put on the stack. 29904If you use the plain prefix @kbd{C-u}, then you will be prompted for a 29905base to use, which can be any integer from 2 to 36. If Calc doesn't 29906allow the text being yanked to be read in a different base (such as if 29907the text is an algebraic expression), then the prefix will have no 29908effect. 29909 29910@node Saving Into Registers, Inserting From Registers, Yanking Into Stack, Kill and Yank 29911@section Saving into Registers 29912 29913@noindent 29914@kindex r s 29915@pindex calc-copy-to-register 29916@pindex calc-prepend-to-register 29917@pindex calc-append-to-register 29918@cindex Registers 29919An alternative to killing and yanking stack entries is using 29920registers in Calc. Saving stack entries in registers is like 29921saving text in normal Emacs registers; although, like Calc's kill 29922commands, register commands always operate on whole stack 29923entries. 29924 29925Registers in Calc are places to store stack entries for later use; 29926each register is indexed by a single character. To store the current 29927region (rounded up, of course, to include full stack entries) into a 29928register, use the command @kbd{r s} (@code{calc-copy-to-register}). 29929You will then be prompted for a register to use, the next character 29930you type will be the index for the register. To store the region in 29931register @var{r}, the full command will be @kbd{r s @var{r}}. With an 29932argument, @kbd{C-u r s @var{r}}, the region being copied to the 29933register will be deleted from the Calc buffer. 29934 29935It is possible to add additional stack entries to a register. The 29936command @kbd{M-x calc-append-to-register} will prompt for a register, 29937then add the stack entries in the region to the end of the register 29938contents. The command @kbd{M-x calc-prepend-to-register} will 29939similarly prompt for a register and add the stack entries in the 29940region to the beginning of the register contents. Both commands take 29941@kbd{C-u} arguments, which will cause the region to be deleted after being 29942added to the register. 29943 29944@node Inserting From Registers, Grabbing From Buffers, Saving Into Registers, Kill and Yank 29945@section Inserting from Registers 29946@noindent 29947@kindex r i 29948@pindex calc-insert-register 29949The command @kbd{r i} (@code{calc-insert-register}) will prompt for a 29950register, then insert the contents of that register into the 29951Calculator. If the contents of the register were placed there from 29952within Calc, then the full internal structure of the contents will be 29953inserted into the Calculator, otherwise whatever text is in the 29954register is reparsed and then inserted into the Calculator. 29955 29956@node Grabbing From Buffers, Yanking Into Buffers, Inserting From Registers, Kill and Yank 29957@section Grabbing from Other Buffers 29958 29959@noindent 29960@kindex C-x * g 29961@pindex calc-grab-region 29962The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between 29963point and mark in the current buffer and attempts to parse it as a 29964vector of values. Basically, it wraps the text in vector brackets 29965@samp{[ ]} unless the text already is enclosed in vector brackets, 29966then reads the text as if it were an algebraic entry. The contents 29967of the vector may be numbers, formulas, or any other Calc objects. 29968If the @kbd{C-x * g} command works successfully, it does an automatic 29969@kbd{C-x * c} to enter the Calculator buffer. 29970 29971A numeric prefix argument grabs the specified number of lines around 29972point, ignoring the mark. A positive prefix grabs from point to the 29973@expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point 29974to the end of the current line); a negative prefix grabs from point 29975back to the @expr{n+1}st preceding newline. In these cases the text 29976that is grabbed is exactly the same as the text that @kbd{C-k} would 29977delete given that prefix argument. 29978 29979A prefix of zero grabs the current line; point may be anywhere on the 29980line. 29981 29982A plain @kbd{C-u} prefix interprets the region between point and mark 29983as a single number or formula rather than a vector. For example, 29984@kbd{C-x * g} on the text @samp{2 a b} produces the vector of three 29985values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region 29986reads a formula which is a product of three things: @samp{2 a b}. 29987(The text @samp{a + b}, on the other hand, will be grabbed as a 29988vector of one element by plain @kbd{C-x * g} because the interpretation 29989@samp{[a, +, b]} would be a syntax error.) 29990 29991If a different language has been specified (@pxref{Language Modes}), 29992the grabbed text will be interpreted according to that language. 29993 29994@kindex C-x * r 29995@pindex calc-grab-rectangle 29996The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between 29997point and mark and attempts to parse it as a matrix. If point and mark 29998are both in the leftmost column, the lines in between are parsed in their 29999entirety. Otherwise, point and mark define the corners of a rectangle 30000whose contents are parsed. 30001 30002Each line of the grabbed area becomes a row of the matrix. The result 30003will actually be a vector of vectors, which Calc will treat as a matrix 30004only if every row contains the same number of values. 30005 30006If a line contains a portion surrounded by square brackets (or curly 30007braces), that portion is interpreted as a vector which becomes a row 30008of the matrix. Any text surrounding the bracketed portion on the line 30009is ignored. 30010 30011Otherwise, the entire line is interpreted as a row vector as if it 30012were surrounded by square brackets. Leading line numbers (in the 30013format used in the Calc stack buffer) are ignored. If you wish to 30014force this interpretation (even if the line contains bracketed 30015portions), give a negative numeric prefix argument to the 30016@kbd{C-x * r} command. 30017 30018If you give a numeric prefix argument of zero or plain @kbd{C-u}, each 30019line is instead interpreted as a single formula which is converted into 30020a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a 30021one-column matrix. For example, suppose one line of the data is the 30022expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as 30023@samp{[2 a]}, which in turn is read as a two-element vector that forms 30024one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row 30025as @samp{[2*a]}. 30026 30027If you give a positive numeric prefix argument @var{n}, then each line 30028will be split up into columns of width @var{n}; each column is parsed 30029separately as a matrix element. If a line contained 30030@w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8 30031would correctly split the line into two error forms. 30032 30033@xref{Matrix Functions}, to see how to pull the matrix apart into its 30034constituent rows and columns. (If it is a 30035@texline @math{1\times1} 30036@infoline 1x1 30037matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.) 30038 30039@kindex C-x * : 30040@kindex C-x * _ 30041@pindex calc-grab-sum-across 30042@pindex calc-grab-sum-down 30043@cindex Summing rows and columns of data 30044The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to 30045grab a rectangle of data and sum its columns. It is equivalent to 30046typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction 30047command that sums the columns of a matrix; @pxref{Reducing}). The 30048result of the command will be a vector of numbers, one for each column 30049in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command 30050similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}. 30051 30052As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also 30053much faster because they don't actually place the grabbed vector on 30054the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector 30055for display on the stack takes a large fraction of the total time 30056(unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes). 30057 30058For example, suppose we have a column of numbers in a file which we 30059wish to sum. Go to one corner of the column and press @kbd{C-@@} to 30060set the mark; go to the other corner and type @kbd{C-x * :}. Since there 30061is only one column, the result will be a vector of one number, the sum. 30062(You can type @kbd{v u} to unpack this vector into a plain number if 30063you want to do further arithmetic with it.) 30064 30065To compute the product of the column of numbers, we would have to do 30066it ``by hand'' since there's no special grab-and-multiply command. 30067Use @kbd{C-x * r} to grab the column of numbers into the calculator in 30068the form of a column matrix. The statistics command @kbd{u *} is a 30069handy way to find the product of a vector or matrix of numbers. 30070@xref{Statistical Operations}. Another approach would be to use 30071an explicit column reduction command, @kbd{V R : *}. 30072 30073@node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank 30074@section Yanking into Other Buffers 30075 30076@noindent 30077@kindex y 30078@pindex calc-copy-to-buffer 30079The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number 30080at the top of the stack into the most recently used normal editing buffer. 30081(More specifically, this is the most recently used buffer which is displayed 30082in a window and whose name does not begin with @samp{*}. If there is no 30083such buffer, this is the most recently used buffer except for Calculator 30084and Calc Trail buffers.) The number is inserted exactly as it appears and 30085without a newline. (If line-numbering is enabled, the line number is 30086normally not included.) The number is @emph{not} removed from the stack. 30087 30088With a prefix argument, @kbd{y} inserts several numbers, one per line. 30089A positive argument inserts the specified number of values from the top 30090of the stack. A negative argument inserts the @expr{n}th value from the 30091top of the stack. An argument of zero inserts the entire stack. Note 30092that @kbd{y} with an argument of 1 is slightly different from @kbd{y} 30093with no argument; the former always copies full lines, whereas the 30094latter strips off the trailing newline. 30095 30096With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the 30097region in the other buffer with the yanked text, then quits the 30098Calculator, leaving you in that buffer. A typical use would be to use 30099@kbd{C-x * g} to read a region of data into the Calculator, operate on the 30100data to produce a new matrix, then type @kbd{C-u y} to replace the 30101original data with the new data. One might wish to alter the matrix 30102display style (@pxref{Vector and Matrix Formats}) or change the current 30103display language (@pxref{Language Modes}) before doing this. Also, note 30104that this command replaces a linear region of text (as grabbed by 30105@kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}). 30106 30107If the editing buffer is in overwrite (as opposed to insert) mode, 30108and the @kbd{C-u} prefix was not used, then the yanked number will 30109overwrite the characters following point rather than being inserted 30110before those characters. The usual conventions of overwrite mode 30111are observed; for example, characters will be inserted at the end of 30112a line rather than overflowing onto the next line. Yanking a multi-line 30113object such as a matrix in overwrite mode overwrites the next @var{n} 30114lines in the buffer, lengthening or shortening each line as necessary. 30115Finally, if the thing being yanked is a simple integer or floating-point 30116number (like @samp{-1.2345e-3}) and the characters following point also 30117make up such a number, then Calc will replace that number with the new 30118number, lengthening or shortening as necessary. The concept of 30119``overwrite mode'' has thus been generalized from overwriting characters 30120to overwriting one complete number with another. 30121 30122@kindex C-x * y 30123The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that 30124it can be typed anywhere, not just in Calc. This provides an easy 30125way to guarantee that Calc knows which editing buffer you want to use! 30126 30127@node X Cut and Paste, , Yanking Into Buffers, Kill and Yank 30128@section X Cut and Paste 30129 30130@noindent 30131If you are using Emacs with the X window system, there is an easier 30132way to move small amounts of data into and out of the calculator: 30133Use the mouse-oriented cut and paste facilities of X. 30134 30135The default bindings for a three-button mouse cause the left button 30136to move the Emacs cursor to the given place, the right button to 30137select the text between the cursor and the clicked location, and 30138the middle button to yank the selection into the buffer at the 30139clicked location. So, if you have a Calc window and an editing 30140window on your Emacs screen, you can use left-click/right-click 30141to select a number, vector, or formula from one window, then 30142middle-click to paste that value into the other window. When you 30143paste text into the Calc window, Calc interprets it as an algebraic 30144entry. It doesn't matter where you click in the Calc window; the 30145new value is always pushed onto the top of the stack. 30146 30147The @code{xterm} program that is typically used for general-purpose 30148shell windows in X interprets the mouse buttons in the same way. 30149So you can use the mouse to move data between Calc and any other 30150Unix program. One nice feature of @code{xterm} is that a double 30151left-click selects one word, and a triple left-click selects a 30152whole line. So you can usually transfer a single number into Calc 30153just by double-clicking on it in the shell, then middle-clicking 30154in the Calc window. 30155 30156@node Keypad Mode, Embedded Mode, Kill and Yank, Top 30157@chapter Keypad Mode 30158 30159@noindent 30160@kindex C-x * k 30161@pindex calc-keypad 30162The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator 30163and displays a picture of a calculator-style keypad. If you are using 30164the X window system, you can click on any of the ``keys'' in the 30165keypad using the left mouse button to operate the calculator. 30166The original window remains the selected window; in Keypad mode 30167you can type in your file while simultaneously performing 30168calculations with the mouse. 30169 30170@pindex full-calc-keypad 30171If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes 30172the @code{full-calc-keypad} command, which takes over the whole 30173Emacs screen and displays the keypad, the Calc stack, and the Calc 30174trail all at once. This mode would normally be used when running 30175Calc standalone (@pxref{Standalone Operation}). 30176 30177If you aren't using the X window system, you must switch into 30178the @file{*Calc Keypad*} window, place the cursor on the desired 30179``key,'' and type @key{SPC} or @key{RET}. If you think this 30180is easier than using Calc normally, go right ahead. 30181 30182Calc commands are more or less the same in Keypad mode. Certain 30183keypad keys differ slightly from the corresponding normal Calc 30184keystrokes; all such deviations are described below. 30185 30186Keypad mode includes many more commands than will fit on the keypad 30187at once. Click the right mouse button [@code{calc-keypad-menu}] 30188to switch to the next menu. The bottom five rows of the keypad 30189stay the same; the top three rows change to a new set of commands. 30190To return to earlier menus, click the middle mouse button 30191[@code{calc-keypad-menu-back}] or simply advance through the menus 30192until you wrap around. Typing @key{TAB} inside the keypad window 30193is equivalent to clicking the right mouse button there. 30194 30195You can always click the @key{EXEC} button and type any normal 30196Calc key sequence. This is equivalent to switching into the 30197Calc buffer, typing the keys, then switching back to your 30198original buffer. 30199 30200@menu 30201* Keypad Main Menu:: 30202* Keypad Functions Menu:: 30203* Keypad Binary Menu:: 30204* Keypad Vectors Menu:: 30205* Keypad Modes Menu:: 30206@end menu 30207 30208@node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode 30209@section Main Menu 30210 30211@smallexample 30212@group 30213|----+----+--Calc---+----+----1 30214|FLR |CEIL|RND |TRNC|CLN2|FLT | 30215|----+----+----+----+----+----| 30216| LN |EXP | |ABS |IDIV|MOD | 30217|----+----+----+----+----+----| 30218|SIN |COS |TAN |SQRT|y^x |1/x | 30219|----+----+----+----+----+----| 30220| ENTER |+/- |EEX |UNDO| <- | 30221|-----+---+-+--+--+-+---++----| 30222| INV | 7 | 8 | 9 | / | 30223|-----+-----+-----+-----+-----| 30224| HYP | 4 | 5 | 6 | * | 30225|-----+-----+-----+-----+-----| 30226|EXEC | 1 | 2 | 3 | - | 30227|-----+-----+-----+-----+-----| 30228| OFF | 0 | . | PI | + | 30229|-----+-----+-----+-----+-----+ 30230@end group 30231@end smallexample 30232 30233@noindent 30234This is the menu that appears the first time you start Keypad mode. 30235It will show up in a vertical window on the right side of your screen. 30236Above this menu is the traditional Calc stack display. On a 24-line 30237screen you will be able to see the top three stack entries. 30238 30239The ten digit keys, decimal point, and @key{EEX} key are used for 30240entering numbers in the obvious way. @key{EEX} begins entry of an 30241exponent in scientific notation. Just as with regular Calc, the 30242number is pushed onto the stack as soon as you press @key{ENTER} 30243or any other function key. 30244 30245The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During 30246numeric entry it changes the sign of the number or of the exponent. 30247At other times it changes the sign of the number on the top of the 30248stack. 30249 30250The @key{INV} and @key{HYP} keys modify other keys. As well as 30251having the effects described elsewhere in this manual, Keypad mode 30252defines several other ``inverse'' operations. These are described 30253below and in the following sections. 30254 30255The @key{ENTER} key finishes the current numeric entry, or otherwise 30256duplicates the top entry on the stack. 30257 30258The @key{UNDO} key undoes the most recent Calc operation. 30259@kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is 30260``last arguments'' (@kbd{M-@key{RET}}). 30261 30262The @key{<-} key acts as a ``backspace'' during numeric entry. 30263At other times it removes the top stack entry. @kbd{INV <-} 30264clears the entire stack. @kbd{HYP <-} takes an integer from 30265the stack, then removes that many additional stack elements. 30266 30267The @key{EXEC} key prompts you to enter any keystroke sequence 30268that would normally work in Calc mode. This can include a 30269numeric prefix if you wish. It is also possible simply to 30270switch into the Calc window and type commands in it; there is 30271nothing ``magic'' about this window when Keypad mode is active. 30272 30273The other keys in this display perform their obvious calculator 30274functions. @key{CLN2} rounds the top-of-stack by temporarily 30275reducing the precision by 2 digits. @key{FLT} converts an 30276integer or fraction on the top of the stack to floating-point. 30277 30278The @key{INV} and @key{HYP} keys combined with several of these keys 30279give you access to some common functions even if the appropriate menu 30280is not displayed. Obviously you don't need to learn these keys 30281unless you find yourself wasting time switching among the menus. 30282 30283@table @kbd 30284@item INV +/- 30285is the same as @key{1/x}. 30286@item INV + 30287is the same as @key{SQRT}. 30288@item INV - 30289is the same as @key{CONJ}. 30290@item INV * 30291is the same as @key{y^x}. 30292@item INV / 30293is the same as @kbd{INV y^x} (the @expr{x}th root of @expr{y}). 30294@item HYP/INV 1 30295are the same as @key{SIN} / @kbd{INV SIN}. 30296@item HYP/INV 2 30297are the same as @key{COS} / @kbd{INV COS}. 30298@item HYP/INV 3 30299are the same as @key{TAN} / @kbd{INV TAN}. 30300@item INV/HYP 4 30301are the same as @key{LN} / @kbd{HYP LN}. 30302@item INV/HYP 5 30303are the same as @key{EXP} / @kbd{HYP EXP}. 30304@item INV 6 30305is the same as @key{ABS}. 30306@item INV 7 30307is the same as @key{RND} (@code{calc-round}). 30308@item INV 8 30309is the same as @key{CLN2}. 30310@item INV 9 30311is the same as @key{FLT} (@code{calc-float}). 30312@item INV 0 30313is the same as @key{IMAG}. 30314@item INV . 30315is the same as @key{PREC}. 30316@item INV ENTER 30317is the same as @key{SWAP}. 30318@item HYP ENTER 30319is the same as @key{RLL3}. 30320@item INV HYP ENTER 30321is the same as @key{OVER}. 30322@item HYP +/- 30323packs the top two stack entries as an error form. 30324@item HYP EEX 30325packs the top two stack entries as a modulo form. 30326@item INV EEX 30327creates an interval form; this removes an integer which is one 30328of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed 30329by the two limits of the interval. 30330@end table 30331 30332The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *} 30333again has the same effect. This is analogous to typing @kbd{q} or 30334hitting @kbd{C-x * c} again in the normal calculator. If Calc is 30335running standalone (the @code{full-calc-keypad} command appeared in the 30336command line that started Emacs), then @kbd{OFF} is replaced with 30337@kbd{EXIT}; clicking on this actually exits Emacs itself. 30338 30339@node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode 30340@section Functions Menu 30341 30342@smallexample 30343@group 30344|----+----+----+----+----+----2 30345|IGAM|BETA|IBET|ERF |BESJ|BESY| 30346|----+----+----+----+----+----| 30347|IMAG|CONJ| RE |ATN2|RAND|RAGN| 30348|----+----+----+----+----+----| 30349|GCD |FACT|DFCT|BNOM|PERM|NXTP| 30350|----+----+----+----+----+----| 30351@end group 30352@end smallexample 30353 30354@noindent 30355This menu provides various operations from the @kbd{f} and @kbd{k} 30356prefix keys. 30357 30358@key{IMAG} multiplies the number on the stack by the imaginary 30359number @expr{i = (0, 1)}. 30360 30361@key{RE} extracts the real part a complex number. @kbd{INV RE} 30362extracts the imaginary part. 30363 30364@key{RAND} takes a number from the top of the stack and computes 30365a random number greater than or equal to zero but less than that 30366number. (@xref{Random Numbers}.) @key{RAGN} is the ``random 30367again'' command; it computes another random number using the 30368same limit as last time. 30369 30370@kbd{INV GCD} computes the LCM (least common multiple) function. 30371 30372@kbd{INV FACT} is the gamma function. 30373@texline @math{\Gamma(x) = (x-1)!}. 30374@infoline @expr{gamma(x) = (x-1)!}. 30375 30376@key{PERM} is the number-of-permutations function, which is on the 30377@kbd{H k c} key in normal Calc. 30378 30379@key{NXTP} finds the next prime after a number. @kbd{INV NXTP} 30380finds the previous prime. 30381 30382@node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode 30383@section Binary Menu 30384 30385@smallexample 30386@group 30387|----+----+----+----+----+----3 30388|AND | OR |XOR |NOT |LSH |RSH | 30389|----+----+----+----+----+----| 30390|DEC |HEX |OCT |BIN |WSIZ|ARSH| 30391|----+----+----+----+----+----| 30392| A | B | C | D | E | F | 30393|----+----+----+----+----+----| 30394@end group 30395@end smallexample 30396 30397@noindent 30398The keys in this menu perform operations on binary integers. 30399Note that both logical and arithmetic right-shifts are provided. 30400@kbd{INV LSH} rotates one bit to the left. 30401 30402The ``difference'' function (normally on @kbd{b d}) is on @kbd{INV AND}. 30403The ``clip'' function (normally on @w{@kbd{b c}}) is on @kbd{INV NOT}. 30404 30405The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the 30406current radix for display and entry of numbers: Decimal, hexadecimal, 30407octal, or binary. The six letter keys @kbd{A} through @kbd{F} are used 30408for entering hexadecimal numbers. 30409 30410The @key{WSIZ} key displays the current word size for binary operations 30411and allows you to enter a new word size. You can respond to the prompt 30412using either the keyboard or the digits and @key{ENTER} from the keypad. 30413The initial word size is 32 bits. 30414 30415@node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode 30416@section Vectors Menu 30417 30418@smallexample 30419@group 30420|----+----+----+----+----+----4 30421|SUM |PROD|MAX |MAP*|MAP^|MAP$| 30422|----+----+----+----+----+----| 30423|MINV|MDET|MTRN|IDNT|CRSS|"x" | 30424|----+----+----+----+----+----| 30425|PACK|UNPK|INDX|BLD |LEN |... | 30426|----+----+----+----+----+----| 30427@end group 30428@end smallexample 30429 30430@noindent 30431The keys in this menu operate on vectors and matrices. 30432 30433@key{PACK} removes an integer @var{n} from the top of the stack; 30434the next @var{n} stack elements are removed and packed into a vector, 30435which is replaced onto the stack. Thus the sequence 30436@kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector 30437@samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row 30438on the stack as a vector, then use a final @key{PACK} to collect the 30439rows into a matrix. 30440 30441@key{UNPK} unpacks the vector on the stack, pushing each of its 30442components separately. 30443 30444@key{INDX} removes an integer @var{n}, then builds a vector of 30445integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers 30446from the stack: The vector size @var{n}, the starting number, 30447and the increment. @kbd{BLD} takes an integer @var{n} and any 30448value @var{x} and builds a vector of @var{n} copies of @var{x}. 30449 30450@key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n} 30451identity matrix. 30452 30453@key{LEN} replaces a vector by its length, an integer. 30454 30455@key{...} turns on or off ``abbreviated'' display mode for large vectors. 30456 30457@key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix 30458inverse, determinant, and transpose, and vector cross product. 30459 30460@key{SUM} replaces a vector by the sum of its elements. It is 30461equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}). 30462@key{PROD} computes the product of the elements of a vector, and 30463@key{MAX} computes the maximum of all the elements of a vector. 30464 30465@kbd{INV SUM} computes the alternating sum of the first element 30466minus the second, plus the third, minus the fourth, and so on. 30467@kbd{INV MAX} computes the minimum of the vector elements. 30468 30469@kbd{HYP SUM} computes the mean of the vector elements. 30470@kbd{HYP PROD} computes the sample standard deviation. 30471@kbd{HYP MAX} computes the median. 30472 30473@key{MAP*} multiplies two vectors elementwise. It is equivalent 30474to the @kbd{V M *} command. @key{MAP^} computes powers elementwise. 30475The arguments must be vectors of equal length, or one must be a vector 30476and the other must be a plain number. For example, @kbd{2 MAP^} squares 30477all the elements of a vector. 30478 30479@key{MAP$} maps the formula on the top of the stack across the 30480vector in the second-to-top position. If the formula contains 30481several variables, Calc takes that many vectors starting at the 30482second-to-top position and matches them to the variables in 30483alphabetical order. The result is a vector of the same size as 30484the input vectors, whose elements are the formula evaluated with 30485the variables set to the various sets of numbers in those vectors. 30486For example, you could simulate @key{MAP^} using @key{MAP$} with 30487the formula @samp{x^y}. 30488 30489The @kbd{"x"} key pushes the variable name @expr{x} onto the 30490stack. To build the formula @expr{x^2 + 6}, you would use the 30491key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be 30492suitable for use with the @key{MAP$} key described above. 30493With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the 30494@kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and 30495@expr{t}, respectively. 30496 30497@node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode 30498@section Modes Menu 30499 30500@smallexample 30501@group 30502|----+----+----+----+----+----5 30503|FLT |FIX |SCI |ENG |GRP | | 30504|----+----+----+----+----+----| 30505|RAD |DEG |FRAC|POLR|SYMB|PREC| 30506|----+----+----+----+----+----| 30507|SWAP|RLL3|RLL4|OVER|STO |RCL | 30508|----+----+----+----+----+----| 30509@end group 30510@end smallexample 30511 30512@noindent 30513The keys in this menu manipulate modes, variables, and the stack. 30514 30515The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select 30516floating-point, fixed-point, scientific, or engineering notation. 30517@key{FIX} displays two digits after the decimal by default; the 30518others display full precision. With the @key{INV} prefix, these 30519keys pop a number-of-digits argument from the stack. 30520 30521The @key{GRP} key turns grouping of digits with commas on or off. 30522@kbd{INV GRP} enables grouping to the right of the decimal point as 30523well as to the left. 30524 30525The @key{RAD} and @key{DEG} keys switch between radians and degrees 30526for trigonometric functions. 30527 30528The @key{FRAC} key turns Fraction mode on or off. This affects 30529whether commands like @kbd{/} with integer arguments produce 30530fractional or floating-point results. 30531 30532The @key{POLR} key turns Polar mode on or off, determining whether 30533polar or rectangular complex numbers are used by default. 30534 30535The @key{SYMB} key turns Symbolic mode on or off, in which 30536operations that would produce inexact floating-point results 30537are left unevaluated as algebraic formulas. 30538 30539The @key{PREC} key selects the current precision. Answer with 30540the keyboard or with the keypad digit and @key{ENTER} keys. 30541 30542The @key{SWAP} key exchanges the top two stack elements. 30543The @key{RLL3} key rotates the top three stack elements upwards. 30544The @key{RLL4} key rotates the top four stack elements upwards. 30545The @key{OVER} key duplicates the second-to-top stack element. 30546 30547The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and 30548@kbd{s r} in regular Calc. @xref{Store and Recall}. Click the 30549@key{STO} or @key{RCL} key, then one of the ten digits. (Named 30550variables are not available in Keypad mode.) You can also use, 30551for example, @kbd{STO + 3} to add to register 3. 30552 30553@node Embedded Mode, Programming, Keypad Mode, Top 30554@chapter Embedded Mode 30555 30556@noindent 30557Embedded mode in Calc provides an alternative to copying numbers 30558and formulas back and forth between editing buffers and the Calc 30559stack. In Embedded mode, your editing buffer becomes temporarily 30560linked to the stack and this copying is taken care of automatically. 30561 30562@menu 30563* Basic Embedded Mode:: 30564* More About Embedded Mode:: 30565* Assignments in Embedded Mode:: 30566* Mode Settings in Embedded Mode:: 30567* Customizing Embedded Mode:: 30568@end menu 30569 30570@node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode 30571@section Basic Embedded Mode 30572 30573@noindent 30574@kindex C-x * e 30575@pindex calc-embedded 30576To enter Embedded mode, position the Emacs point (cursor) on a 30577formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}). 30578Note that @kbd{C-x * e} is not to be used in the Calc stack buffer 30579like most Calc commands, but rather in regular editing buffers that 30580are visiting your own files. 30581 30582Calc will try to guess an appropriate language based on the major mode 30583of the editing buffer. (@xref{Language Modes}.) If the current buffer is 30584in @code{latex-mode}, for example, Calc will set its language to @LaTeX{}. 30585Similarly, Calc will use @TeX{} language for @code{tex-mode}, 30586@code{plain-tex-mode} and @code{context-mode}, C language for 30587@code{c-mode} and @code{c++-mode}, FORTRAN language for 30588@code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode}, 30589and eqn for @code{nroff-mode} (@pxref{Customizing Calc}). 30590These can be overridden with Calc's mode 30591changing commands (@pxref{Mode Settings in Embedded Mode}). If no 30592suitable language is available, Calc will continue with its current language. 30593 30594Calc normally scans backward and forward in the buffer for the 30595nearest opening and closing @dfn{formula delimiters}. The simplest 30596delimiters are blank lines. Other delimiters that Embedded mode 30597understands are: 30598 30599@enumerate 30600@item 30601The @TeX{} and @LaTeX{} math delimiters @samp{$ $}, @samp{$$ $$}, 30602@samp{\[ \]}, and @samp{\( \)}; 30603@item 30604Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters); 30605@item 30606Lines beginning with @samp{@@} (Texinfo delimiters). 30607@item 30608Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters); 30609@item 30610Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else. 30611@end enumerate 30612 30613@xref{Customizing Embedded Mode}, to see how to make Calc recognize 30614your own favorite delimiters. Delimiters like @samp{$ $} can appear 30615on their own separate lines or in-line with the formula. 30616 30617If you give a positive or negative numeric prefix argument, Calc 30618instead uses the current point as one end of the formula, and includes 30619that many lines forward or backward (respectively, including the current 30620line). Explicit delimiters are not necessary in this case. 30621 30622With a prefix argument of zero, Calc uses the current region (delimited 30623by point and mark) instead of formula delimiters. With a prefix 30624argument of @kbd{C-u} only, Calc uses the current line as the formula. 30625 30626@kindex C-x * w 30627@pindex calc-embedded-word 30628The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded 30629mode on the current ``word''; in this case Calc will scan for the first 30630non-numeric character (i.e., the first character that is not a digit, 30631sign, decimal point, or upper- or lower-case @samp{e}) forward and 30632backward to delimit the formula. 30633 30634When you enable Embedded mode for a formula, Calc reads the text 30635between the delimiters and tries to interpret it as a Calc formula. 30636Calc can generally identify @TeX{} formulas and 30637Big-style formulas even if the language mode is wrong. If Calc 30638can't make sense of the formula, it beeps and refuses to enter 30639Embedded mode. But if the current language is wrong, Calc can 30640sometimes parse the formula successfully (but incorrectly); 30641for example, the C expression @samp{atan(a[1])} can be parsed 30642in Normal language mode, but the @code{atan} won't correspond to 30643the built-in @code{arctan} function, and the @samp{a[1]} will be 30644interpreted as @samp{a} times the vector @samp{[1]}! 30645 30646If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded 30647formula which is blank, say with the cursor on the space between 30648the two delimiters @samp{$ $}, Calc will immediately prompt for 30649an algebraic entry. 30650 30651Only one formula in one buffer can be enabled at a time. If you 30652move to another area of the current buffer and give Calc commands, 30653Calc turns Embedded mode off for the old formula and then tries 30654to restart Embedded mode at the new position. Other buffers are 30655not affected by Embedded mode. 30656 30657When Embedded mode begins, Calc pushes the current formula onto 30658the stack. No Calc stack window is created; however, Calc copies 30659the top-of-stack position into the original buffer at all times. 30660You can create a Calc window by hand with @kbd{C-x * o} if you 30661find you need to see the entire stack. 30662 30663For example, typing @kbd{C-x * e} while somewhere in the formula 30664@samp{n>2} in the following line enables Embedded mode on that 30665inequality: 30666 30667@example 30668We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$. 30669@end example 30670 30671@noindent 30672The formula @expr{n>2} will be pushed onto the Calc stack, and 30673the top of stack will be copied back into the editing buffer. 30674This means that spaces will appear around the @samp{>} symbol 30675to match Calc's usual display style: 30676 30677@example 30678We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$. 30679@end example 30680 30681@noindent 30682No spaces have appeared around the @samp{+} sign because it's 30683in a different formula, one which we have not yet touched with 30684Embedded mode. 30685 30686Now that Embedded mode is enabled, keys you type in this buffer 30687are interpreted as Calc commands. At this point we might use 30688the ``commute'' command @kbd{j C} to reverse the inequality. 30689This is a selection-based command for which we first need to 30690move the cursor onto the operator (@samp{>} in this case) that 30691needs to be commuted. 30692 30693@example 30694We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$. 30695@end example 30696 30697The @kbd{C-x * o} command is a useful way to open a Calc window 30698without actually selecting that window. Giving this command 30699verifies that @samp{2 < n} is also on the Calc stack. Typing 30700@kbd{17 @key{RET}} would produce: 30701 30702@example 30703We define $F_n = F_(n-1)+F_(n-2)$ for all $17$. 30704@end example 30705 30706@noindent 30707with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB} 30708at this point will exchange the two stack values and restore 30709@samp{2 < n} to the embedded formula. Even though you can't 30710normally see the stack in Embedded mode, it is still there and 30711it still operates in the same way. But, as with old-fashioned 30712RPN calculators, you can only see the value at the top of the 30713stack at any given time (unless you use @kbd{C-x * o}). 30714 30715Typing @kbd{C-x * e} again turns Embedded mode off. The Calc 30716window reveals that the formula @w{@samp{2 < n}} is automatically 30717removed from the stack, but the @samp{17} is not. Entering 30718Embedded mode always pushes one thing onto the stack, and 30719leaving Embedded mode always removes one thing. Anything else 30720that happens on the stack is entirely your business as far as 30721Embedded mode is concerned. 30722 30723If you press @kbd{C-x * e} in the wrong place by accident, it is 30724possible that Calc will be able to parse the nearby text as a 30725formula and will mangle that text in an attempt to redisplay it 30726``properly'' in the current language mode. If this happens, 30727press @kbd{C-x * e} again to exit Embedded mode, then give the 30728regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put 30729the text back the way it was before Calc edited it. Note that Calc's 30730own Undo command (typed before you turn Embedded mode back off) 30731will not do you any good, because as far as Calc is concerned 30732you haven't done anything with this formula yet. 30733 30734@node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode 30735@section More About Embedded Mode 30736 30737@noindent 30738When Embedded mode ``activates'' a formula, i.e., when it examines 30739the formula for the first time since the buffer was created or 30740loaded, Calc tries to sense the language in which the formula was 30741written. If the formula contains any @LaTeX{}-like @samp{\} sequences, 30742it is parsed (i.e., read) in @LaTeX{} mode. If the formula appears to 30743be written in multi-line Big mode, it is parsed in Big mode. Otherwise, 30744it is parsed according to the current language mode. 30745 30746Note that Calc does not change the current language mode according 30747the formula it reads in. Even though it can read a @LaTeX{} formula when 30748not in @LaTeX{} mode, it will immediately rewrite this formula using 30749whatever language mode is in effect. 30750 30751@tex 30752\bigskip 30753@end tex 30754 30755@kindex d p 30756@pindex calc-show-plain 30757Calc's parser is unable to read certain kinds of formulas. For 30758example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can 30759specify matrix display styles which the parser is unable to 30760recognize as matrices. The @kbd{d p} (@code{calc-show-plain}) 30761command turns on a mode in which a ``plain'' version of a 30762formula is placed in front of the fully-formatted version. 30763When Calc reads a formula that has such a plain version in 30764front, it reads the plain version and ignores the formatted 30765version. 30766 30767Plain formulas are preceded and followed by @samp{%%%} signs 30768by default. This notation has the advantage that the @samp{%} 30769character begins a comment in @TeX{} and @LaTeX{}, so if your formula is 30770embedded in a @TeX{} or @LaTeX{} document its plain version will be 30771invisible in the final printed copy. Certain major modes have different 30772delimiters to ensure that the ``plain'' version will be 30773in a comment for those modes, also. 30774See @ref{Customizing Embedded Mode} to see how to change the ``plain'' 30775formula delimiters. 30776 30777There are several notations which Calc's parser for ``big'' 30778formatted formulas can't yet recognize. In particular, it can't 30779read the large symbols for @code{sum}, @code{prod}, and @code{integ}, 30780and it can't handle @samp{=>} with the righthand argument omitted. 30781Also, Calc won't recognize special formats you have defined with 30782the @kbd{Z C} command (@pxref{User-Defined Compositions}). In 30783these cases it is important to use ``plain'' mode to make sure 30784Calc will be able to read your formula later. 30785 30786Another example where ``plain'' mode is important is if you have 30787specified a float mode with few digits of precision. Normally 30788any digits that are computed but not displayed will simply be 30789lost when you save and re-load your embedded buffer, but ``plain'' 30790mode allows you to make sure that the complete number is present 30791in the file as well as the rounded-down number. 30792 30793@tex 30794\bigskip 30795@end tex 30796 30797Embedded buffers remember active formulas for as long as they 30798exist in Emacs memory. Suppose you have an embedded formula 30799which is @cpi{} to the normal 12 decimal places, and then 30800type @w{@kbd{C-u 5 d n}} to display only five decimal places. 30801If you then type @kbd{d n}, all 12 places reappear because the 30802full number is still there on the Calc stack. More surprisingly, 30803even if you exit Embedded mode and later re-enter it for that 30804formula, typing @kbd{d n} will restore all 12 places because 30805each buffer remembers all its active formulas. However, if you 30806save the buffer in a file and reload it in a new Emacs session, 30807all non-displayed digits will have been lost unless you used 30808``plain'' mode. 30809 30810@tex 30811\bigskip 30812@end tex 30813 30814In some applications of Embedded mode, you will want to have a 30815sequence of copies of a formula that show its evolution as you 30816work on it. For example, you might want to have a sequence 30817like this in your file (elaborating here on the example from 30818the ``Getting Started'' chapter): 30819 30820@smallexample 30821The derivative of 30822 30823 ln(ln(x)) 30824 30825is 30826 30827 @r{(the derivative of }ln(ln(x))@r{)} 30828 30829whose value at x = 2 is 30830 30831 @r{(the value)} 30832 30833and at x = 3 is 30834 30835 @r{(the value)} 30836@end smallexample 30837 30838@kindex C-x * d 30839@pindex calc-embedded-duplicate 30840The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a 30841handy way to make sequences like this. If you type @kbd{C-x * d}, 30842the formula under the cursor (which may or may not have Embedded 30843mode enabled for it at the time) is copied immediately below and 30844Embedded mode is then enabled for that copy. 30845 30846For this example, you would start with just 30847 30848@smallexample 30849The derivative of 30850 30851 ln(ln(x)) 30852@end smallexample 30853 30854@noindent 30855and press @kbd{C-x * d} with the cursor on this formula. The result 30856is 30857 30858@smallexample 30859The derivative of 30860 30861 ln(ln(x)) 30862 30863 30864 ln(ln(x)) 30865@end smallexample 30866 30867@noindent 30868with the second copy of the formula enabled in Embedded mode. 30869You can now press @kbd{a d x @key{RET}} to take the derivative, and 30870@kbd{C-x * d C-x * d} to make two more copies of the derivative. 30871To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate 30872the last formula, then move up to the second-to-last formula 30873and type @kbd{2 s l x @key{RET}}. 30874 30875Finally, you would want to press @kbd{C-x * e} to exit Embedded 30876mode, then go up and insert the necessary text in between the 30877various formulas and numbers. 30878 30879@tex 30880\bigskip 30881@end tex 30882 30883@kindex C-x * f 30884@kindex C-x * ' 30885@pindex calc-embedded-new-formula 30886The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command 30887creates a new embedded formula at the current point. It inserts 30888some default delimiters, which are usually just blank lines, 30889and then does an algebraic entry to get the formula (which is 30890then enabled for Embedded mode). This is just shorthand for 30891typing the delimiters yourself, positioning the cursor between 30892the new delimiters, and pressing @kbd{C-x * e}. The key sequence 30893@kbd{C-x * '} is equivalent to @kbd{C-x * f}. 30894 30895@kindex C-x * n 30896@kindex C-x * p 30897@pindex calc-embedded-next 30898@pindex calc-embedded-previous 30899The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p} 30900(@code{calc-embedded-previous}) commands move the cursor to the 30901next or previous active embedded formula in the buffer. They 30902can take positive or negative prefix arguments to move by several 30903formulas. Note that these commands do not actually examine the 30904text of the buffer looking for formulas; they only see formulas 30905which have previously been activated in Embedded mode. In fact, 30906@kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which 30907embedded formulas are currently active. Also, note that these 30908commands do not enable Embedded mode on the next or previous 30909formula, they just move the cursor. 30910 30911@kindex C-x * ` 30912@pindex calc-embedded-edit 30913The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the 30914embedded formula at the current point as if by @kbd{`} (@code{calc-edit}). 30915Embedded mode does not have to be enabled for this to work. Press 30916@kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel. 30917 30918@node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode 30919@section Assignments in Embedded Mode 30920 30921@noindent 30922The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators 30923are especially useful in Embedded mode. They allow you to make 30924a definition in one formula, then refer to that definition in 30925other formulas embedded in the same buffer. 30926 30927An embedded formula which is an assignment to a variable, as in 30928 30929@example 30930foo := 5 30931@end example 30932 30933@noindent 30934records @expr{5} as the stored value of @code{foo} for the 30935purposes of Embedded mode operations in the current buffer. It 30936does @emph{not} actually store @expr{5} as the ``global'' value 30937of @code{foo}, however. Regular Calc operations, and Embedded 30938formulas in other buffers, will not see this assignment. 30939 30940One way to use this assigned value is simply to create an 30941Embedded formula elsewhere that refers to @code{foo}, and to press 30942@kbd{=} in that formula. However, this permanently replaces the 30943@code{foo} in the formula with its current value. More interesting 30944is to use @samp{=>} elsewhere: 30945 30946@example 30947foo + 7 => 12 30948@end example 30949 30950@xref{Evaluates-To Operator}, for a general discussion of @samp{=>}. 30951 30952If you move back and change the assignment to @code{foo}, any 30953@samp{=>} formulas which refer to it are automatically updated. 30954 30955@example 30956foo := 17 30957 30958foo + 7 => 24 30959@end example 30960 30961The obvious question then is, @emph{how} can one easily change the 30962assignment to @code{foo}? If you simply select the formula in 30963Embedded mode and type 17, the assignment itself will be replaced 30964by the 17. The effect on the other formula will be that the 30965variable @code{foo} becomes unassigned: 30966 30967@example 3096817 30969 30970foo + 7 => foo + 7 30971@end example 30972 30973The right thing to do is first to use a selection command (@kbd{j 2} 30974will do the trick) to select the righthand side of the assignment. 30975Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting 30976Subformulas}, to see how this works). 30977 30978@kindex C-x * j 30979@pindex calc-embedded-select 30980The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an 30981easy way to operate on assignments. It is just like @kbd{C-x * e}, 30982except that if the enabled formula is an assignment, it uses 30983@kbd{j 2} to select the righthand side. If the enabled formula 30984is an evaluates-to, it uses @kbd{j 1} to select the lefthand side. 30985A formula can also be a combination of both: 30986 30987@example 30988bar := foo + 3 => 20 30989@end example 30990 30991@noindent 30992in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}). 30993 30994The formula is automatically deselected when you leave Embedded 30995mode. 30996 30997@kindex C-x * u 30998@pindex calc-embedded-update-formula 30999Another way to change the assignment to @code{foo} would simply be 31000to edit the number using regular Emacs editing rather than Embedded 31001mode. Then, we have to find a way to get Embedded mode to notice 31002the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula}) 31003command is a convenient way to do this. 31004 31005@example 31006foo := 6 31007 31008foo + 7 => 13 31009@end example 31010 31011Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that 31012is, temporarily enabling Embedded mode for the formula under the 31013cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does 31014not actually use @kbd{C-x * e}, and in fact another formula somewhere 31015else can be enabled in Embedded mode while you use @kbd{C-x * u} and 31016that formula will not be disturbed. 31017 31018With a numeric prefix argument, @kbd{C-x * u} updates all active 31019@samp{=>} formulas in the buffer. Formulas which have not yet 31020been activated in Embedded mode, and formulas which do not have 31021@samp{=>} as their top-level operator, are not affected by this. 31022(This is useful only if you have used @kbd{m C}; see below.) 31023 31024With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the 31025region between mark and point rather than in the whole buffer. 31026 31027@kbd{C-x * u} is also a handy way to activate a formula, such as an 31028@samp{=>} formula that has freshly been typed in or loaded from a 31029file. 31030 31031@kindex C-x * a 31032@pindex calc-embedded-activate 31033The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans 31034through the current buffer and activates all embedded formulas 31035that contain @samp{:=} or @samp{=>} symbols. This does not mean 31036that Embedded mode is actually turned on, but only that the 31037formulas' positions are registered with Embedded mode so that 31038the @samp{=>} values can be properly updated as assignments are 31039changed. 31040 31041It is a good idea to type @kbd{C-x * a} right after loading a file 31042that uses embedded @samp{=>} operators. Emacs includes a nifty 31043``buffer-local variables'' feature that you can use to do this 31044automatically. The idea is to place near the end of your file 31045a few lines that look like this: 31046 31047@example 31048--- Local Variables: --- 31049--- eval:(calc-embedded-activate) --- 31050--- End: --- 31051@end example 31052 31053@noindent 31054where the leading and trailing @samp{---} can be replaced by 31055any suitable strings (which must be the same on all three lines) 31056or omitted altogether; in a @TeX{} or @LaTeX{} file, @samp{%} would be a good 31057leading string and no trailing string would be necessary. In a 31058C program, @samp{/*} and @samp{*/} would be good leading and 31059trailing strings. 31060 31061When Emacs loads a file into memory, it checks for a Local Variables 31062section like this one at the end of the file. If it finds this 31063section, it does the specified things (in this case, running 31064@kbd{C-x * a} automatically) before editing of the file begins. 31065The Local Variables section must be within 3000 characters of the 31066end of the file for Emacs to find it, and it must be in the last 31067page of the file if the file has any page separators. 31068@xref{File Variables, , Local Variables in Files, emacs, the 31069Emacs manual}. 31070 31071Note that @kbd{C-x * a} does not update the formulas it finds. 31072To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}. 31073Generally this should not be a problem, though, because the 31074formulas will have been up-to-date already when the file was 31075saved. 31076 31077Normally, @kbd{C-x * a} activates all the formulas it finds, but 31078any previous active formulas remain active as well. With a 31079positive numeric prefix argument, @kbd{C-x * a} first deactivates 31080all current active formulas, then actives the ones it finds in 31081its scan of the buffer. With a negative prefix argument, 31082@kbd{C-x * a} simply deactivates all formulas. 31083 31084Embedded mode has two symbols, @samp{Active} and @samp{~Active}, 31085which it puts next to the major mode name in a buffer's mode line. 31086It puts @samp{Active} if it has reason to believe that all 31087formulas in the buffer are active, because you have typed @kbd{C-x * a} 31088and Calc has not since had to deactivate any formulas (which can 31089happen if Calc goes to update an @samp{=>} formula somewhere because 31090a variable changed, and finds that the formula is no longer there 31091due to some kind of editing outside of Embedded mode). Calc puts 31092@samp{~Active} in the mode line if some, but probably not all, 31093formulas in the buffer are active. This happens if you activate 31094a few formulas one at a time but never use @kbd{C-x * a}, or if you 31095used @kbd{C-x * a} but then Calc had to deactivate a formula 31096because it lost track of it. If neither of these symbols appears 31097in the mode line, no embedded formulas are active in the buffer 31098(e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}). 31099 31100Embedded formulas can refer to assignments both before and after them 31101in the buffer. If there are several assignments to a variable, the 31102nearest preceding assignment is used if there is one, otherwise the 31103following assignment is used. 31104 31105@example 31106x => 1 31107 31108x := 1 31109 31110x => 1 31111 31112x := 2 31113 31114x => 2 31115@end example 31116 31117As well as simple variables, you can also assign to subscript 31118expressions of the form @samp{@var{var}_@var{number}} (as in 31119@code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}). 31120Assignments to other kinds of objects can be represented by Calc, 31121but the automatic linkage between assignments and references works 31122only for plain variables and these two kinds of subscript expressions. 31123 31124If there are no assignments to a given variable, the global 31125stored value for the variable is used (@pxref{Storing Variables}), 31126or, if no value is stored, the variable is left in symbolic form. 31127Note that global stored values will be lost when the file is saved 31128and loaded in a later Emacs session, unless you have used the 31129@kbd{s p} (@code{calc-permanent-variable}) command to save them; 31130@pxref{Operations on Variables}. 31131 31132The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic 31133recomputation of @samp{=>} forms on and off. If you turn automatic 31134recomputation off, you will have to use @kbd{C-x * u} to update these 31135formulas manually after an assignment has been changed. If you 31136plan to change several assignments at once, it may be more efficient 31137to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u} 31138to update the entire buffer afterwards. The @kbd{m C} command also 31139controls @samp{=>} formulas on the stack; @pxref{Evaluates-To 31140Operator}. When you turn automatic recomputation back on, the 31141stack will be updated but the Embedded buffer will not; you must 31142use @kbd{C-x * u} to update the buffer by hand. 31143 31144@node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode 31145@section Mode Settings in Embedded Mode 31146 31147@kindex m e 31148@pindex calc-embedded-preserve-modes 31149@noindent 31150The mode settings can be changed while Calc is in embedded mode, but 31151by default they will revert to their original values when embedded mode 31152is ended. However, the modes saved when the mode-recording mode is 31153@code{Save} (see below) and the modes in effect when the @kbd{m e} 31154(@code{calc-embedded-preserve-modes}) command is given 31155will be preserved when embedded mode is ended. 31156 31157Embedded mode has a rather complicated mechanism for handling mode 31158settings in Embedded formulas. It is possible to put annotations 31159in the file that specify mode settings either global to the entire 31160file or local to a particular formula or formulas. In the latter 31161case, different modes can be specified for use when a formula 31162is the enabled Embedded mode formula. 31163 31164When you give any mode-setting command, like @kbd{m f} (for Fraction 31165mode) or @kbd{d s} (for scientific notation), Embedded mode adds 31166a line like the following one to the file just before the opening 31167delimiter of the formula. 31168 31169@example 31170% [calc-mode: fractions: t] 31171% [calc-mode: float-format: (sci 0)] 31172@end example 31173 31174When Calc interprets an embedded formula, it scans the text before 31175the formula for mode-setting annotations like these and sets the 31176Calc buffer to match these modes. Modes not explicitly described 31177in the file are not changed. Calc scans all the way to the top of 31178the file, or up to a line of the form 31179 31180@example 31181% [calc-defaults] 31182@end example 31183 31184@noindent 31185which you can insert at strategic places in the file if this backward 31186scan is getting too slow, or just to provide a barrier between one 31187``zone'' of mode settings and another. 31188 31189If the file contains several annotations for the same mode, the 31190closest one before the formula is used. Annotations after the 31191formula are never used (except for global annotations, described 31192below). 31193 31194The scan does not look for the leading @samp{% }, only for the 31195square brackets and the text they enclose. In fact, the leading 31196characters are different for different major modes. You can edit the 31197mode annotations to a style that works better in context if you wish. 31198@xref{Customizing Embedded Mode}, to see how to change the style 31199that Calc uses when it generates the annotations. You can write 31200mode annotations into the file yourself if you know the syntax; 31201the easiest way to find the syntax for a given mode is to let 31202Calc write the annotation for it once and see what it does. 31203 31204If you give a mode-changing command for a mode that already has 31205a suitable annotation just above the current formula, Calc will 31206modify that annotation rather than generating a new, conflicting 31207one. 31208 31209Mode annotations have three parts, separated by colons. (Spaces 31210after the colons are optional.) The first identifies the kind 31211of mode setting, the second is a name for the mode itself, and 31212the third is the value in the form of a Lisp symbol, number, 31213or list. Annotations with unrecognizable text in the first or 31214second parts are ignored. The third part is not checked to make 31215sure the value is of a valid type or range; if you write an 31216annotation by hand, be sure to give a proper value or results 31217will be unpredictable. Mode-setting annotations are case-sensitive. 31218 31219While Embedded mode is enabled, the word @code{Local} appears in 31220the mode line. This is to show that mode setting commands generate 31221annotations that are ``local'' to the current formula or set of 31222formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command 31223causes Calc to generate different kinds of annotations. Pressing 31224@kbd{m R} repeatedly cycles through the possible modes. 31225 31226@code{LocEdit} and @code{LocPerm} modes generate annotations 31227that look like this, respectively: 31228 31229@example 31230% [calc-edit-mode: float-format: (sci 0)] 31231% [calc-perm-mode: float-format: (sci 5)] 31232@end example 31233 31234The first kind of annotation will be used only while a formula 31235is enabled in Embedded mode. The second kind will be used only 31236when the formula is @emph{not} enabled. (Whether the formula 31237is ``active'' or not, i.e., whether Calc has seen this formula 31238yet, is not relevant here.) 31239 31240@code{Global} mode generates an annotation like this at the end 31241of the file: 31242 31243@example 31244% [calc-global-mode: fractions t] 31245@end example 31246 31247Global mode annotations affect all formulas throughout the file, 31248and may appear anywhere in the file. This allows you to tuck your 31249mode annotations somewhere out of the way, say, on a new page of 31250the file, as long as those mode settings are suitable for all 31251formulas in the file. 31252 31253Enabling a formula with @kbd{C-x * e} causes a fresh scan for local 31254mode annotations; you will have to use this after adding annotations 31255above a formula by hand to get the formula to notice them. Updating 31256a formula with @kbd{C-x * u} will also re-scan the local modes, but 31257global modes are only re-scanned by @kbd{C-x * a}. 31258 31259Another way that modes can get out of date is if you add a local 31260mode annotation to a formula that has another formula after it. 31261In this example, we have used the @kbd{d s} command while the 31262first of the two embedded formulas is active. But the second 31263formula has not changed its style to match, even though by the 31264rules of reading annotations the @samp{(sci 0)} applies to it, too. 31265 31266@example 31267% [calc-mode: float-format: (sci 0)] 312681.23e2 31269 31270456. 31271@end example 31272 31273We would have to go down to the other formula and press @kbd{C-x * u} 31274on it in order to get it to notice the new annotation. 31275 31276Two more mode-recording modes selectable by @kbd{m R} are available 31277which are also available outside of Embedded mode. 31278(@pxref{General Mode Commands}.) They are @code{Save}, in which mode 31279settings are recorded permanently in your Calc init file (the file given 31280by the variable @code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}) 31281rather than by annotating the current document, and no-recording 31282mode (where there is no symbol like @code{Save} or @code{Local} in 31283the mode line), in which mode-changing commands do not leave any 31284annotations at all. 31285 31286When Embedded mode is not enabled, mode-recording modes except 31287for @code{Save} have no effect. 31288 31289@node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode 31290@section Customizing Embedded Mode 31291 31292@noindent 31293You can modify Embedded mode's behavior by setting various Lisp 31294variables described here. These variables are customizable 31295(@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable} 31296to adjust a variable on the fly. 31297(Another possibility would be to use a file-local variable annotation at 31298the end of the file; 31299@pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.) 31300Many of the variables given mentioned here can be set to depend on the 31301major mode of the editing buffer (@pxref{Customizing Calc}). 31302 31303@vindex calc-embedded-open-formula 31304The @code{calc-embedded-open-formula} variable holds a regular 31305expression for the opening delimiter of a formula. @xref{Regexp Search, 31306, Regular Expression Search, emacs, the Emacs manual}, to see 31307how regular expressions work. Basically, a regular expression is a 31308pattern that Calc can search for. A regular expression that considers 31309blank lines, @samp{$}, and @samp{$$} to be opening delimiters is 31310@code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this 31311regular expression is not completely plain, let's go through it 31312in detail. 31313 31314The surrounding @samp{" "} marks quote the text between them as a 31315Lisp string. If you left them off, @code{set-variable} (for example) 31316would try to read the regular expression as a Lisp program. 31317 31318The most obvious property of this regular expression is that it 31319contains indecently many backslashes. There are actually two levels 31320of backslash usage going on here. First, when Lisp reads a quoted 31321string, all pairs of characters beginning with a backslash are 31322interpreted as special characters. Here, @code{\n} changes to a 31323new-line character, and @code{\\} changes to a single backslash. 31324So the actual regular expression seen by Calc is 31325@samp{\`\|^ @r{(newline)} \|\$\$?}. 31326 31327Regular expressions also consider pairs beginning with backslash 31328to have special meanings. Sometimes the backslash is used to quote 31329a character that otherwise would have a special meaning in a regular 31330expression, like @samp{$}, which normally means ``end-of-line,'' 31331or @samp{?}, which means that the preceding item is optional. So 31332@samp{\$\$?} matches either one or two dollar signs. 31333 31334The other codes in this regular expression are @samp{^}, which matches 31335``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`}, 31336which matches ``beginning-of-buffer.'' So the whole pattern means 31337that a formula begins at the beginning of the buffer, or on a newline 31338that occurs at the beginning of a line (i.e., a blank line), or at 31339one or two dollar signs. 31340 31341The default value of @code{calc-embedded-open-formula} looks just 31342like this example, with several more alternatives added on to 31343recognize various other common kinds of delimiters. 31344 31345By the way, the reason to use @samp{^\n} rather than @samp{^$} 31346or @samp{\n\n}, which also would appear to match blank lines, 31347is that the former expression actually ``consumes'' only one 31348newline character as @emph{part of} the delimiter, whereas the 31349latter expressions consume zero or two newlines, respectively. 31350The former choice gives the most natural behavior when Calc 31351must operate on a whole formula including its delimiters. 31352 31353See the Emacs manual for complete details on regular expressions. 31354But just for your convenience, here is a list of all characters 31355which must be quoted with backslash (like @samp{\$}) to avoid 31356some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note 31357the backslash in this list; for example, to match @samp{\[} you 31358must use @code{"\\\\\\["}. An exercise for the reader is to 31359account for each of these six backslashes!) 31360 31361@vindex calc-embedded-close-formula 31362The @code{calc-embedded-close-formula} variable holds a regular 31363expression for the closing delimiter of a formula. A closing 31364regular expression to match the above example would be 31365@code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the 31366other one, except it now uses @samp{\'} (``end-of-buffer'') and 31367@samp{\n$} (newline occurring at end of line, yet another way 31368of describing a blank line that is more appropriate for this 31369case). 31370 31371@vindex calc-embedded-word-regexp 31372The @code{calc-embedded-word-regexp} variable holds a regular expression 31373used to define an expression to look for (a ``word'') when you type 31374@kbd{C-x * w} to enable Embedded mode. 31375 31376@vindex calc-embedded-open-plain 31377The @code{calc-embedded-open-plain} variable is a string which 31378begins a ``plain'' formula written in front of the formatted 31379formula when @kbd{d p} mode is turned on. Note that this is an 31380actual string, not a regular expression, because Calc must be able 31381to write this string into a buffer as well as to recognize it. 31382The default string is @code{"%%% "} (note the trailing space), but may 31383be different for certain major modes. 31384 31385@vindex calc-embedded-close-plain 31386The @code{calc-embedded-close-plain} variable is a string which 31387ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be 31388different for different major modes. Without 31389the trailing newline here, the first line of a Big mode formula 31390that followed might be shifted over with respect to the other lines. 31391 31392@vindex calc-embedded-open-new-formula 31393The @code{calc-embedded-open-new-formula} variable is a string 31394which is inserted at the front of a new formula when you type 31395@kbd{C-x * f}. Its default value is @code{"\n\n"}. If this 31396string begins with a newline character and the @kbd{C-x * f} is 31397typed at the beginning of a line, @kbd{C-x * f} will skip this 31398first newline to avoid introducing unnecessary blank lines in 31399the file. 31400 31401@vindex calc-embedded-close-new-formula 31402The @code{calc-embedded-close-new-formula} variable is the corresponding 31403string which is inserted at the end of a new formula. Its default 31404value is also @code{"\n\n"}. The final newline is omitted by 31405@w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if 31406@kbd{C-x * f} is typed on a blank line, both a leading opening 31407newline and a trailing closing newline are omitted.) 31408 31409@vindex calc-embedded-announce-formula 31410The @code{calc-embedded-announce-formula} variable is a regular 31411expression which is sure to be followed by an embedded formula. 31412The @kbd{C-x * a} command searches for this pattern as well as for 31413@samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will 31414not activate just anything surrounded by formula delimiters; after 31415all, blank lines are considered formula delimiters by default! 31416But if your language includes a delimiter which can only occur 31417actually in front of a formula, you can take advantage of it here. 31418The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be 31419different for different major modes. 31420This pattern will check for @samp{%Embed} followed by any number of 31421lines beginning with @samp{%} and a space. This last is important to 31422make Calc consider mode annotations part of the pattern, so that the 31423formula's opening delimiter really is sure to follow the pattern. 31424 31425@vindex calc-embedded-open-mode 31426The @code{calc-embedded-open-mode} variable is a string (not a 31427regular expression) which should precede a mode annotation. 31428Calc never scans for this string; Calc always looks for the 31429annotation itself. But this is the string that is inserted before 31430the opening bracket when Calc adds an annotation on its own. 31431The default is @code{"% "}, but may be different for different major 31432modes. 31433 31434@vindex calc-embedded-close-mode 31435The @code{calc-embedded-close-mode} variable is a string which 31436follows a mode annotation written by Calc. Its default value 31437is simply a newline, @code{"\n"}, but may be different for different 31438major modes. If you change this, it is a good idea still to end with a 31439newline so that mode annotations will appear on lines by themselves. 31440 31441@node Programming, Copying, Embedded Mode, Top 31442@chapter Programming 31443 31444@noindent 31445There are several ways to ``program'' the Emacs Calculator, depending 31446on the nature of the problem you need to solve. 31447 31448@enumerate 31449@item 31450@dfn{Keyboard macros} allow you to record a sequence of keystrokes 31451and play them back at a later time. This is just the standard Emacs 31452keyboard macro mechanism, dressed up with a few more features such 31453as loops and conditionals. 31454 31455@item 31456@dfn{Algebraic definitions} allow you to use any formula to define a 31457new function. This function can then be used in algebraic formulas or 31458as an interactive command. 31459 31460@item 31461@dfn{Rewrite rules} are discussed in the section on algebra commands. 31462@xref{Rewrite Rules}. If you put your rewrite rules in the variable 31463@code{EvalRules}, they will be applied automatically to all Calc 31464results in just the same way as an internal ``rule'' is applied to 31465evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}. 31466 31467@item 31468@dfn{Lisp} is the programming language that Calc (and most of Emacs) 31469is written in. If the above techniques aren't powerful enough, you 31470can write Lisp functions to do anything that built-in Calc commands 31471can do. Lisp code is also somewhat faster than keyboard macros or 31472rewrite rules. 31473@end enumerate 31474 31475@kindex z 31476Programming features are available through the @kbd{z} and @kbd{Z} 31477prefix keys. New commands that you define are two-key sequences 31478beginning with @kbd{z}. Commands for managing these definitions 31479use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing}) 31480command is described elsewhere; @pxref{Troubleshooting Commands}. 31481The @kbd{Z C} (@code{calc-user-define-composition}) command is also 31482described elsewhere; @pxref{User-Defined Compositions}.) 31483 31484@menu 31485* Creating User Keys:: 31486* Keyboard Macros:: 31487* Invocation Macros:: 31488* Algebraic Definitions:: 31489* Lisp Definitions:: 31490@end menu 31491 31492@node Creating User Keys, Keyboard Macros, Programming, Programming 31493@section Creating User Keys 31494 31495@noindent 31496@kindex Z D 31497@pindex calc-user-define 31498Any Calculator command may be bound to a key using the @kbd{Z D} 31499(@code{calc-user-define}) command. Actually, it is bound to a two-key 31500sequence beginning with the lower-case @kbd{z} prefix. 31501 31502The @kbd{Z D} command first prompts for the key to define. For example, 31503press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then 31504prompted for the name of the Calculator command that this key should 31505run. For example, the @code{calc-sincos} command is not normally 31506available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the 31507@kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain 31508in effect for the rest of this Emacs session, or until you redefine 31509@kbd{z s} to be something else. 31510 31511You can actually bind any Emacs command to a @kbd{z} key sequence by 31512backspacing over the @samp{calc-} when you are prompted for the command name. 31513 31514As with any other prefix key, you can type @kbd{z ?} to see a list of 31515all the two-key sequences you have defined that start with @kbd{z}. 31516Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined. 31517 31518User keys are typically letters, but may in fact be any key. 31519(@key{META}-keys are not permitted, nor are a terminal's special 31520function keys which generate multi-character sequences when pressed.) 31521You can define different commands on the shifted and unshifted versions 31522of a letter if you wish. 31523 31524@kindex Z U 31525@pindex calc-user-undefine 31526The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key. 31527For example, the key sequence @kbd{Z U s} will undefine the @code{sincos} 31528key we defined above. 31529 31530@kindex Z P 31531@pindex calc-user-define-permanent 31532@cindex Storing user definitions 31533@cindex Permanent user definitions 31534@cindex Calc init file, user-defined commands 31535The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key 31536binding permanent so that it will remain in effect even in future Emacs 31537sessions. (It does this by adding a suitable bit of Lisp code into 31538your Calc init file; that is, the file given by the variable 31539@code{calc-settings-file}, typically @file{~/.emacs.d/calc.el}.) For example, 31540@kbd{Z P s} would register our @code{sincos} command permanently. If 31541you later wish to unregister this command you must edit your Calc init 31542file by hand. (@xref{General Mode Commands}, for a way to tell Calc to 31543use a different file for the Calc init file.) 31544 31545The @kbd{Z P} command also saves the user definition, if any, for the 31546command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user 31547key could invoke a command, which in turn calls an algebraic function, 31548which might have one or more special display formats. A single @kbd{Z P} 31549command will save all of these definitions. 31550To save an algebraic function, type @kbd{'} (the apostrophe) 31551when prompted for a key, and type the function name. To save a command 31552without its key binding, type @kbd{M-x} and enter a function name. (The 31553@samp{calc-} prefix will automatically be inserted for you.) 31554(If the command you give implies a function, the function will be saved, 31555and if the function has any display formats, those will be saved, but 31556not the other way around: Saving a function will not save any commands 31557or key bindings associated with the function.) 31558 31559@kindex Z E 31560@pindex calc-user-define-edit 31561@cindex Editing user definitions 31562The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition 31563of a user key. This works for keys that have been defined by either 31564keyboard macros or formulas; further details are contained in the relevant 31565following sections. 31566 31567@node Keyboard Macros, Invocation Macros, Creating User Keys, Programming 31568@section Programming with Keyboard Macros 31569 31570@noindent 31571@kindex X 31572@cindex Programming with keyboard macros 31573@cindex Keyboard macros 31574The easiest way to ``program'' the Emacs Calculator is to use standard 31575keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From 31576this point on, keystrokes you type will be saved away as well as 31577performing their usual functions. Press @kbd{C-x )} to end recording. 31578Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to 31579execute your keyboard macro by replaying the recorded keystrokes. 31580@xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further 31581information. 31582 31583When you use @kbd{X} to invoke a keyboard macro, the entire macro is 31584treated as a single command by the undo and trail features. The stack 31585display buffer is not updated during macro execution, but is instead 31586fixed up once the macro completes. Thus, commands defined with keyboard 31587macros are convenient and efficient. The @kbd{C-x e} command, on the 31588other hand, invokes the keyboard macro with no special treatment: Each 31589command in the macro will record its own undo information and trail entry, 31590and update the stack buffer accordingly. If your macro uses features 31591outside of Calc's control to operate on the contents of the Calc stack 31592buffer, or if it includes Undo, Redo, or last-arguments commands, you 31593must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date 31594at all times. You could also consider using @kbd{K} (@code{calc-keep-args}) 31595instead of @kbd{M-@key{RET}} (@code{calc-last-args}). 31596 31597Calc extends the standard Emacs keyboard macros in several ways. 31598Keyboard macros can be used to create user-defined commands. Keyboard 31599macros can include conditional and iteration structures, somewhat 31600analogous to those provided by a traditional programmable calculator. 31601 31602@menu 31603* Naming Keyboard Macros:: 31604* Conditionals in Macros:: 31605* Loops in Macros:: 31606* Local Values in Macros:: 31607* Queries in Macros:: 31608@end menu 31609 31610@node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros 31611@subsection Naming Keyboard Macros 31612 31613@noindent 31614@kindex Z K 31615@pindex calc-user-define-kbd-macro 31616Once you have defined a keyboard macro, you can bind it to a @kbd{z} 31617key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command. 31618This command prompts first for a key, then for a command name. For 31619example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will 31620define a keyboard macro which negates the top two numbers on the stack 31621(@key{TAB} swaps the top two stack elements). Now you can type 31622@kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key 31623sequence. The default command name (if you answer the second prompt with 31624just the @key{RET} key as in this example) will be something like 31625@samp{calc-User-n}. The keyboard macro will now be available as both 31626@kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more 31627descriptive command name if you wish. 31628 31629Macros defined by @kbd{Z K} act like single commands; they are executed 31630in the same way as by the @kbd{X} key. If you wish to define the macro 31631as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}), 31632give a negative prefix argument to @kbd{Z K}. 31633 31634Once you have bound your keyboard macro to a key, you can use 31635@kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}. 31636 31637@cindex Keyboard macros, editing 31638The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has 31639been defined by a keyboard macro tries to use the @code{edmacro} package 31640edit the macro. Type @kbd{C-c C-c} to finish editing and update 31641the definition stored on the key, or, to cancel the edit, kill the 31642buffer with @kbd{C-x k}. 31643The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, 31644@code{DEL}, and @code{NUL} must be entered as these three character 31645sequences, written in all uppercase, as must the prefixes @code{C-} and 31646@code{M-}. Spaces and line breaks are ignored. Other characters are 31647copied verbatim into the keyboard macro. Basically, the notation is the 31648same as is used in all of this manual's examples, except that the manual 31649takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}}, 31650we take it for granted that it is clear we really mean 31651@kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}. 31652 31653@kindex C-x * m 31654@pindex read-kbd-macro 31655The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region'' 31656of spelled-out keystrokes and defines it as the current keyboard macro. 31657It is a convenient way to define a keyboard macro that has been stored 31658in a file, or to define a macro without executing it at the same time. 31659 31660@node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros 31661@subsection Conditionals in Keyboard Macros 31662 31663@noindent 31664@kindex Z [ 31665@kindex Z ] 31666@pindex calc-kbd-if 31667@pindex calc-kbd-else 31668@pindex calc-kbd-else-if 31669@pindex calc-kbd-end-if 31670@cindex Conditional structures 31671The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if}) 31672commands allow you to put simple tests in a keyboard macro. When Calc 31673sees the @kbd{Z [}, it pops an object from the stack and, if the object is 31674a non-zero value, continues executing keystrokes. But if the object is 31675zero, or if it is not provably nonzero, Calc skips ahead to the matching 31676@kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for 31677performing tests which conveniently produce 1 for true and 0 for false. 31678 31679For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value 31680function in the form of a keyboard macro. This macro duplicates the 31681number on the top of the stack, pushes zero and compares using @kbd{a <} 31682(@code{calc-less-than}), then, if the number was less than zero, 31683executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign 31684command is skipped. 31685 31686To program this macro, type @kbd{C-x (}, type the above sequence of 31687keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be 31688executed while you are making the definition as well as when you later 31689re-execute the macro by typing @kbd{X}. Thus you should make sure a 31690suitable number is on the stack before defining the macro so that you 31691don't get a stack-underflow error during the definition process. 31692 31693Conditionals can be nested arbitrarily. However, there should be exactly 31694one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro. 31695 31696@kindex Z : 31697The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between 31698two keystroke sequences. The general format is @kbd{@var{cond} Z [ 31699@var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true 31700(i.e., if the top of stack contains a non-zero number after @var{cond} 31701has been executed), the @var{then-part} will be executed and the 31702@var{else-part} will be skipped. Otherwise, the @var{then-part} will 31703be skipped and the @var{else-part} will be executed. 31704 31705@kindex Z | 31706The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose 31707between any number of alternatives. For example, 31708@kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z : 31709@var{part3} Z ]} will execute @var{part1} if @var{cond1} is true, 31710otherwise it will execute @var{part2} if @var{cond2} is true, otherwise 31711it will execute @var{part3}. 31712 31713More precisely, @kbd{Z [} pops a number and conditionally skips to the 31714next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when 31715actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}. 31716@kbd{Z |} pops a number and conditionally skips to the next matching 31717@kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally 31718equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |} 31719does not. 31720 31721Calc's conditional and looping constructs work by scanning the 31722keyboard macro for occurrences of character sequences like @samp{Z:} 31723and @samp{Z]}. One side-effect of this is that if you use these 31724constructs you must be careful that these character pairs do not 31725occur by accident in other parts of the macros. Since Calc rarely 31726uses shift-@kbd{Z} for any purpose except as a prefix character, this 31727is not likely to be a problem. Another side-effect is that it will 31728not work to define your own custom key bindings for these commands. 31729Only the standard shift-@kbd{Z} bindings will work correctly. 31730 31731@kindex Z C-g 31732If Calc gets stuck while skipping characters during the definition of a 31733macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g} 31734actually adds a @kbd{C-g} keystroke to the macro.) 31735 31736@node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros 31737@subsection Loops in Keyboard Macros 31738 31739@noindent 31740@kindex Z < 31741@kindex Z > 31742@pindex calc-kbd-repeat 31743@pindex calc-kbd-end-repeat 31744@cindex Looping structures 31745@cindex Iterative structures 31746The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >} 31747(@code{calc-kbd-end-repeat}) commands pop a number from the stack, 31748which must be an integer, then repeat the keystrokes between the brackets 31749the specified number of times. If the integer is zero or negative, the 31750body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >} 31751computes two to a nonnegative integer power. First, we push 1 on the 31752stack and then swap the integer argument back to the top. The @kbd{Z <} 31753pops that argument leaving the 1 back on top of the stack. Then, we 31754repeat a multiply-by-two step however many times. 31755 31756Once again, the keyboard macro is executed as it is being entered. 31757In this case it is especially important to set up reasonable initial 31758conditions before making the definition: Suppose the integer 1000 just 31759happened to be sitting on the stack before we typed the above definition! 31760Another approach is to enter a harmless dummy definition for the macro, 31761then go back and edit in the real one with a @kbd{Z E} command. Yet 31762another approach is to type the macro as written-out keystroke names 31763in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the 31764macro. 31765 31766@kindex Z / 31767@pindex calc-break 31768The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out 31769of a keyboard macro loop prematurely. It pops an object from the stack; 31770if that object is true (a non-zero number), control jumps out of the 31771innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues 31772after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no 31773effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;} 31774in the C language. 31775 31776@kindex Z ( 31777@kindex Z ) 31778@pindex calc-kbd-for 31779@pindex calc-kbd-end-for 31780The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for}) 31781commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the 31782value of the counter available inside the loop. The general layout is 31783@kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (} 31784command pops initial and final values from the stack. It then creates 31785a temporary internal counter and initializes it with the value @var{init}. 31786The @kbd{Z (} command then repeatedly pushes the counter value onto the 31787stack and executes @var{body} and @var{step}, adding @var{step} to the 31788counter each time until the loop finishes. 31789 31790@cindex Summations (by keyboard macros) 31791By default, the loop finishes when the counter becomes greater than (or 31792less than) @var{final}, assuming @var{initial} is less than (greater 31793than) @var{final}. If @var{initial} is equal to @var{final}, the body 31794executes exactly once. The body of the loop always executes at least 31795once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the 31796squares of the integers from 1 to 10, in steps of 1. 31797 31798If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is 31799forced to use upward-counting conventions. In this case, if @var{initial} 31800is greater than @var{final} the body will not be executed at all. 31801Note that @var{step} may still be negative in this loop; the prefix 31802argument merely constrains the loop-finished test. Likewise, a prefix 31803argument of @mathit{-1} forces downward-counting conventions. 31804 31805@kindex Z @{ 31806@kindex Z @} 31807@pindex calc-kbd-loop 31808@pindex calc-kbd-end-loop 31809The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}} 31810(@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and 31811@kbd{Z >}, except that they do not pop a count from the stack---they 31812effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}} 31813loop ought to include at least one @kbd{Z /} to make sure the loop 31814doesn't run forever. (If any error message occurs which causes Emacs 31815to beep, the keyboard macro will also be halted; this is a standard 31816feature of Emacs. You can also generally press @kbd{C-g} to halt a 31817running keyboard macro, although not all versions of Unix support 31818this feature.) 31819 31820The conditional and looping constructs are not actually tied to 31821keyboard macros, but they are most often used in that context. 31822For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push 31823ten copies of 23 onto the stack. This can be typed ``live'' just 31824as easily as in a macro definition. 31825 31826@xref{Conditionals in Macros}, for some additional notes about 31827conditional and looping commands. 31828 31829@node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros 31830@subsection Local Values in Macros 31831 31832@noindent 31833@cindex Local variables 31834@cindex Restoring saved modes 31835Keyboard macros sometimes want to operate under known conditions 31836without affecting surrounding conditions. For example, a keyboard 31837macro may wish to turn on Fraction mode, or set a particular 31838precision, independent of the user's normal setting for those 31839modes. 31840 31841@kindex Z ` 31842@kindex Z ' 31843@pindex calc-kbd-push 31844@pindex calc-kbd-pop 31845Macros also sometimes need to use local variables. Assignments to 31846local variables inside the macro should not affect any variables 31847outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '} 31848(@code{calc-kbd-pop}) commands give you both of these capabilities. 31849 31850When you type @kbd{Z `} (with a grave accent), 31851the values of various mode settings are saved away. The ten ``quick'' 31852variables @code{q0} through @code{q9} are also saved. When 31853you type @w{@kbd{Z '}} (with an apostrophe), these values are restored. 31854Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested. 31855 31856If a keyboard macro halts due to an error in between a @kbd{Z `} and 31857a @kbd{Z '}, the saved values will be restored correctly even though 31858the macro never reaches the @kbd{Z '} command. Thus you can use 31859@kbd{Z `} and @kbd{Z '} without having to worry about what happens 31860in exceptional conditions. 31861 31862If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts 31863you into a ``recursive edit.'' You can tell you are in a recursive 31864edit because there will be extra square brackets in the mode line, 31865as in @samp{[(Calculator)]}. These brackets will go away when you 31866type the matching @kbd{Z '} command. The modes and quick variables 31867will be saved and restored in just the same way as if actual keyboard 31868macros were involved. 31869 31870The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision 31871and binary word size, the angular mode (Deg, Rad, or HMS), the 31872simplification mode, Algebraic mode, Symbolic mode, Infinite mode, 31873Matrix or Scalar mode, Fraction mode, and the current complex mode 31874(Polar or Rectangular). The ten ``quick'' variables' values (or lack 31875thereof) are also saved. 31876 31877Most mode-setting commands act as toggles, but with a numeric prefix 31878they force the mode either on (positive prefix) or off (negative 31879or zero prefix). Since you don't know what the environment might 31880be when you invoke your macro, it's best to use prefix arguments 31881for all mode-setting commands inside the macro. 31882 31883In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes 31884listed above to their default values. As usual, the matching @kbd{Z '} 31885will restore the modes to their settings from before the @kbd{C-u Z `}. 31886Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode 31887to its default (off) but leaves the other modes the same as they were 31888outside the construct. 31889 31890The contents of the stack and trail, values of non-quick variables, and 31891other settings such as the language mode and the various display modes, 31892are @emph{not} affected by @kbd{Z `} and @kbd{Z '}. 31893 31894@node Queries in Macros, , Local Values in Macros, Keyboard Macros 31895@subsection Queries in Keyboard Macros 31896 31897@c @noindent 31898@c @kindex Z = 31899@c @pindex calc-kbd-report 31900@c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative 31901@c message including the value on the top of the stack. You are prompted 31902@c to enter a string. That string, along with the top-of-stack value, 31903@c is displayed unless @kbd{m w} (@code{calc-working}) has been used 31904@c to turn such messages off. 31905 31906@noindent 31907@kindex Z # 31908@pindex calc-kbd-query 31909The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic 31910entry which takes its input from the keyboard, even during macro 31911execution. All the normal conventions of algebraic input, including the 31912use of @kbd{$} characters, are supported. The prompt message itself is 31913taken from the top of the stack, and so must be entered (as a string) 31914before the @kbd{Z #} command. (Recall, as a string it can be entered by 31915pressing the @kbd{"} key and will appear as a vector when it is put on 31916the stack. The prompt message is only put on the stack to provide a 31917prompt for the @kbd{Z #} command; it will not play any role in any 31918subsequent calculations.) This command allows your keyboard macros to 31919accept numbers or formulas as interactive input. 31920 31921As an example, 31922@kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for 31923input with ``Power: '' in the minibuffer, then return 2 to the provided 31924power. (The response to the prompt that's given, 3 in this example, 31925will not be part of the macro.) 31926 31927@xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of 31928@kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept 31929keyboard input during a keyboard macro. In particular, you can use 31930@kbd{C-x q} to enter a recursive edit, which allows the user to perform 31931any Calculator operations interactively before pressing @kbd{C-M-c} to 31932return control to the keyboard macro. 31933 31934@node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming 31935@section Invocation Macros 31936 31937@kindex C-x * z 31938@kindex Z I 31939@pindex calc-user-invocation 31940@pindex calc-user-define-invocation 31941Calc provides one special keyboard macro, called up by @kbd{C-x * z} 31942(@code{calc-user-invocation}), that is intended to allow you to define 31943your own special way of starting Calc. To define this ``invocation 31944macro,'' create the macro in the usual way with @kbd{C-x (} and 31945@kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}). 31946There is only one invocation macro, so you don't need to type any 31947additional letters after @kbd{Z I}. From now on, you can type 31948@kbd{C-x * z} at any time to execute your invocation macro. 31949 31950For example, suppose you find yourself often grabbing rectangles of 31951numbers into Calc and multiplying their columns. You can do this 31952by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns. 31953To make this into an invocation macro, just type @kbd{C-x ( C-x * r 31954V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data, 31955just mark the data in its buffer in the usual way and type @kbd{C-x * z}. 31956 31957Invocation macros are treated like regular Emacs keyboard macros; 31958all the special features described above for @kbd{Z K}-style macros 31959do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it 31960uses the macro that was last stored by @kbd{Z I}. (In fact, the 31961macro does not even have to have anything to do with Calc!) 31962 31963The @kbd{m m} command saves the last invocation macro defined by 31964@kbd{Z I} along with all the other Calc mode settings. 31965@xref{General Mode Commands}. 31966 31967@node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming 31968@section Programming with Formulas 31969 31970@noindent 31971@kindex Z F 31972@pindex calc-user-define-formula 31973@cindex Programming with algebraic formulas 31974Another way to create a new Calculator command uses algebraic formulas. 31975The @kbd{Z F} (@code{calc-user-define-formula}) command stores the 31976formula at the top of the stack as the definition for a key. This 31977command prompts for five things: The key, the command name, the function 31978name, the argument list, and the behavior of the command when given 31979non-numeric arguments. 31980 31981For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula 31982@samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this 31983formula on the @kbd{z m} key sequence. The next prompt is for a command 31984name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form 31985for the new command. If you simply press @key{RET}, a default name like 31986@code{calc-User-m} will be constructed. In our example, suppose we enter 31987@kbd{spam @key{RET}} to define the new command as @code{calc-spam}. 31988 31989If you want to give the formula a long-style name only, you can press 31990@key{SPC} or @key{RET} when asked which single key to use. For example 31991@kbd{Z F @key{RET} spam @key{RET}} defines the new command as 31992@kbd{M-x calc-spam}, with no keyboard equivalent. 31993 31994The third prompt is for an algebraic function name. The default is to 31995use the same name as the command name but without the @samp{calc-} 31996prefix. (If this is of the form @samp{User-m}, the hyphen is removed so 31997it won't be taken for a minus sign in algebraic formulas.) 31998This is the name you will use if you want to enter your 31999new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}. 32000Then the new function can be invoked by pushing two numbers on the 32001stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic 32002formula @samp{yow(x,y)}. 32003 32004The fourth prompt is for the function's argument list. This is used to 32005associate values on the stack with the variables that appear in the formula. 32006The default is a list of all variables which appear in the formula, sorted 32007into alphabetical order. In our case, the default would be @samp{(a b)}. 32008This means that, when the user types @kbd{z m}, the Calculator will remove 32009two numbers from the stack, substitute these numbers for @samp{a} and 32010@samp{b} (respectively) in the formula, then simplify the formula and 32011push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m} 32012would replace the 10 and 100 on the stack with the number 210, which is 32013@expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula 32014@samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and 32015@expr{b=100} in the definition. 32016 32017You can rearrange the order of the names before pressing @key{RET} to 32018control which stack positions go to which variables in the formula. If 32019you remove a variable from the argument list, that variable will be left 32020in symbolic form by the command. Thus using an argument list of @samp{(b)} 32021for our function would cause @kbd{10 z m} to replace the 10 on the stack 32022with the formula @samp{a + 20}. If we had used an argument list of 32023@samp{(b a)}, the result with inputs 10 and 100 would have been 120. 32024 32025You can also put a nameless function on the stack instead of just a 32026formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}. 32027In this example, the command will be defined by the formula @samp{a + 2 b} 32028using the argument list @samp{(a b)}. 32029 32030The final prompt is a y-or-n question concerning what to do if symbolic 32031arguments are given to your function. If you answer @kbd{y}, then 32032executing @kbd{z m} (using the original argument list @samp{(a b)}) with 32033arguments @expr{10} and @expr{x} will leave the function in symbolic 32034form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n}, 32035then the formula will always be expanded, even for non-constant 32036arguments: @samp{10 + 2 x}. If you never plan to feed algebraic 32037formulas to your new function, it doesn't matter how you answer this 32038question. 32039 32040If you answered @kbd{y} to this question you can still cause a function 32041call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}). 32042Also, Calc will expand the function if necessary when you take a 32043derivative or integral or solve an equation involving the function. 32044 32045@kindex Z G 32046@pindex calc-get-user-defn 32047Once you have defined a formula on a key, you can retrieve this formula 32048with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a 32049key, and this command pushes the formula that was used to define that 32050key onto the stack. Actually, it pushes a nameless function that 32051specifies both the argument list and the defining formula. You will get 32052an error message if the key is undefined, or if the key was not defined 32053by a @kbd{Z F} command. 32054 32055The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has 32056been defined by a formula uses a variant of the @code{calc-edit} command 32057to edit the defining formula. Press @kbd{C-c C-c} to finish editing and 32058store the new formula back in the definition, or kill the buffer with 32059@kbd{C-x k} to 32060cancel the edit. (The argument list and other properties of the 32061definition are unchanged; to adjust the argument list, you can use 32062@kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and 32063then re-execute the @kbd{Z F} command.) 32064 32065As usual, the @kbd{Z P} command records your definition permanently. 32066In this case it will permanently record all three of the relevant 32067definitions: the key, the command, and the function. 32068 32069You may find it useful to turn off the default simplifications with 32070@kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be 32071used as a function definition. For example, the formula @samp{deriv(a^2,v)} 32072which might be used to define a new function @samp{dsqr(a,v)} will be 32073``simplified'' to 0 immediately upon entry since @code{deriv} considers 32074@expr{a} to be constant with respect to @expr{v}. Turning off 32075default simplifications cures this problem: The definition will be stored 32076in symbolic form without ever activating the @code{deriv} function. Press 32077@kbd{m D} to turn the default simplifications back on afterwards. 32078 32079@node Lisp Definitions, , Algebraic Definitions, Programming 32080@section Programming with Lisp 32081 32082@noindent 32083The Calculator can be programmed quite extensively in Lisp. All you 32084do is write a normal Lisp function definition, but with @code{defmath} 32085in place of @code{defun}. This has the same form as @code{defun}, but it 32086automagically replaces calls to standard Lisp functions like @code{+} and 32087@code{zerop} with calls to the corresponding functions in Calc's own library. 32088Thus you can write natural-looking Lisp code which operates on all of the 32089standard Calculator data types. You can then use @kbd{Z D} if you wish to 32090bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command 32091will not edit a Lisp-based definition. 32092 32093Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section 32094assumes a familiarity with Lisp programming concepts; if you do not know 32095Lisp, you may find keyboard macros or rewrite rules to be an easier way 32096to program the Calculator. 32097 32098This section first discusses ways to write commands, functions, or 32099small programs to be executed inside of Calc. Then it discusses how 32100your own separate programs are able to call Calc from the outside. 32101Finally, there is a list of internal Calc functions and data structures 32102for the true Lisp enthusiast. 32103 32104@menu 32105* Defining Functions:: 32106* Defining Simple Commands:: 32107* Defining Stack Commands:: 32108* Argument Qualifiers:: 32109* Example Definitions:: 32110 32111* Calling Calc from Your Programs:: 32112* Internals:: 32113@end menu 32114 32115@node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions 32116@subsection Defining New Functions 32117 32118@noindent 32119@findex defmath 32120The @code{defmath} function (actually a Lisp macro) is like @code{defun} 32121except that code in the body of the definition can make use of the full 32122range of Calculator data types. The prefix @samp{calcFunc-} is added 32123to the specified name to get the actual Lisp function name. As a simple 32124example, 32125 32126@example 32127(defmath myfact (n) 32128 (if (> n 0) 32129 (* n (myfact (1- n))) 32130 1)) 32131@end example 32132 32133@noindent 32134This actually expands to the code, 32135 32136@example 32137(defun calcFunc-myfact (n) 32138 (if (math-posp n) 32139 (math-mul n (calcFunc-myfact (math-add n -1))) 32140 1)) 32141@end example 32142 32143@noindent 32144This function can be used in algebraic expressions, e.g., @samp{myfact(5)}. 32145 32146The @samp{myfact} function as it is defined above has the bug that an 32147expression @samp{myfact(a+b)} will be simplified to 1 because the 32148formula @samp{a+b} is not considered to be @code{posp}. A robust 32149factorial function would be written along the following lines: 32150 32151@smallexample 32152(defmath myfact (n) 32153 (if (> n 0) 32154 (* n (myfact (1- n))) 32155 (if (= n 0) 32156 1 32157 nil))) ; this could be simplified as: (and (= n 0) 1) 32158@end smallexample 32159 32160If a function returns @code{nil}, it is left unsimplified by the Calculator 32161(except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)} 32162will be simplified to @samp{myfact(a+3)} but no further. Beware that every 32163time the Calculator reexamines this formula it will attempt to resimplify 32164it, so your function ought to detect the returning-@code{nil} case as 32165efficiently as possible. 32166 32167The following standard Lisp functions are treated by @code{defmath}: 32168@code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or 32169@code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=}, 32170@code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor}, 32171@code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for 32172@code{math-nearly-equal}, which is useful in implementing Taylor series. 32173 32174For other functions @var{func}, if a function by the name 32175@samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the 32176name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself 32177is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is 32178used on the assumption that this is a to-be-defined math function. Also, if 32179the function name is quoted as in @samp{('integerp a)} the function name is 32180always used exactly as written (but not quoted). 32181 32182Variable names have @samp{var-} prepended to them unless they appear in 32183the function's argument list or in an enclosing @code{let}, @code{let*}, 32184@code{for}, or @code{foreach} form, 32185or their names already contain a @samp{-} character. Thus a reference to 32186@samp{foo} is the same as a reference to @samp{var-foo}. 32187 32188A few other Lisp extensions are available in @code{defmath} definitions: 32189 32190@itemize @bullet 32191@item 32192The @code{elt} function accepts any number of index variables. 32193Note that Calc vectors are stored as Lisp lists whose first 32194element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields 32195the second element of vector @code{v}, and @samp{(elt m i j)} 32196yields one element of a Calc matrix. 32197 32198@item 32199The @code{setq} function has been extended to act like the Common 32200Lisp @code{setf} function. (The name @code{setf} is recognized as 32201a synonym of @code{setq}.) Specifically, the first argument of 32202@code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form, 32203in which case the effect is to store into the specified 32204element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x} 32205into one element of a matrix. 32206 32207@item 32208A @code{for} looping construct is available. For example, 32209@samp{(for ((i 0 10)) body)} executes @code{body} once for each 32210binding of @expr{i} from zero to 10. This is like a @code{let} 32211form in that @expr{i} is temporarily bound to the loop count 32212without disturbing its value outside the @code{for} construct. 32213Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)}, 32214are also available. For each value of @expr{i} from zero to 10, 32215@expr{j} counts from 0 to @expr{i-1} in steps of two. Note that 32216@code{for} has the same general outline as @code{let*}, except 32217that each element of the header is a list of three or four 32218things, not just two. 32219 32220@item 32221The @code{foreach} construct loops over elements of a list. 32222For example, @samp{(foreach ((x (cdr v))) body)} executes 32223@code{body} with @expr{x} bound to each element of Calc vector 32224@expr{v} in turn. The purpose of @code{cdr} here is to skip over 32225the initial @code{vec} symbol in the vector. 32226 32227@item 32228The @code{break} function breaks out of the innermost enclosing 32229@code{while}, @code{for}, or @code{foreach} loop. If given a 32230value, as in @samp{(break x)}, this value is returned by the 32231loop. (Lisp loops otherwise always return @code{nil}.) 32232 32233@item 32234The @code{return} function prematurely returns from the enclosing 32235function. For example, @samp{(return (+ x y))} returns @expr{x+y} 32236as the value of a function. You can use @code{return} anywhere 32237inside the body of the function. 32238@end itemize 32239 32240Non-integer numbers (and extremely large integers) cannot be included 32241directly into a @code{defmath} definition. This is because the Lisp 32242reader will fail to parse them long before @code{defmath} ever gets control. 32243Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic 32244formula can go between the quotes. For example, 32245 32246@smallexample 32247(defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5) 32248 (and (numberp x) 32249 (exp :"x * 0.5"))) 32250@end smallexample 32251 32252expands to 32253 32254@smallexample 32255(defun calcFunc-sqexp (x) 32256 (and (math-numberp x) 32257 (calcFunc-exp (math-mul x '(float 5 -1))))) 32258@end smallexample 32259 32260Note the use of @code{numberp} as a guard to ensure that the argument is 32261a number first, returning @code{nil} if not. The exponential function 32262could itself have been included in the expression, if we had preferred: 32263@samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion 32264step of @code{myfact} could have been written 32265 32266@example 32267:"n * myfact(n-1)" 32268@end example 32269 32270A good place to put your @code{defmath} commands is your Calc init file 32271(the file given by @code{calc-settings-file}, typically 32272@file{~/.emacs.d/calc.el}), which will not be loaded until Calc starts. 32273If a file named @file{.emacs} exists in your home directory, Emacs reads 32274and executes the Lisp forms in this file as it starts up. While it may 32275seem reasonable to put your favorite @code{defmath} commands there, 32276this has the unfortunate side-effect that parts of the Calculator must be 32277loaded in to process the @code{defmath} commands whether or not you will 32278actually use the Calculator! If you want to put the @code{defmath} 32279commands there (for example, if you redefine @code{calc-settings-file} 32280to be @file{.emacs}), a better effect can be had by writing 32281 32282@example 32283(put 'calc-define 'thing '(progn 32284 (defmath ... ) 32285 (defmath ... ) 32286)) 32287@end example 32288 32289@noindent 32290@vindex calc-define 32291The @code{put} function adds a @dfn{property} to a symbol. Each Lisp 32292symbol has a list of properties associated with it. Here we add a 32293property with a name of @code{thing} and a @samp{(progn ...)} form as 32294its value. When Calc starts up, and at the start of every Calc command, 32295the property list for the symbol @code{calc-define} is checked and the 32296values of any properties found are evaluated as Lisp forms. The 32297properties are removed as they are evaluated. The property names 32298(like @code{thing}) are not used; you should choose something like the 32299name of your project so as not to conflict with other properties. 32300 32301The net effect is that you can put the above code in your @file{.emacs} 32302file and it will not be executed until Calc is loaded. Or, you can put 32303that same code in another file which you load by hand either before or 32304after Calc itself is loaded. 32305 32306The properties of @code{calc-define} are evaluated in the same order 32307that they were added. They can assume that the Calc modules @file{calc.el}, 32308@file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and 32309that the @file{*Calculator*} buffer will be the current buffer. 32310 32311If your @code{calc-define} property only defines algebraic functions, 32312you can be sure that it will have been evaluated before Calc tries to 32313call your function, even if the file defining the property is loaded 32314after Calc is loaded. But if the property defines commands or key 32315sequences, it may not be evaluated soon enough. (Suppose it defines the 32316new command @code{tweak-calc}; the user can load your file, then type 32317@kbd{M-x tweak-calc} before Calc has had chance to do anything.) To 32318protect against this situation, you can put 32319 32320@example 32321(run-hooks 'calc-check-defines) 32322@end example 32323 32324@findex calc-check-defines 32325@noindent 32326at the end of your file. The @code{calc-check-defines} function is what 32327looks for and evaluates properties on @code{calc-define}; @code{run-hooks} 32328has the advantage that it is quietly ignored if @code{calc-check-defines} 32329is not yet defined because Calc has not yet been loaded. 32330 32331Examples of things that ought to be enclosed in a @code{calc-define} 32332property are @code{defmath} calls, @code{define-key} calls that modify 32333the Calc key map, and any calls that redefine things defined inside Calc. 32334Ordinary @code{defun}s need not be enclosed with @code{calc-define}. 32335 32336@node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions 32337@subsection Defining New Simple Commands 32338 32339@noindent 32340@findex interactive 32341If a @code{defmath} form contains an @code{interactive} clause, it defines 32342a Calculator command. Actually such a @code{defmath} results in @emph{two} 32343function definitions: One, a @samp{calcFunc-} function as was just described, 32344with the @code{interactive} clause removed. Two, a @samp{calc-} function 32345with a suitable @code{interactive} clause and some sort of wrapper to make 32346the command work in the Calc environment. 32347 32348In the simple case, the @code{interactive} clause has the same form as 32349for normal Emacs Lisp commands: 32350 32351@smallexample 32352(defmath increase-precision (delta) 32353 "Increase precision by DELTA." ; This is the "documentation string" 32354 (interactive "p") ; Register this as a M-x-able command 32355 (setq calc-internal-prec (+ calc-internal-prec delta))) 32356@end smallexample 32357 32358This expands to the pair of definitions, 32359 32360@smallexample 32361(defun calc-increase-precision (delta) 32362 "Increase precision by DELTA." 32363 (interactive "p") 32364 (calc-wrapper 32365 (setq calc-internal-prec (math-add calc-internal-prec delta)))) 32366 32367(defun calcFunc-increase-precision (delta) 32368 "Increase precision by DELTA." 32369 (setq calc-internal-prec (math-add calc-internal-prec delta))) 32370@end smallexample 32371 32372@noindent 32373where in this case the latter function would never really be used! Note 32374that since the Calculator stores small integers as plain Lisp integers, 32375the @code{math-add} function will work just as well as the native 32376@code{+} even when the intent is to operate on native Lisp integers. 32377 32378@findex calc-wrapper 32379The @samp{calc-wrapper} call invokes a macro which surrounds the body of 32380the function with code that looks roughly like this: 32381 32382@smallexample 32383(let ((calc-command-flags nil)) 32384 (unwind-protect 32385 (save-current-buffer 32386 (calc-select-buffer) 32387 @emph{body of function} 32388 @emph{renumber stack} 32389 @emph{clear} Working @emph{message}) 32390 @emph{realign cursor and window} 32391 @emph{clear Inverse, Hyperbolic, and Keep Args flags} 32392 @emph{update Emacs mode line})) 32393@end smallexample 32394 32395@findex calc-select-buffer 32396The @code{calc-select-buffer} function selects the @file{*Calculator*} 32397buffer if necessary, say, because the command was invoked from inside 32398the @file{*Calc Trail*} window. 32399 32400@findex calc-set-command-flag 32401You can call, for example, @code{(calc-set-command-flag 'no-align)} to 32402set the above-mentioned command flags. Calc routines recognize the 32403following command flags: 32404 32405@table @code 32406@item renum-stack 32407Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered 32408after this command completes. This is set by routines like 32409@code{calc-push}. 32410 32411@item clear-message 32412Calc should call @samp{(message "")} if this command completes normally 32413(to clear a ``Working@dots{}'' message out of the echo area). 32414 32415@item no-align 32416Do not move the cursor back to the @samp{.} top-of-stack marker. 32417 32418@item position-point 32419Use the variables @code{calc-position-point-line} and 32420@code{calc-position-point-column} to position the cursor after 32421this command finishes. 32422 32423@item keep-flags 32424Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag}, 32425and @code{calc-keep-args-flag} at the end of this command. 32426 32427@item do-edit 32428Switch to buffer @file{*Calc Edit*} after this command. 32429 32430@item hold-trail 32431Do not move trail pointer to end of trail when something is recorded 32432there. 32433@end table 32434 32435@kindex Y 32436@kindex Y ? 32437@vindex calc-Y-help-msgs 32438Calc reserves a special prefix key, shift-@kbd{Y}, for user-written 32439extensions to Calc. There are no built-in commands that work with 32440this prefix key; you must call @code{define-key} from Lisp (probably 32441from inside a @code{calc-define} property) to add to it. Initially only 32442@kbd{Y ?} is defined; it takes help messages from a list of strings 32443(initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All 32444other undefined keys except for @kbd{Y} are reserved for use by 32445future versions of Calc. 32446 32447If you are writing a Calc enhancement which you expect to give to 32448others, it is best to minimize the number of @kbd{Y}-key sequences 32449you use. In fact, if you have more than one key sequence you should 32450consider defining three-key sequences with a @kbd{Y}, then a key that 32451stands for your package, then a third key for the particular command 32452within your package. 32453 32454Users may wish to install several Calc enhancements, and it is possible 32455that several enhancements will choose to use the same key. In the 32456example below, a variable @code{inc-prec-base-key} has been defined 32457to contain the key that identifies the @code{inc-prec} package. Its 32458value is initially @code{"P"}, but a user can change this variable 32459if necessary without having to modify the file. 32460 32461Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I} 32462command that increases the precision, and a @kbd{Y P D} command that 32463decreases the precision. 32464 32465@smallexample 32466;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91. 32467;; (Include copyright or copyleft stuff here.) 32468 32469(defvar inc-prec-base-key "P" 32470 "Base key for inc-prec.el commands.") 32471 32472(put 'calc-define 'inc-prec '(progn 32473 32474(define-key calc-mode-map (format "Y%sI" inc-prec-base-key) 32475 'increase-precision) 32476(define-key calc-mode-map (format "Y%sD" inc-prec-base-key) 32477 'decrease-precision) 32478 32479(setq calc-Y-help-msgs 32480 (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key) 32481 calc-Y-help-msgs)) 32482 32483(defmath increase-precision (delta) 32484 "Increase precision by DELTA." 32485 (interactive "p") 32486 (setq calc-internal-prec (+ calc-internal-prec delta))) 32487 32488(defmath decrease-precision (delta) 32489 "Decrease precision by DELTA." 32490 (interactive "p") 32491 (setq calc-internal-prec (- calc-internal-prec delta))) 32492 32493)) ; end of calc-define property 32494 32495(run-hooks 'calc-check-defines) 32496@end smallexample 32497 32498@node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions 32499@subsection Defining New Stack-Based Commands 32500 32501@noindent 32502To define a new computational command which takes and/or leaves arguments 32503on the stack, a special form of @code{interactive} clause is used. 32504 32505@example 32506(interactive @var{num} @var{tag}) 32507@end example 32508 32509@noindent 32510where @var{num} is an integer, and @var{tag} is a string. The effect is 32511to pop @var{num} values off the stack, resimplify them by calling 32512@code{calc-normalize}, and hand them to your function according to the 32513function's argument list. Your function may include @code{&optional} and 32514@code{&rest} parameters, so long as calling the function with @var{num} 32515parameters is valid. 32516 32517Your function must return either a number or a formula in a form 32518acceptable to Calc, or a list of such numbers or formulas. These value(s) 32519are pushed onto the stack when the function completes. They are also 32520recorded in the Calc Trail buffer on a line beginning with @var{tag}, 32521a string of (normally) four characters or less. If you omit @var{tag} 32522or use @code{nil} as a tag, the result is not recorded in the trail. 32523 32524As an example, the definition 32525 32526@smallexample 32527(defmath myfact (n) 32528 "Compute the factorial of the integer at the top of the stack." 32529 (interactive 1 "fact") 32530 (if (> n 0) 32531 (* n (myfact (1- n))) 32532 (and (= n 0) 1))) 32533@end smallexample 32534 32535@noindent 32536is a version of the factorial function shown previously which can be used 32537as a command as well as an algebraic function. It expands to 32538 32539@smallexample 32540(defun calc-myfact () 32541 "Compute the factorial of the integer at the top of the stack." 32542 (interactive) 32543 (calc-slow-wrapper 32544 (calc-enter-result 1 "fact" 32545 (cons 'calcFunc-myfact (calc-top-list-n 1))))) 32546 32547(defun calcFunc-myfact (n) 32548 "Compute the factorial of the integer at the top of the stack." 32549 (if (math-posp n) 32550 (math-mul n (calcFunc-myfact (math-add n -1))) 32551 (and (math-zerop n) 1))) 32552@end smallexample 32553 32554@findex calc-slow-wrapper 32555The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper} 32556that automatically puts up a @samp{Working...} message before the 32557computation begins. (This message can be turned off by the user 32558with an @kbd{m w} (@code{calc-working}) command.) 32559 32560@findex calc-top-list-n 32561The @code{calc-top-list-n} function returns a list of the specified number 32562of values from the top of the stack. It resimplifies each value by 32563calling @code{calc-normalize}. If its argument is zero it returns an 32564empty list. It does not actually remove these values from the stack. 32565 32566@findex calc-enter-result 32567The @code{calc-enter-result} function takes an integer @var{num} and string 32568@var{tag} as described above, plus a third argument which is either a 32569Calculator data object or a list of such objects. These objects are 32570resimplified and pushed onto the stack after popping the specified number 32571of values from the stack. If @var{tag} is non-@code{nil}, the values 32572being pushed are also recorded in the trail. 32573 32574Note that if @code{calcFunc-myfact} returns @code{nil} this represents 32575``leave the function in symbolic form.'' To return an actual empty list, 32576in the sense that @code{calc-enter-result} will push zero elements back 32577onto the stack, you should return the special value @samp{'(nil)}, a list 32578containing the single symbol @code{nil}. 32579 32580The @code{interactive} declaration can actually contain a limited 32581Emacs-style code string as well which comes just before @var{num} and 32582@var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in 32583 32584@example 32585(defmath foo (a b &optional c) 32586 (interactive "p" 2 "foo") 32587 @var{body}) 32588@end example 32589 32590In this example, the command @code{calc-foo} will evaluate the expression 32591@samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if 32592executed with a numeric prefix argument of @expr{n}. 32593 32594The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"} 32595code as used with @code{defun}). It uses the numeric prefix argument as the 32596number of objects to remove from the stack and pass to the function. 32597In this case, the integer @var{num} serves as a default number of 32598arguments to be used when no prefix is supplied. 32599 32600@node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions 32601@subsection Argument Qualifiers 32602 32603@noindent 32604Anywhere a parameter name can appear in the parameter list you can also use 32605an @dfn{argument qualifier}. Thus the general form of a definition is: 32606 32607@example 32608(defmath @var{name} (@var{param} @var{param...} 32609 &optional @var{param} @var{param...} 32610 &rest @var{param}) 32611 @var{body}) 32612@end example 32613 32614@noindent 32615where each @var{param} is either a symbol or a list of the form 32616 32617@example 32618(@var{qual} @var{param}) 32619@end example 32620 32621The following qualifiers are recognized: 32622 32623@table @samp 32624@item complete 32625@findex complete 32626The argument must not be an incomplete vector, interval, or complex number. 32627(This is rarely needed since the Calculator itself will never call your 32628function with an incomplete argument. But there is nothing stopping your 32629own Lisp code from calling your function with an incomplete argument.) 32630 32631@item integer 32632@findex integer 32633The argument must be an integer. If it is an integer-valued float 32634it will be accepted but converted to integer form. Non-integers and 32635formulas are rejected. 32636 32637@item natnum 32638@findex natnum 32639Like @samp{integer}, but the argument must be non-negative. 32640 32641@item fixnum 32642@findex fixnum 32643Like @samp{integer}, but the argument must fit into a native Lisp integer, 32644which on most systems means less than 2^23 in absolute value. The 32645argument is converted into Lisp-integer form if necessary. 32646 32647@item float 32648@findex float 32649The argument is converted to floating-point format if it is a number or 32650vector. If it is a formula it is left alone. (The argument is never 32651actually rejected by this qualifier.) 32652 32653@item @var{pred} 32654The argument must satisfy predicate @var{pred}, which is one of the 32655standard Calculator predicates. @xref{Predicates}. 32656 32657@item not-@var{pred} 32658The argument must @emph{not} satisfy predicate @var{pred}. 32659@end table 32660 32661For example, 32662 32663@example 32664(defmath foo (a (constp (not-matrixp b)) &optional (float c) 32665 &rest (integer d)) 32666 @var{body}) 32667@end example 32668 32669@noindent 32670expands to 32671 32672@example 32673(defun calcFunc-foo (a b &optional c &rest d) 32674 (and (math-matrixp b) 32675 (math-reject-arg b 'not-matrixp)) 32676 (or (math-constp b) 32677 (math-reject-arg b 'constp)) 32678 (and c (setq c (math-check-float c))) 32679 (setq d (mapcar 'math-check-integer d)) 32680 @var{body}) 32681@end example 32682 32683@noindent 32684which performs the necessary checks and conversions before executing the 32685body of the function. 32686 32687@node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions 32688@subsection Example Definitions 32689 32690@noindent 32691This section includes some Lisp programming examples on a larger scale. 32692These programs make use of some of the Calculator's internal functions; 32693@pxref{Internals}. 32694 32695@menu 32696* Bit Counting Example:: 32697* Sine Example:: 32698@end menu 32699 32700@node Bit Counting Example, Sine Example, Example Definitions, Example Definitions 32701@subsubsection Bit-Counting 32702 32703@noindent 32704@ignore 32705@starindex 32706@end ignore 32707@tindex bcount 32708Calc does not include a built-in function for counting the number of 32709``one'' bits in a binary integer. It's easy to invent one using @kbd{b u} 32710to convert the integer to a set, and @kbd{V #} to count the elements of 32711that set; let's write a function that counts the bits without having to 32712create an intermediate set. 32713 32714@smallexample 32715(defmath bcount ((natnum n)) 32716 (interactive 1 "bcnt") 32717 (let ((count 0)) 32718 (while (> n 0) 32719 (if (oddp n) 32720 (setq count (1+ count))) 32721 (setq n (ash n -1))) 32722 count)) 32723@end smallexample 32724 32725@noindent 32726When this is expanded by @code{defmath}, it will become the following 32727Emacs Lisp function: 32728 32729@smallexample 32730(defun calcFunc-bcount (n) 32731 (setq n (math-check-natnum n)) 32732 (let ((count 0)) 32733 (while (math-posp n) 32734 (if (math-oddp n) 32735 (setq count (math-add count 1))) 32736 (setq n (calcFunc-lsh n -1))) 32737 count)) 32738@end smallexample 32739 32740If the input numbers are large, this function involves a fair amount 32741of arithmetic. A binary right shift is essentially a division by two; 32742recall that Calc stores integers in decimal form so bit shifts must 32743involve actual division. 32744 32745To gain a bit more efficiency, we could divide the integer into 32746@var{n}-bit chunks, each of which can be handled quickly because 32747they fit into Lisp integers. It turns out that Calc's arithmetic 32748routines are especially fast when dividing by an integer less than 327491000, so we can set @var{n = 9} bits and use repeated division by 512: 32750 32751@smallexample 32752(defmath bcount ((natnum n)) 32753 (interactive 1 "bcnt") 32754 (let ((count 0)) 32755 (while (not (fixnump n)) 32756 (let ((qr (idivmod n 512))) 32757 (setq count (+ count (bcount-fixnum (cdr qr))) 32758 n (car qr)))) 32759 (+ count (bcount-fixnum n)))) 32760 32761(defun bcount-fixnum (n) 32762 (let ((count 0)) 32763 (while (> n 0) 32764 (setq count (+ count (logand n 1)) 32765 n (ash n -1))) 32766 count)) 32767@end smallexample 32768 32769@noindent 32770Note that the second function uses @code{defun}, not @code{defmath}. 32771Because this function deals only with native Lisp integers (``fixnums''), 32772it can use the actual Emacs @code{+} and related functions rather 32773than the slower but more general Calc equivalents which @code{defmath} 32774uses. 32775 32776The @code{idivmod} function does an integer division, returning both 32777the quotient and the remainder at once. Again, note that while it 32778might seem that @samp{(logand n 511)} and @samp{(ash n -9)} are 32779more efficient ways to split off the bottom nine bits of @code{n}, 32780actually they are less efficient because each operation is really 32781a division by 512 in disguise; @code{idivmod} allows us to do the 32782same thing with a single division by 512. 32783 32784@node Sine Example, , Bit Counting Example, Example Definitions 32785@subsubsection The Sine Function 32786 32787@noindent 32788@ignore 32789@starindex 32790@end ignore 32791@tindex mysin 32792A somewhat limited sine function could be defined as follows, using the 32793well-known Taylor series expansion for 32794@texline @math{\sin x}: 32795@infoline @samp{sin(x)}: 32796 32797@smallexample 32798(defmath mysin ((float (anglep x))) 32799 (interactive 1 "mysn") 32800 (setq x (to-radians x)) ; Convert from current angular mode. 32801 (let ((sum x) ; Initial term of Taylor expansion of sin. 32802 newsum 32803 (nfact 1) ; "nfact" equals "n" factorial at all times. 32804 (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2. 32805 (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution. 32806 (working "mysin" sum) ; Display "Working" message, if enabled. 32807 (setq nfact (* nfact (1- n) n) 32808 x (* x xnegsqr) 32809 newsum (+ sum (/ x nfact))) 32810 (if (~= newsum sum) ; If newsum is "nearly equal to" sum, 32811 (break)) ; then we are done. 32812 (setq sum newsum)) 32813 sum)) 32814@end smallexample 32815 32816The actual @code{sin} function in Calc works by first reducing the problem 32817to a sine or cosine of a nonnegative number less than @cpiover{4}. This 32818ensures that the Taylor series will converge quickly. Also, the calculation 32819is carried out with two extra digits of precision to guard against cumulative 32820round-off in @samp{sum}. Finally, complex arguments are allowed and handled 32821by a separate algorithm. 32822 32823@smallexample 32824(defmath mysin ((float (scalarp x))) 32825 (interactive 1 "mysn") 32826 (setq x (to-radians x)) ; Convert from current angular mode. 32827 (with-extra-prec 2 ; Evaluate with extra precision. 32828 (cond ((complexp x) 32829 (mysin-complex x)) 32830 ((< x 0) 32831 (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0. 32832 (t (mysin-raw x)))))) 32833 32834(defmath mysin-raw (x) 32835 (cond ((>= x 7) 32836 (mysin-raw (% x (two-pi)))) ; Now x < 7. 32837 ((> x (pi-over-2)) 32838 (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2. 32839 ((> x (pi-over-4)) 32840 (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4. 32841 ((< x (- (pi-over-4))) 32842 (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4, 32843 (t (mysin-series x)))) ; so the series will be efficient. 32844@end smallexample 32845 32846@noindent 32847where @code{mysin-complex} is an appropriate function to handle complex 32848numbers, @code{mysin-series} is the routine to compute the sine Taylor 32849series as before, and @code{mycos-raw} is a function analogous to 32850@code{mysin-raw} for cosines. 32851 32852The strategy is to ensure that @expr{x} is nonnegative before calling 32853@code{mysin-raw}. This function then recursively reduces its argument 32854to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each 32855test, and particularly the first comparison against 7, is designed so 32856that small roundoff errors cannot produce an infinite loop. (Suppose 32857we compared with @samp{(two-pi)} instead; if due to roundoff problems 32858the modulo operator ever returned @samp{(two-pi)} exactly, an infinite 32859recursion could result!) We use modulo only for arguments that will 32860clearly get reduced, knowing that the next rule will catch any reductions 32861that this rule misses. 32862 32863If a program is being written for general use, it is important to code 32864it carefully as shown in this second example. For quick-and-dirty programs, 32865when you know that your own use of the sine function will never encounter 32866a large argument, a simpler program like the first one shown is fine. 32867 32868@node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions 32869@subsection Calling Calc from Your Lisp Programs 32870 32871@noindent 32872A later section (@pxref{Internals}) gives a full description of 32873Calc's internal Lisp functions. It's not hard to call Calc from 32874inside your programs, but the number of these functions can be daunting. 32875So Calc provides one special ``programmer-friendly'' function called 32876@code{calc-eval} that can be made to do just about everything you 32877need. It's not as fast as the low-level Calc functions, but it's 32878much simpler to use! 32879 32880It may seem that @code{calc-eval} itself has a daunting number of 32881options, but they all stem from one simple operation. 32882 32883In its simplest manifestation, @samp{(calc-eval "1+2")} parses the 32884string @code{"1+2"} as if it were a Calc algebraic entry and returns 32885the result formatted as a string: @code{"3"}. 32886 32887Since @code{calc-eval} is on the list of recommended @code{autoload} 32888functions, you don't need to make any special preparations to load 32889Calc before calling @code{calc-eval} the first time. Calc will be 32890loaded and initialized for you. 32891 32892All the Calc modes that are currently in effect will be used when 32893evaluating the expression and formatting the result. 32894 32895@ifinfo 32896@example 32897 32898@end example 32899@end ifinfo 32900@subsubsection Additional Arguments to @code{calc-eval} 32901 32902@noindent 32903If the input string parses to a list of expressions, Calc returns 32904the results separated by @code{", "}. You can specify a different 32905separator by giving a second string argument to @code{calc-eval}: 32906@samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}. 32907 32908The ``separator'' can also be any of several Lisp symbols which 32909request other behaviors from @code{calc-eval}. These are discussed 32910one by one below. 32911 32912You can give additional arguments to be substituted for 32913@samp{$}, @samp{$$}, and so on in the main expression. For 32914example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the 32915expression @code{"7/(1+1)"} to yield the result @code{"3.5"} 32916(assuming Fraction mode is not in effect). Note the @code{nil} 32917used as a placeholder for the item-separator argument. 32918 32919@ifinfo 32920@example 32921 32922@end example 32923@end ifinfo 32924@subsubsection Error Handling 32925 32926@noindent 32927If @code{calc-eval} encounters an error, it returns a list containing 32928the character position of the error, plus a suitable message as a 32929string. Note that @samp{1 / 0} is @emph{not} an error by Calc's 32930standards; it simply returns the string @code{"1 / 0"} which is the 32931division left in symbolic form. But @samp{(calc-eval "1/")} will 32932return the list @samp{(2 "Expected a number")}. 32933 32934If you bind the variable @code{calc-eval-error} to @code{t} 32935using a @code{let} form surrounding the call to @code{calc-eval}, 32936errors instead call the Emacs @code{error} function which aborts 32937to the Emacs command loop with a beep and an error message. 32938 32939If you bind this variable to the symbol @code{string}, error messages 32940are returned as strings instead of lists. The character position is 32941ignored. 32942 32943As a courtesy to other Lisp code which may be using Calc, be sure 32944to bind @code{calc-eval-error} using @code{let} rather than changing 32945it permanently with @code{setq}. 32946 32947@ifinfo 32948@example 32949 32950@end example 32951@end ifinfo 32952@subsubsection Numbers Only 32953 32954@noindent 32955Sometimes it is preferable to treat @samp{1 / 0} as an error 32956rather than returning a symbolic result. If you pass the symbol 32957@code{num} as the second argument to @code{calc-eval}, results 32958that are not constants are treated as errors. The error message 32959reported is the first @code{calc-why} message if there is one, 32960or otherwise ``Number expected.'' 32961 32962A result is ``constant'' if it is a number, vector, or other 32963object that does not include variables or function calls. If it 32964is a vector, the components must themselves be constants. 32965 32966@ifinfo 32967@example 32968 32969@end example 32970@end ifinfo 32971@subsubsection Default Modes 32972 32973@noindent 32974If the first argument to @code{calc-eval} is a list whose first 32975element is a formula string, then @code{calc-eval} sets all the 32976various Calc modes to their default values while the formula is 32977evaluated and formatted. For example, the precision is set to 12 32978digits, digit grouping is turned off, and the Normal language 32979mode is used. 32980 32981This same principle applies to the other options discussed below. 32982If the first argument would normally be @var{x}, then it can also 32983be the list @samp{(@var{x})} to use the default mode settings. 32984 32985If there are other elements in the list, they are taken as 32986variable-name/value pairs which override the default mode 32987settings. Look at the documentation at the front of the 32988@file{calc.el} file to find the names of the Lisp variables for 32989the various modes. The mode settings are restored to their 32990original values when @code{calc-eval} is done. 32991 32992For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)} 32993computes the sum of two numbers, requiring a numeric result, and 32994using default mode settings except that the precision is 8 instead 32995of the default of 12. 32996 32997It's usually best to use this form of @code{calc-eval} unless your 32998program actually considers the interaction with Calc's mode settings 32999to be a feature. This will avoid all sorts of potential ``gotchas''; 33000consider what happens with @samp{(calc-eval "sqrt(2)" 'num)} 33001when the user has left Calc in Symbolic mode or No-Simplify mode. 33002 33003As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")} 33004checks if the number in string @expr{a} is less than the one in 33005string @expr{b}. Without using a list, the integer 1 might 33006come out in a variety of formats which would be hard to test for 33007conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But 33008see ``Predicates'' mode, below.) 33009 33010@ifinfo 33011@example 33012 33013@end example 33014@end ifinfo 33015@subsubsection Raw Numbers 33016 33017@noindent 33018Normally all input and output for @code{calc-eval} is done with strings. 33019You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)} 33020in place of @samp{(+ a b)}, but this is very inefficient since the 33021numbers must be converted to and from string format as they are passed 33022from one @code{calc-eval} to the next. 33023 33024If the separator is the symbol @code{raw}, the result will be returned 33025as a raw Calc data structure rather than a string. You can read about 33026how these objects look in the following sections, but usually you can 33027treat them as ``black box'' objects with no important internal 33028structure. 33029 33030There is also a @code{rawnum} symbol, which is a combination of 33031@code{raw} (returning a raw Calc object) and @code{num} (signaling 33032an error if that object is not a constant). 33033 33034You can pass a raw Calc object to @code{calc-eval} in place of a 33035string, either as the formula itself or as one of the @samp{$} 33036arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an 33037addition function that operates on raw Calc objects. Of course 33038in this case it would be easier to call the low-level @code{math-add} 33039function in Calc, if you can remember its name. 33040 33041In particular, note that a plain Lisp integer is acceptable to Calc 33042as a raw object. (All Lisp integers are accepted on input, but 33043integers of more than six decimal digits are converted to ``big-integer'' 33044form for output. @xref{Data Type Formats}.) 33045 33046When it comes time to display the object, just use @samp{(calc-eval a)} 33047to format it as a string. 33048 33049It is an error if the input expression evaluates to a list of 33050values. The separator symbol @code{list} is like @code{raw} 33051except that it returns a list of one or more raw Calc objects. 33052 33053Note that a Lisp string is not a valid Calc object, nor is a list 33054containing a string. Thus you can still safely distinguish all the 33055various kinds of error returns discussed above. 33056 33057@ifinfo 33058@example 33059 33060@end example 33061@end ifinfo 33062@subsubsection Predicates 33063 33064@noindent 33065If the separator symbol is @code{pred}, the result of the formula is 33066treated as a true/false value; @code{calc-eval} returns @code{t} or 33067@code{nil}, respectively. A value is considered ``true'' if it is a 33068non-zero number, or false if it is zero or if it is not a number. 33069 33070For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether 33071one value is less than another. 33072 33073As usual, it is also possible for @code{calc-eval} to return one of 33074the error indicators described above. Lisp will interpret such an 33075indicator as ``true'' if you don't check for it explicitly. If you 33076wish to have an error register as ``false'', use something like 33077@samp{(eq (calc-eval ...) t)}. 33078 33079@ifinfo 33080@example 33081 33082@end example 33083@end ifinfo 33084@subsubsection Variable Values 33085 33086@noindent 33087Variables in the formula passed to @code{calc-eval} are not normally 33088replaced by their values. If you wish this, you can use the 33089@code{evalv} function (@pxref{Algebraic Manipulation}). For example, 33090if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable 33091@code{var-a}), then @samp{(calc-eval "a+pi")} will return the 33092formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")} 33093will return @code{"7.14159265359"}. 33094 33095To store in a Calc variable, just use @code{setq} to store in the 33096corresponding Lisp variable. (This is obtained by prepending 33097@samp{var-} to the Calc variable name.) Calc routines will 33098understand either string or raw form values stored in variables, 33099although raw data objects are much more efficient. For example, 33100to increment the Calc variable @code{a}: 33101 33102@example 33103(setq var-a (calc-eval "evalv(a+1)" 'raw)) 33104@end example 33105 33106@ifinfo 33107@example 33108 33109@end example 33110@end ifinfo 33111@subsubsection Stack Access 33112 33113@noindent 33114If the separator symbol is @code{push}, the formula argument is 33115evaluated (with possible @samp{$} expansions, as usual). The 33116result is pushed onto the Calc stack. The return value is @code{nil} 33117(unless there is an error from evaluating the formula, in which 33118case the return value depends on @code{calc-eval-error} in the 33119usual way). 33120 33121If the separator symbol is @code{pop}, the first argument to 33122@code{calc-eval} must be an integer instead of a string. That 33123many values are popped from the stack and thrown away. A negative 33124argument deletes the entry at that stack level. The return value 33125is the number of elements remaining in the stack after popping; 33126@samp{(calc-eval 0 'pop)} is a good way to measure the size of 33127the stack. 33128 33129If the separator symbol is @code{top}, the first argument to 33130@code{calc-eval} must again be an integer. The value at that 33131stack level is formatted as a string and returned. Thus 33132@samp{(calc-eval 1 'top)} returns the top-of-stack value. If the 33133integer is out of range, @code{nil} is returned. 33134 33135The separator symbol @code{rawtop} is just like @code{top} except 33136that the stack entry is returned as a raw Calc object instead of 33137as a string. 33138 33139In all of these cases the first argument can be made a list in 33140order to force the default mode settings, as described above. 33141Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the 33142second-to-top stack entry, formatted as a string using the default 33143instead of current display modes, except that the radix is 33144hexadecimal instead of decimal. 33145 33146It is, of course, polite to put the Calc stack back the way you 33147found it when you are done, unless the user of your program is 33148actually expecting it to affect the stack. 33149 33150Note that you do not actually have to switch into the @file{*Calculator*} 33151buffer in order to use @code{calc-eval}; it temporarily switches into 33152the stack buffer if necessary. 33153 33154@ifinfo 33155@example 33156 33157@end example 33158@end ifinfo 33159@subsubsection Keyboard Macros 33160 33161@noindent 33162If the separator symbol is @code{macro}, the first argument must be a 33163string of characters which Calc can execute as a sequence of keystrokes. 33164This switches into the Calc buffer for the duration of the macro. 33165For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the 33166vector @samp{[1,2,3,4,5]} on the stack and then replaces it 33167with the sum of those numbers. Note that @samp{\r} is the Lisp 33168notation for the carriage return, @key{RET}, character. 33169 33170If your keyboard macro wishes to pop the stack, @samp{\C-d} is 33171safer than @samp{\177} (the @key{DEL} character) because some 33172installations may have switched the meanings of @key{DEL} and 33173@kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for 33174``pop-stack'' regardless of key mapping. 33175 33176If you provide a third argument to @code{calc-eval}, evaluation 33177of the keyboard macro will leave a record in the Trail using 33178that argument as a tag string. Normally the Trail is unaffected. 33179 33180The return value in this case is always @code{nil}. 33181 33182@ifinfo 33183@example 33184 33185@end example 33186@end ifinfo 33187@subsubsection Lisp Evaluation 33188 33189@noindent 33190Finally, if the separator symbol is @code{eval}, then the Lisp 33191@code{eval} function is called on the first argument, which must 33192be a Lisp expression rather than a Calc formula. Remember to 33193quote the expression so that it is not evaluated until inside 33194@code{calc-eval}. 33195 33196The difference from plain @code{eval} is that @code{calc-eval} 33197switches to the Calc buffer before evaluating the expression. 33198For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)} 33199will correctly affect the buffer-local Calc precision variable. 33200 33201An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}. 33202This is evaluating a call to the function that is normally invoked 33203by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.'' 33204Note that this function will leave a message in the echo area as 33205a side effect. Also, all Calc functions switch to the Calc buffer 33206automatically if not invoked from there, so the above call is 33207also equivalent to @samp{(calc-precision 17)} by itself. 33208In all cases, Calc uses @code{save-excursion} to switch back to 33209your original buffer when it is done. 33210 33211As usual the first argument can be a list that begins with a Lisp 33212expression to use default instead of current mode settings. 33213 33214The result of @code{calc-eval} in this usage is just the result 33215returned by the evaluated Lisp expression. 33216 33217@ifinfo 33218@example 33219 33220@end example 33221@end ifinfo 33222@subsubsection Example 33223 33224@noindent 33225@findex convert-temp 33226Here is a sample Emacs command that uses @code{calc-eval}. Suppose 33227you have a document with lots of references to temperatures on the 33228Fahrenheit scale, say ``98.6 F'', and you wish to convert these 33229references to Centigrade. The following command does this conversion. 33230Place the Emacs cursor right after the letter ``F'' and invoke the 33231command to change ``98.6 F'' to ``37 C''. Or, if the temperature is 33232already in Centigrade form, the command changes it back to Fahrenheit. 33233 33234@example 33235(defun convert-temp () 33236 (interactive) 33237 (save-excursion 33238 (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)") 33239 (let* ((top1 (match-beginning 1)) 33240 (bot1 (match-end 1)) 33241 (number (buffer-substring top1 bot1)) 33242 (top2 (match-beginning 2)) 33243 (bot2 (match-end 2)) 33244 (type (buffer-substring top2 bot2))) 33245 (if (equal type "F") 33246 (setq type "C" 33247 number (calc-eval "($ - 32)*5/9" nil number)) 33248 (setq type "F" 33249 number (calc-eval "$*9/5 + 32" nil number))) 33250 (goto-char top2) 33251 (delete-region top2 bot2) 33252 (insert-before-markers type) 33253 (goto-char top1) 33254 (delete-region top1 bot1) 33255 (if (string-match "\\.$" number) ; change "37." to "37" 33256 (setq number (substring number 0 -1))) 33257 (insert number)))) 33258@end example 33259 33260Note the use of @code{insert-before-markers} when changing between 33261``F'' and ``C'', so that the character winds up before the cursor 33262instead of after it. 33263 33264@node Internals, , Calling Calc from Your Programs, Lisp Definitions 33265@subsection Calculator Internals 33266 33267@noindent 33268This section describes the Lisp functions defined by the Calculator that 33269may be of use to user-written Calculator programs (as described in the 33270rest of this chapter). These functions are shown by their names as they 33271conventionally appear in @code{defmath}. Their full Lisp names are 33272generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their 33273apparent names. (Names that begin with @samp{calc-} are already in 33274their full Lisp form.) You can use the actual full names instead if you 33275prefer them, or if you are calling these functions from regular Lisp. 33276 33277The functions described here are scattered throughout the various 33278Calc component files. Note that @file{calc.el} includes @code{autoload}s 33279for only a few component files; to get autoloads of the more advanced 33280function, one needs to load @file{calc-ext.el}, which in turn 33281autoloads all the functions in the remaining component files. 33282 33283Because @code{defmath} itself uses the extensions, user-written code 33284generally always executes with the extensions already loaded, so 33285normally you can use any Calc function and be confident that it will 33286be autoloaded for you when necessary. If you are doing something 33287special, check carefully to make sure each function you are using is 33288from @file{calc.el} or its components, and use @w{@code{(require 33289'calc-ext)}} before using any function based in @file{calc-ext.el} if 33290you can't prove this file will already be loaded. 33291 33292@menu 33293* Data Type Formats:: 33294* Interactive Lisp Functions:: 33295* Stack Lisp Functions:: 33296* Predicates:: 33297* Computational Lisp Functions:: 33298* Vector Lisp Functions:: 33299* Symbolic Lisp Functions:: 33300* Formatting Lisp Functions:: 33301* Hooks:: 33302@end menu 33303 33304@node Data Type Formats, Interactive Lisp Functions, Internals, Internals 33305@subsubsection Data Type Formats 33306 33307@noindent 33308Integers are stored in either of two ways, depending on their magnitude. 33309Integers less than one million in absolute value are stored as standard 33310Lisp integers. This is the only storage format for Calc data objects 33311which is not a Lisp list. 33312 33313Large integers are stored as lists of the form @samp{(bigpos @var{d0} 33314@var{d1} @var{d2} @dots{})} for sufficiently large positive integers 33315(where ``sufficiently large'' depends on the machine), or 33316@samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative 33317integers. Each @var{d} is a base-@expr{10^n} ``digit'' (where again, 33318@expr{n} depends on the machine), a Lisp integer from 0 to 3331999@dots{}9. The least significant digit is @var{d0}; the last digit, 33320@var{dn}, which is always nonzero, is the most significant digit. For 33321example, the integer @mathit{-12345678} might be stored as 33322@samp{(bigneg 678 345 12)}. 33323 33324The distinction between small and large integers is entirely hidden from 33325the user. In @code{defmath} definitions, the Lisp predicate @code{integerp} 33326returns true for either kind of integer, and in general both big and small 33327integers are accepted anywhere the word ``integer'' is used in this manual. 33328If the distinction must be made, native Lisp integers are called @dfn{fixnums} 33329and large integers are called @dfn{bignums}. 33330 33331Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})} 33332where @var{n} is an integer (big or small) numerator, @var{d} is an 33333integer denominator greater than one, and @var{n} and @var{d} are relatively 33334prime. Note that fractions where @var{d} is one are automatically converted 33335to plain integers by all math routines; fractions where @var{d} is negative 33336are normalized by negating the numerator and denominator. 33337 33338Floating-point numbers are stored in the form, @samp{(float @var{mant} 33339@var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than 33340@samp{10^@var{p}} in absolute value (@var{p} represents the current 33341precision), and @var{exp} (the ``exponent'') is a fixnum. The value of 33342the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number 33343@mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints 33344are that the number 0.0 is always stored as @samp{(float 0 0)}, and, 33345except for the 0.0 case, the rightmost base-10 digit of @var{mant} is 33346always nonzero. (If the rightmost digit is zero, the number is 33347rearranged by dividing @var{mant} by ten and incrementing @var{exp}.) 33348 33349Rectangular complex numbers are stored in the form @samp{(cplx @var{re} 33350@var{im})}, where @var{re} and @var{im} are each real numbers, either 33351integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}. 33352The @var{im} part is nonzero; complex numbers with zero imaginary 33353components are converted to real numbers automatically. 33354 33355Polar complex numbers are stored in the form @samp{(polar @var{r} 33356@var{theta})}, where @var{r} is a positive real value and @var{theta} 33357is a real value or HMS form representing an angle. This angle is 33358usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees, 33359or @samp{(-pi ..@: pi)} radians, according to the current angular mode. 33360If the angle is 0 the value is converted to a real number automatically. 33361(If the angle is 180 degrees, the value is usually also converted to a 33362negative real number.) 33363 33364Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m} 33365@var{s})}, where @var{h} is an integer or an integer-valued float (i.e., 33366a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued 33367float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number 33368in the range @samp{[0 ..@: 60)}. 33369 33370Date forms are stored as @samp{(date @var{n})}, where @var{n} is 33371a real number that counts days since midnight on the morning of 33372January 1, 1 AD@. If @var{n} is an integer, this is a pure date 33373form. If @var{n} is a fraction or float, this is a date/time form. 33374 33375Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a 33376positive real number or HMS form, and @var{n} is a real number or HMS 33377form in the range @samp{[0 ..@: @var{m})}. 33378 33379Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x} 33380is the mean value and @var{sigma} is the standard deviation. Each 33381component is either a number, an HMS form, or a symbolic object 33382(a variable or function call). If @var{sigma} is zero, the value is 33383converted to a plain real number. If @var{sigma} is negative or 33384complex, it is automatically normalized to be a positive real. 33385 33386Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})}, 33387where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and 33388@var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask} 33389is a binary integer where 1 represents the fact that the interval is 33390closed on the high end, and 2 represents the fact that it is closed on 33391the low end. (Thus 3 represents a fully closed interval.) The interval 33392@w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x}; 33393intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask} 33394represent empty intervals. If @var{hi} is less than @var{lo}, the interval 33395is converted to a standard empty interval by replacing @var{hi} with @var{lo}. 33396 33397Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1} 33398is the first element of the vector, @var{v2} is the second, and so on. 33399An empty vector is stored as @samp{(vec)}. A matrix is simply a vector 33400where all @var{v}'s are themselves vectors of equal lengths. Note that 33401Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is 33402generally unused by Calc data structures. 33403 33404Variables are stored as @samp{(var @var{name} @var{sym})}, where 33405@var{name} is a Lisp symbol whose print name is used as the visible name 33406of the variable, and @var{sym} is a Lisp symbol in which the variable's 33407value is actually stored. Thus, @samp{(var pi var-pi)} represents the 33408special constant @samp{pi}. Almost always, the form is @samp{(var 33409@var{v} var-@var{v})}. If the variable name was entered with @code{#} 33410signs (which are converted to hyphens internally), the form is 33411@samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name 33412contains @code{#} characters, and @var{v} is a symbol that contains 33413@code{-} characters instead. The value of a variable is the Calc 33414object stored in its @var{sym} symbol's value cell. If the symbol's 33415value cell is void or if it contains @code{nil}, the variable has no 33416value. Special constants have the form @samp{(special-const 33417@var{value})} stored in their value cell, where @var{value} is a formula 33418which is evaluated when the constant's value is requested. Variables 33419which represent units are not stored in any special way; they are units 33420only because their names appear in the units table. If the value 33421cell contains a string, it is parsed to get the variable's value when 33422the variable is used. 33423 33424A Lisp list with any other symbol as the first element is a function call. 33425The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^}, 33426and @code{|} represent special binary operators; these lists are always 33427of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the 33428sub-formula on the lefthand side and @var{rhs} is the sub-formula on the 33429right. The symbol @code{neg} represents unary negation; this list is always 33430of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a 33431function that would be displayed in function-call notation; the symbol 33432@var{func} is in general always of the form @samp{calcFunc-@var{name}}. 33433The function cell of the symbol @var{func} should contain a Lisp function 33434for evaluating a call to @var{func}. This function is passed the remaining 33435elements of the list (themselves already evaluated) as arguments; such 33436functions should return @code{nil} or call @code{reject-arg} to signify 33437that they should be left in symbolic form, or they should return a Calc 33438object which represents their value, or a list of such objects if they 33439wish to return multiple values. (The latter case is allowed only for 33440functions which are the outer-level call in an expression whose value is 33441about to be pushed on the stack; this feature is considered obsolete 33442and is not used by any built-in Calc functions.) 33443 33444@node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals 33445@subsubsection Interactive Functions 33446 33447@noindent 33448The functions described here are used in implementing interactive Calc 33449commands. Note that this list is not exhaustive! If there is an 33450existing command that behaves similarly to the one you want to define, 33451you may find helpful tricks by checking the source code for that command. 33452 33453@defun calc-set-command-flag flag 33454Set the command flag @var{flag}. This is generally a Lisp symbol, but 33455may in fact be anything. The effect is to add @var{flag} to the list 33456stored in the variable @code{calc-command-flags}, unless it is already 33457there. @xref{Defining Simple Commands}. 33458@end defun 33459 33460@defun calc-clear-command-flag flag 33461If @var{flag} appears among the list of currently-set command flags, 33462remove it from that list. 33463@end defun 33464 33465@defun calc-record-undo rec 33466Add the ``undo record'' @var{rec} to the list of steps to take if the 33467current operation should need to be undone. Stack push and pop functions 33468automatically call @code{calc-record-undo}, so the kinds of undo records 33469you might need to create take the form @samp{(set @var{sym} @var{value})}, 33470which says that the Lisp variable @var{sym} was changed and had previously 33471contained @var{value}; @samp{(store @var{var} @var{value})} which says that 33472the Calc variable @var{var} (a string which is the name of the symbol that 33473contains the variable's value) was stored and its previous value was 33474@var{value} (either a Calc data object, or @code{nil} if the variable was 33475previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})}, 33476which means that to undo requires calling the function @samp{(@var{undo} 33477@var{args} @dots{})} and, if the undo is later redone, calling 33478@samp{(@var{redo} @var{args} @dots{})}. 33479@end defun 33480 33481@defun calc-record-why msg args 33482Record the error or warning message @var{msg}, which is normally a string. 33483This message will be replayed if the user types @kbd{w} (@code{calc-why}); 33484if the message string begins with a @samp{*}, it is considered important 33485enough to display even if the user doesn't type @kbd{w}. If one or more 33486@var{args} are present, the displayed message will be of the form, 33487@samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are 33488formatted on the assumption that they are either strings or Calc objects of 33489some sort. If @var{msg} is a symbol, it is the name of a Calc predicate 33490(such as @code{integerp} or @code{numvecp}) which the arguments did not 33491satisfy; it is expanded to a suitable string such as ``Expected an 33492integer.'' The @code{reject-arg} function calls @code{calc-record-why} 33493automatically; @pxref{Predicates}. 33494@end defun 33495 33496@defun calc-is-inverse 33497This predicate returns true if the current command is inverse, 33498i.e., if the Inverse (@kbd{I} key) flag was set. 33499@end defun 33500 33501@defun calc-is-hyperbolic 33502This predicate is the analogous function for the @kbd{H} key. 33503@end defun 33504 33505@node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals 33506@subsubsection Stack-Oriented Functions 33507 33508@noindent 33509The functions described here perform various operations on the Calc 33510stack and trail. They are to be used in interactive Calc commands. 33511 33512@defun calc-push-list vals n 33513Push the Calc objects in list @var{vals} onto the stack at stack level 33514@var{n}. If @var{n} is omitted it defaults to 1, so that the elements 33515are pushed at the top of the stack. If @var{n} is greater than 1, the 33516elements will be inserted into the stack so that the last element will 33517end up at level @var{n}, the next-to-last at level @var{n}+1, etc. 33518The elements of @var{vals} are assumed to be valid Calc objects, and 33519are not evaluated, rounded, or renormalized in any way. If @var{vals} 33520is an empty list, nothing happens. 33521 33522The stack elements are pushed without any sub-formula selections. 33523You can give an optional third argument to this function, which must 33524be a list the same size as @var{vals} of selections. Each selection 33525must be @code{eq} to some sub-formula of the corresponding formula 33526in @var{vals}, or @code{nil} if that formula should have no selection. 33527@end defun 33528 33529@defun calc-top-list n m 33530Return a list of the @var{n} objects starting at level @var{m} of the 33531stack. If @var{m} is omitted it defaults to 1, so that the elements are 33532taken from the top of the stack. If @var{n} is omitted, it also 33533defaults to 1, so that the top stack element (in the form of a 33534one-element list) is returned. If @var{m} is greater than 1, the 33535@var{m}th stack element will be at the end of the list, the @var{m}+1st 33536element will be next-to-last, etc. If @var{n} or @var{m} are out of 33537range, the command is aborted with a suitable error message. If @var{n} 33538is zero, the function returns an empty list. The stack elements are not 33539evaluated, rounded, or renormalized. 33540 33541If any stack elements contain selections, and selections have not 33542been disabled by the @kbd{j e} (@code{calc-enable-selections}) command, 33543this function returns the selected portions rather than the entire 33544stack elements. It can be given a third ``selection-mode'' argument 33545which selects other behaviors. If it is the symbol @code{t}, then 33546a selection in any of the requested stack elements produces an 33547``invalid operation on selections'' error. If it is the symbol @code{full}, 33548the whole stack entry is always returned regardless of selections. 33549If it is the symbol @code{sel}, the selected portion is always returned, 33550or @code{nil} if there is no selection. (This mode ignores the @kbd{j e} 33551command.) If the symbol is @code{entry}, the complete stack entry in 33552list form is returned; the first element of this list will be the whole 33553formula, and the third element will be the selection (or @code{nil}). 33554@end defun 33555 33556@defun calc-pop-stack n m 33557Remove the specified elements from the stack. The parameters @var{n} 33558and @var{m} are defined the same as for @code{calc-top-list}. The return 33559value of @code{calc-pop-stack} is uninteresting. 33560 33561If there are any selected sub-formulas among the popped elements, and 33562@kbd{j e} has not been used to disable selections, this produces an 33563error without changing the stack. If you supply an optional third 33564argument of @code{t}, the stack elements are popped even if they 33565contain selections. 33566@end defun 33567 33568@defun calc-record-list vals tag 33569This function records one or more results in the trail. The @var{vals} 33570are a list of strings or Calc objects. The @var{tag} is the four-character 33571tag string to identify the values. If @var{tag} is omitted, a blank tag 33572will be used. 33573@end defun 33574 33575@defun calc-normalize n 33576This function takes a Calc object and ``normalizes'' it. At the very 33577least this involves re-rounding floating-point values according to the 33578current precision and other similar jobs. Also, unless the user has 33579selected No-Simplify mode (@pxref{Simplification Modes}), this involves 33580actually evaluating a formula object by executing the function calls 33581it contains, and possibly also doing algebraic simplification, etc. 33582@end defun 33583 33584@defun calc-top-list-n n m 33585This function is identical to @code{calc-top-list}, except that it calls 33586@code{calc-normalize} on the values that it takes from the stack. They 33587are also passed through @code{check-complete}, so that incomplete 33588objects will be rejected with an error message. All computational 33589commands should use this in preference to @code{calc-top-list}; the only 33590standard Calc commands that operate on the stack without normalizing 33591are stack management commands like @code{calc-enter} and @code{calc-roll-up}. 33592This function accepts the same optional selection-mode argument as 33593@code{calc-top-list}. 33594@end defun 33595 33596@defun calc-top-n m 33597This function is a convenient form of @code{calc-top-list-n} in which only 33598a single element of the stack is taken and returned, rather than a list 33599of elements. This also accepts an optional selection-mode argument. 33600@end defun 33601 33602@defun calc-enter-result n tag vals 33603This function is a convenient interface to most of the above functions. 33604The @var{vals} argument should be either a single Calc object, or a list 33605of Calc objects; the object or objects are normalized, and the top @var{n} 33606stack entries are replaced by the normalized objects. If @var{tag} is 33607non-@code{nil}, the normalized objects are also recorded in the trail. 33608A typical stack-based computational command would take the form, 33609 33610@smallexample 33611(calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func} 33612 (calc-top-list-n @var{n}))) 33613@end smallexample 33614 33615If any of the @var{n} stack elements replaced contain sub-formula 33616selections, and selections have not been disabled by @kbd{j e}, 33617this function takes one of two courses of action. If @var{n} is 33618equal to the number of elements in @var{vals}, then each element of 33619@var{vals} is spliced into the corresponding selection; this is what 33620happens when you use the @key{TAB} key, or when you use a unary 33621arithmetic operation like @code{sqrt}. If @var{vals} has only one 33622element but @var{n} is greater than one, there must be only one 33623selection among the top @var{n} stack elements; the element from 33624@var{vals} is spliced into that selection. This is what happens when 33625you use a binary arithmetic operation like @kbd{+}. Any other 33626combination of @var{n} and @var{vals} is an error when selections 33627are present. 33628@end defun 33629 33630@defun calc-unary-op tag func arg 33631This function implements a unary operator that allows a numeric prefix 33632argument to apply the operator over many stack entries. If the prefix 33633argument @var{arg} is @code{nil}, this uses @code{calc-enter-result} 33634as outlined above. Otherwise, it maps the function over several stack 33635elements; @pxref{Prefix Arguments}. For example, 33636 33637@smallexample 33638(defun calc-zeta (arg) 33639 (interactive "P") 33640 (calc-unary-op "zeta" 'calcFunc-zeta arg)) 33641@end smallexample 33642@end defun 33643 33644@defun calc-binary-op tag func arg ident unary 33645This function implements a binary operator, analogously to 33646@code{calc-unary-op}. The optional @var{ident} and @var{unary} 33647arguments specify the behavior when the prefix argument is zero or 33648one, respectively. If the prefix is zero, the value @var{ident} 33649is pushed onto the stack, if specified, otherwise an error message 33650is displayed. If the prefix is one, the unary function @var{unary} 33651is applied to the top stack element, or, if @var{unary} is not 33652specified, nothing happens. When the argument is two or more, 33653the binary function @var{func} is reduced across the top @var{arg} 33654stack elements; when the argument is negative, the function is 33655mapped between the next-to-top @mathit{-@var{arg}} stack elements and the 33656top element. 33657@end defun 33658 33659@defun calc-stack-size 33660Return the number of elements on the stack as an integer. This count 33661does not include elements that have been temporarily hidden by stack 33662truncation; @pxref{Truncating the Stack}. 33663@end defun 33664 33665@defun calc-cursor-stack-index n 33666Move the point to the @var{n}th stack entry. If @var{n} is zero, this 33667will be the @samp{.} line. If @var{n} is from 1 to the current stack size, 33668this will be the beginning of the first line of that stack entry's display. 33669If line numbers are enabled, this will move to the first character of the 33670line number, not the stack entry itself. 33671@end defun 33672 33673@defun calc-substack-height n 33674Return the number of lines between the beginning of the @var{n}th stack 33675entry and the bottom of the buffer. If @var{n} is zero, this 33676will be one (assuming no stack truncation). If all stack entries are 33677one line long (i.e., no matrices are displayed), the return value will 33678be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big 33679mode, the return value includes the blank lines that separate stack 33680entries.) 33681@end defun 33682 33683@defun calc-refresh 33684Erase the @file{*Calculator*} buffer and reformat its contents from memory. 33685This must be called after changing any parameter, such as the current 33686display radix, which might change the appearance of existing stack 33687entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing 33688is suppressed, but a flag is set so that the entire stack will be refreshed 33689rather than just the top few elements when the macro finishes.) 33690@end defun 33691 33692@node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals 33693@subsubsection Predicates 33694 33695@noindent 33696The functions described here are predicates, that is, they return a 33697true/false value where @code{nil} means false and anything else means 33698true. These predicates are expanded by @code{defmath}, for example, 33699from @code{zerop} to @code{math-zerop}. In many cases they correspond 33700to native Lisp functions by the same name, but are extended to cover 33701the full range of Calc data types. 33702 33703@defun zerop x 33704Returns true if @var{x} is numerically zero, in any of the Calc data 33705types. (Note that for some types, such as error forms and intervals, 33706it never makes sense to return true.) In @code{defmath}, the expression 33707@samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)}, 33708and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}. 33709@end defun 33710 33711@defun negp x 33712Returns true if @var{x} is negative. This accepts negative real numbers 33713of various types, negative HMS and date forms, and intervals in which 33714all included values are negative. In @code{defmath}, the expression 33715@samp{(< x 0)} will automatically be converted to @samp{(math-negp x)}, 33716and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}. 33717@end defun 33718 33719@defun posp x 33720Returns true if @var{x} is positive (and non-zero). For complex 33721numbers, none of these three predicates will return true. 33722@end defun 33723 33724@defun looks-negp x 33725Returns true if @var{x} is ``negative-looking.'' This returns true if 33726@var{x} is a negative number, or a formula with a leading minus sign 33727such as @samp{-a/b}. In other words, this is an object which can be 33728made simpler by calling @code{(- @var{x})}. 33729@end defun 33730 33731@defun integerp x 33732Returns true if @var{x} is an integer of any size. 33733@end defun 33734 33735@defun fixnump x 33736Returns true if @var{x} is a native Lisp integer. 33737@end defun 33738 33739@defun natnump x 33740Returns true if @var{x} is a nonnegative integer of any size. 33741@end defun 33742 33743@defun fixnatnump x 33744Returns true if @var{x} is a nonnegative Lisp integer. 33745@end defun 33746 33747@defun num-integerp x 33748Returns true if @var{x} is numerically an integer, i.e., either a 33749true integer or a float with no significant digits to the right of 33750the decimal point. 33751@end defun 33752 33753@defun messy-integerp x 33754Returns true if @var{x} is numerically, but not literally, an integer. 33755A value is @code{num-integerp} if it is @code{integerp} or 33756@code{messy-integerp} (but it is never both at once). 33757@end defun 33758 33759@defun num-natnump x 33760Returns true if @var{x} is numerically a nonnegative integer. 33761@end defun 33762 33763@defun evenp x 33764Returns true if @var{x} is an even integer. 33765@end defun 33766 33767@defun looks-evenp x 33768Returns true if @var{x} is an even integer, or a formula with a leading 33769multiplicative coefficient which is an even integer. 33770@end defun 33771 33772@defun oddp x 33773Returns true if @var{x} is an odd integer. 33774@end defun 33775 33776@defun ratp x 33777Returns true if @var{x} is a rational number, i.e., an integer or a 33778fraction. 33779@end defun 33780 33781@defun realp x 33782Returns true if @var{x} is a real number, i.e., an integer, fraction, 33783or floating-point number. 33784@end defun 33785 33786@defun anglep x 33787Returns true if @var{x} is a real number or HMS form. 33788@end defun 33789 33790@defun floatp x 33791Returns true if @var{x} is a float, or a complex number, error form, 33792interval, date form, or modulo form in which at least one component 33793is a float. 33794@end defun 33795 33796@defun complexp x 33797Returns true if @var{x} is a rectangular or polar complex number 33798(but not a real number). 33799@end defun 33800 33801@defun rect-complexp x 33802Returns true if @var{x} is a rectangular complex number. 33803@end defun 33804 33805@defun polar-complexp x 33806Returns true if @var{x} is a polar complex number. 33807@end defun 33808 33809@defun numberp x 33810Returns true if @var{x} is a real number or a complex number. 33811@end defun 33812 33813@defun scalarp x 33814Returns true if @var{x} is a real or complex number or an HMS form. 33815@end defun 33816 33817@defun vectorp x 33818Returns true if @var{x} is a vector (this simply checks if its argument 33819is a list whose first element is the symbol @code{vec}). 33820@end defun 33821 33822@defun numvecp x 33823Returns true if @var{x} is a number or vector. 33824@end defun 33825 33826@defun matrixp x 33827Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors, 33828all of the same size. 33829@end defun 33830 33831@defun square-matrixp x 33832Returns true if @var{x} is a square matrix. 33833@end defun 33834 33835@defun objectp x 33836Returns true if @var{x} is any numeric Calc object, including real and 33837complex numbers, HMS forms, date forms, error forms, intervals, and 33838modulo forms. (Note that error forms and intervals may include formulas 33839as their components; see @code{constp} below.) 33840@end defun 33841 33842@defun objvecp x 33843Returns true if @var{x} is an object or a vector. This also accepts 33844incomplete objects, but it rejects variables and formulas (except as 33845mentioned above for @code{objectp}). 33846@end defun 33847 33848@defun primp x 33849Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object, 33850i.e., one whose components cannot be regarded as sub-formulas. This 33851includes variables, and all @code{objectp} types except error forms 33852and intervals. 33853@end defun 33854 33855@defun constp x 33856Returns true if @var{x} is constant, i.e., a real or complex number, 33857HMS form, date form, or error form, interval, or vector all of whose 33858components are @code{constp}. 33859@end defun 33860 33861@defun lessp x y 33862Returns true if @var{x} is numerically less than @var{y}. Returns false 33863if @var{x} is greater than or equal to @var{y}, or if the order is 33864undefined or cannot be determined. Generally speaking, this works 33865by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In 33866@code{defmath}, the expression @samp{(< x y)} will automatically be 33867converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=}, 33868and @code{>=} are similarly converted in terms of @code{lessp}. 33869@end defun 33870 33871@defun beforep x y 33872Returns true if @var{x} comes before @var{y} in a canonical ordering 33873of Calc objects. If @var{x} and @var{y} are both real numbers, this 33874will be the same as @code{lessp}. But whereas @code{lessp} considers 33875other types of objects to be unordered, @code{beforep} puts any two 33876objects into a definite, consistent order. The @code{beforep} 33877function is used by the @kbd{V S} vector-sorting command, and also 33878by Calc's algebraic simplifications to put the terms of a product into 33879canonical order: This allows @samp{x y + y x} to be simplified easily to 33880@samp{2 x y}. 33881@end defun 33882 33883@defun equal x y 33884This is the standard Lisp @code{equal} predicate; it returns true if 33885@var{x} and @var{y} are structurally identical. This is the usual way 33886to compare numbers for equality, but note that @code{equal} will treat 338870 and 0.0 as different. 33888@end defun 33889 33890@defun math-equal x y 33891Returns true if @var{x} and @var{y} are numerically equal, either because 33892they are @code{equal}, or because their difference is @code{zerop}. In 33893@code{defmath}, the expression @samp{(= x y)} will automatically be 33894converted to @samp{(math-equal x y)}. 33895@end defun 33896 33897@defun equal-int x n 33898Returns true if @var{x} and @var{n} are numerically equal, where @var{n} 33899is a fixnum which is not a multiple of 10. This will automatically be 33900used by @code{defmath} in place of the more general @code{math-equal} 33901whenever possible. 33902@end defun 33903 33904@defun nearly-equal x y 33905Returns true if @var{x} and @var{y}, as floating-point numbers, are 33906equal except possibly in the last decimal place. For example, 33907314.159 and 314.166 are considered nearly equal if the current 33908precision is 6 (since they differ by 7 units), but not if the current 33909precision is 7 (since they differ by 70 units). Most functions which 33910use series expansions use @code{with-extra-prec} to evaluate the 33911series with 2 extra digits of precision, then use @code{nearly-equal} 33912to decide when the series has converged; this guards against cumulative 33913error in the series evaluation without doing extra work which would be 33914lost when the result is rounded back down to the current precision. 33915In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}. 33916The @var{x} and @var{y} can be numbers of any kind, including complex. 33917@end defun 33918 33919@defun nearly-zerop x y 33920Returns true if @var{x} is nearly zero, compared to @var{y}. This 33921checks whether @var{x} plus @var{y} would by be @code{nearly-equal} 33922to @var{y} itself, to within the current precision, in other words, 33923if adding @var{x} to @var{y} would have a negligible effect on @var{y} 33924due to roundoff error. @var{X} may be a real or complex number, but 33925@var{y} must be real. 33926@end defun 33927 33928@defun is-true x 33929Return true if the formula @var{x} represents a true value in 33930Calc, not Lisp, terms. It tests if @var{x} is a non-zero number 33931or a provably non-zero formula. 33932@end defun 33933 33934@defun reject-arg val pred 33935Abort the current function evaluation due to unacceptable argument values. 33936This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a 33937Lisp error which @code{normalize} will trap. The net effect is that the 33938function call which led here will be left in symbolic form. 33939@end defun 33940 33941@defun inexact-value 33942If Symbolic mode is enabled, this will signal an error that causes 33943@code{normalize} to leave the formula in symbolic form, with the message 33944``Inexact result.'' (This function has no effect when not in Symbolic mode.) 33945Note that if your function calls @samp{(sin 5)} in Symbolic mode, the 33946@code{sin} function will call @code{inexact-value}, which will cause your 33947function to be left unsimplified. You may instead wish to call 33948@samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will 33949return the formula @samp{sin(5)} to your function. 33950@end defun 33951 33952@defun overflow 33953This signals an error that will be reported as a floating-point overflow. 33954@end defun 33955 33956@defun underflow 33957This signals a floating-point underflow. 33958@end defun 33959 33960@node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals 33961@subsubsection Computational Functions 33962 33963@noindent 33964The functions described here do the actual computational work of the 33965Calculator. In addition to these, note that any function described in 33966the main body of this manual may be called from Lisp; for example, if 33967the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command, 33968this means @code{calc-sqrt} is an interactive stack-based square-root 33969command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt}) 33970is the actual Lisp function for taking square roots. 33971 33972The functions @code{math-add}, @code{math-sub}, @code{math-mul}, 33973@code{math-div}, @code{math-mod}, and @code{math-neg} are not included 33974in this list, since @code{defmath} allows you to write native Lisp 33975@code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-}, 33976respectively, instead. 33977 33978@defun normalize val 33979(Full form: @code{math-normalize}.) 33980Reduce the value @var{val} to standard form. For example, if @var{val} 33981is a fixnum, it will be converted to a bignum if it is too large, and 33982if @var{val} is a bignum it will be normalized by clipping off trailing 33983(i.e., most-significant) zero digits and converting to a fixnum if it is 33984small. All the various data types are similarly converted to their standard 33985forms. Variables are left alone, but function calls are actually evaluated 33986in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will 33987return 6. 33988 33989If a function call fails, because the function is void or has the wrong 33990number of parameters, or because it returns @code{nil} or calls 33991@code{reject-arg} or @code{inexact-result}, @code{normalize} returns 33992the formula still in symbolic form. 33993 33994If the current simplification mode is ``none'' or ``numeric arguments 33995only,'' @code{normalize} will act appropriately. However, the more 33996powerful simplification modes (like Algebraic Simplification) are 33997not handled by @code{normalize}. They are handled by @code{calc-normalize}, 33998which calls @code{normalize} and possibly some other routines, such 33999as @code{simplify} or @code{simplify-units}. Programs generally will 34000never call @code{calc-normalize} except when popping or pushing values 34001on the stack. 34002@end defun 34003 34004@defun evaluate-expr expr 34005Replace all variables in @var{expr} that have values with their values, 34006then use @code{normalize} to simplify the result. This is what happens 34007when you press the @kbd{=} key interactively. 34008@end defun 34009 34010@defmac with-extra-prec n body 34011Evaluate the Lisp forms in @var{body} with precision increased by @var{n} 34012digits. This is a macro which expands to 34013 34014@smallexample 34015(math-normalize 34016 (let ((calc-internal-prec (+ calc-internal-prec @var{n}))) 34017 @var{body})) 34018@end smallexample 34019 34020The surrounding call to @code{math-normalize} causes a floating-point 34021result to be rounded down to the original precision afterwards. This 34022is important because some arithmetic operations assume a number's 34023mantissa contains no more digits than the current precision allows. 34024@end defmac 34025 34026@defun make-frac n d 34027Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling 34028@samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient. 34029@end defun 34030 34031@defun make-float mant exp 34032Build a floating-point value out of @var{mant} and @var{exp}, both 34033of which are arbitrary integers. This function will return a 34034properly normalized float value, or signal an overflow or underflow 34035if @var{exp} is out of range. 34036@end defun 34037 34038@defun make-sdev x sigma 34039Build an error form out of @var{x} and the absolute value of @var{sigma}. 34040If @var{sigma} is zero, the result is the number @var{x} directly. 34041If @var{sigma} is negative or complex, its absolute value is used. 34042If @var{x} or @var{sigma} is not a valid type of object for use in 34043error forms, this calls @code{reject-arg}. 34044@end defun 34045 34046@defun make-intv mask lo hi 34047Build an interval form out of @var{mask} (which is assumed to be an 34048integer from 0 to 3), and the limits @var{lo} and @var{hi}. If 34049@var{lo} is greater than @var{hi}, an empty interval form is returned. 34050This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable. 34051@end defun 34052 34053@defun sort-intv mask lo hi 34054Build an interval form, similar to @code{make-intv}, except that if 34055@var{lo} is less than @var{hi} they are simply exchanged, and the 34056bits of @var{mask} are swapped accordingly. 34057@end defun 34058 34059@defun make-mod n m 34060Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo 34061forms do not allow formulas as their components, if @var{n} or @var{m} 34062is not a real number or HMS form the result will be a formula which 34063is a call to @code{makemod}, the algebraic version of this function. 34064@end defun 34065 34066@defun float x 34067Convert @var{x} to floating-point form. Integers and fractions are 34068converted to numerically equivalent floats; components of complex 34069numbers, vectors, HMS forms, date forms, error forms, intervals, and 34070modulo forms are recursively floated. If the argument is a variable 34071or formula, this calls @code{reject-arg}. 34072@end defun 34073 34074@defun compare x y 34075Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if 34076@samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})}, 340770 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is 34078undefined or cannot be determined. 34079@end defun 34080 34081@defun numdigs n 34082Return the number of digits of integer @var{n}, effectively 34083@samp{ceil(log10(@var{n}))}, but much more efficient. Zero is 34084considered to have zero digits. 34085@end defun 34086 34087@defun scale-int x n 34088Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}} 34089digits with truncation toward zero. 34090@end defun 34091 34092@defun scale-rounding x n 34093Like @code{scale-int}, except that a right shift rounds to the nearest 34094integer rather than truncating. 34095@end defun 34096 34097@defun fixnum n 34098Return the integer @var{n} as a fixnum, i.e., a native Lisp integer. 34099If @var{n} is outside the permissible range for Lisp integers (usually 3410024 binary bits) the result is undefined. 34101@end defun 34102 34103@defun sqr x 34104Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}. 34105@end defun 34106 34107@defun quotient x y 34108Divide integer @var{x} by integer @var{y}; return an integer quotient 34109and discard the remainder. If @var{x} or @var{y} is negative, the 34110direction of rounding is undefined. 34111@end defun 34112 34113@defun idiv x y 34114Perform an integer division; if @var{x} and @var{y} are both nonnegative 34115integers, this uses the @code{quotient} function, otherwise it computes 34116@samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but 34117slower than for @code{quotient}. 34118@end defun 34119 34120@defun imod x y 34121Divide integer @var{x} by integer @var{y}; return the integer remainder 34122and discard the quotient. Like @code{quotient}, this works only for 34123integer arguments and is not well-defined for negative arguments. 34124For a more well-defined result, use @samp{(% @var{x} @var{y})}. 34125@end defun 34126 34127@defun idivmod x y 34128Divide integer @var{x} by integer @var{y}; return a cons cell whose 34129@code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr} 34130is @samp{(imod @var{x} @var{y})}. 34131@end defun 34132 34133@defun pow x y 34134Compute @var{x} to the power @var{y}. In @code{defmath} code, this can 34135also be written @samp{(^ @var{x} @var{y})} or 34136@w{@samp{(expt @var{x} @var{y})}}. 34137@end defun 34138 34139@defun abs-approx x 34140Compute a fast approximation to the absolute value of @var{x}. For 34141example, for a rectangular complex number the result is the sum of 34142the absolute values of the components. 34143@end defun 34144 34145@findex e 34146@findex gamma-const 34147@findex ln-2 34148@findex ln-10 34149@findex phi 34150@findex pi-over-2 34151@findex pi-over-4 34152@findex pi-over-180 34153@findex sqrt-two-pi 34154@findex sqrt-e 34155@findex two-pi 34156@defun pi 34157The function @samp{(pi)} computes @samp{pi} to the current precision. 34158Other related constant-generating functions are @code{two-pi}, 34159@code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi}, 34160@code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and 34161@code{gamma-const}. Each function returns a floating-point value in the 34162current precision, and each uses caching so that all calls after the 34163first are essentially free. 34164@end defun 34165 34166@defmac math-defcache @var{func} @var{initial} @var{form} 34167This macro, usually used as a top-level call like @code{defun} or 34168@code{defvar}, defines a new cached constant analogous to @code{pi}, etc. 34169It defines a function @code{func} which returns the requested value; 34170if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})} 34171form which serves as an initial value for the cache. If @var{func} 34172is called when the cache is empty or does not have enough digits to 34173satisfy the current precision, the Lisp expression @var{form} is evaluated 34174with the current precision increased by four, and the result minus its 34175two least significant digits is stored in the cache. For example, 34176calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34 34177digits, rounds it down to 32 digits for future use, then rounds it 34178again to 30 digits for use in the present request. 34179@end defmac 34180 34181@findex half-circle 34182@findex quarter-circle 34183@defun full-circle symb 34184If the current angular mode is Degrees or HMS, this function returns the 34185integer 360. In Radians mode, this function returns either the 34186corresponding value in radians to the current precision, or the formula 34187@samp{2*pi}, depending on the Symbolic mode. There are also similar 34188function @code{half-circle} and @code{quarter-circle}. 34189@end defun 34190 34191@defun power-of-2 n 34192Compute two to the integer power @var{n}, as a (potentially very large) 34193integer. Powers of two are cached, so only the first call for a 34194particular @var{n} is expensive. 34195@end defun 34196 34197@defun integer-log2 n 34198Compute the base-2 logarithm of @var{n}, which must be an integer which 34199is a power of two. If @var{n} is not a power of two, this function will 34200return @code{nil}. 34201@end defun 34202 34203@defun div-mod a b m 34204Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if 34205there is no solution, or if any of the arguments are not integers. 34206@end defun 34207 34208@defun pow-mod a b m 34209Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a}, 34210@var{b}, and @var{m} are integers, this uses an especially efficient 34211algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}. 34212@end defun 34213 34214@defun isqrt n 34215Compute the integer square root of @var{n}. This is the square root 34216of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}. 34217If @var{n} is itself an integer, the computation is especially efficient. 34218@end defun 34219 34220@defun to-hms a ang 34221Convert the argument @var{a} into an HMS form. If @var{ang} is specified, 34222it is the angular mode in which to interpret @var{a}, either @code{deg} 34223or @code{rad}. Otherwise, the current angular mode is used. If @var{a} 34224is already an HMS form it is returned as-is. 34225@end defun 34226 34227@defun from-hms a ang 34228Convert the HMS form @var{a} into a real number. If @var{ang} is specified, 34229it is the angular mode in which to express the result, otherwise the 34230current angular mode is used. If @var{a} is already a real number, it 34231is returned as-is. 34232@end defun 34233 34234@defun to-radians a 34235Convert the number or HMS form @var{a} to radians from the current 34236angular mode. 34237@end defun 34238 34239@defun from-radians a 34240Convert the number @var{a} from radians to the current angular mode. 34241If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}. 34242@end defun 34243 34244@defun to-radians-2 a 34245Like @code{to-radians}, except that in Symbolic mode a degrees to 34246radians conversion yields a formula like @samp{@var{a}*pi/180}. 34247@end defun 34248 34249@defun from-radians-2 a 34250Like @code{from-radians}, except that in Symbolic mode a radians to 34251degrees conversion yields a formula like @samp{@var{a}*180/pi}. 34252@end defun 34253 34254@defun random-digit 34255Produce a random base-1000 digit in the range 0 to 999. 34256@end defun 34257 34258@defun random-digits n 34259Produce a random @var{n}-digit integer; this will be an integer 34260in the interval @samp{[0, 10^@var{n})}. 34261@end defun 34262 34263@defun random-float 34264Produce a random float in the interval @samp{[0, 1)}. 34265@end defun 34266 34267@defun prime-test n iters 34268Determine whether the integer @var{n} is prime. Return a list which has 34269one of these forms: @samp{(nil @var{f})} means the number is non-prime 34270because it was found to be divisible by @var{f}; @samp{(nil)} means it 34271was found to be non-prime by table look-up (so no factors are known); 34272@samp{(nil unknown)} means it is definitely non-prime but no factors 34273are known because @var{n} was large enough that Fermat's probabilistic 34274test had to be used; @samp{(t)} means the number is definitely prime; 34275and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i} 34276iterations, is @var{p} percent sure that the number is prime. The 34277@var{iters} parameter is the number of Fermat iterations to use, in the 34278case that this is necessary. If @code{prime-test} returns ``maybe,'' 34279you can call it again with the same @var{n} to get a greater certainty; 34280@code{prime-test} remembers where it left off. 34281@end defun 34282 34283@defun to-simple-fraction f 34284If @var{f} is a floating-point number which can be represented exactly 34285as a small rational number, return that number, else return @var{f}. 34286For example, 0.75 would be converted to 3:4. This function is very 34287fast. 34288@end defun 34289 34290@defun to-fraction f tol 34291Find a rational approximation to floating-point number @var{f} to within 34292a specified tolerance @var{tol}; this corresponds to the algebraic 34293function @code{frac}, and can be rather slow. 34294@end defun 34295 34296@defun quarter-integer n 34297If @var{n} is an integer or integer-valued float, this function 34298returns zero. If @var{n} is a half-integer (i.e., an integer plus 34299@mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer, 34300it returns 1 or 3. If @var{n} is anything else, this function 34301returns @code{nil}. 34302@end defun 34303 34304@node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals 34305@subsubsection Vector Functions 34306 34307@noindent 34308The functions described here perform various operations on vectors and 34309matrices. 34310 34311@defun math-concat x y 34312Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}} 34313in a symbolic formula. @xref{Building Vectors}. 34314@end defun 34315 34316@defun vec-length v 34317Return the length of vector @var{v}. If @var{v} is not a vector, the 34318result is zero. If @var{v} is a matrix, this returns the number of 34319rows in the matrix. 34320@end defun 34321 34322@defun mat-dimens m 34323Determine the dimensions of vector or matrix @var{m}. If @var{m} is not 34324a vector, the result is an empty list. If @var{m} is a plain vector 34325but not a matrix, the result is a one-element list containing the length 34326of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns, 34327the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors 34328produce lists of more than two dimensions. Note that the object 34329@samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size, 34330and is treated by this and other Calc routines as a plain vector of two 34331elements. 34332@end defun 34333 34334@defun dimension-error 34335Abort the current function with a message of ``Dimension error.'' 34336The Calculator will leave the function being evaluated in symbolic 34337form; this is really just a special case of @code{reject-arg}. 34338@end defun 34339 34340@defun build-vector args 34341Return a Calc vector with @var{args} as elements. 34342For example, @samp{(build-vector 1 2 3)} returns the Calc vector 34343@samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}. 34344@end defun 34345 34346@defun make-vec obj dims 34347Return a Calc vector or matrix all of whose elements are equal to 34348@var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix 34349filled with 27's. 34350@end defun 34351 34352@defun row-matrix v 34353If @var{v} is a plain vector, convert it into a row matrix, i.e., 34354a matrix whose single row is @var{v}. If @var{v} is already a matrix, 34355leave it alone. 34356@end defun 34357 34358@defun col-matrix v 34359If @var{v} is a plain vector, convert it into a column matrix, i.e., a 34360matrix with each element of @var{v} as a separate row. If @var{v} is 34361already a matrix, leave it alone. 34362@end defun 34363 34364@defun map-vec f v 34365Map the Lisp function @var{f} over the Calc vector @var{v}. For example, 34366@samp{(map-vec 'math-floor v)} returns a vector of the floored components 34367of vector @var{v}. 34368@end defun 34369 34370@defun map-vec-2 f a b 34371Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}. 34372If @var{a} and @var{b} are vectors of equal length, the result is a 34373vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})} 34374for each pair of elements @var{ai} and @var{bi}. If either @var{a} or 34375@var{b} is a scalar, it is matched with each value of the other vector. 34376For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v} 34377with each element increased by one. Note that using @samp{'+} would not 34378work here, since @code{defmath} does not expand function names everywhere, 34379just where they are in the function position of a Lisp expression. 34380@end defun 34381 34382@defun reduce-vec f v 34383Reduce the function @var{f} over the vector @var{v}. For example, if 34384@var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}. 34385If @var{v} is a matrix, this reduces over the rows of @var{v}. 34386@end defun 34387 34388@defun reduce-cols f m 34389Reduce the function @var{f} over the columns of matrix @var{m}. For 34390example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result 34391is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}. 34392@end defun 34393 34394@defun mat-row m n 34395Return the @var{n}th row of matrix @var{m}. This is equivalent to 34396@samp{(elt m n)}. For a slower but safer version, use @code{mrow}. 34397(@xref{Extracting Elements}.) 34398@end defun 34399 34400@defun mat-col m n 34401Return the @var{n}th column of matrix @var{m}, in the form of a vector. 34402The arguments are not checked for correctness. 34403@end defun 34404 34405@defun mat-less-row m n 34406Return a copy of matrix @var{m} with its @var{n}th row deleted. The 34407number @var{n} must be in range from 1 to the number of rows in @var{m}. 34408@end defun 34409 34410@defun mat-less-col m n 34411Return a copy of matrix @var{m} with its @var{n}th column deleted. 34412@end defun 34413 34414@defun transpose m 34415Return the transpose of matrix @var{m}. 34416@end defun 34417 34418@defun flatten-vector v 34419Flatten nested vector @var{v} into a vector of scalars. For example, 34420if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}. 34421@end defun 34422 34423@defun copy-matrix m 34424If @var{m} is a matrix, return a copy of @var{m}. This maps 34425@code{copy-sequence} over the rows of @var{m}; in Lisp terms, each 34426element of the result matrix will be @code{eq} to the corresponding 34427element of @var{m}, but none of the @code{cons} cells that make up 34428the structure of the matrix will be @code{eq}. If @var{m} is a plain 34429vector, this is the same as @code{copy-sequence}. 34430@end defun 34431 34432@defun swap-rows m r1 r2 34433Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In 34434other words, unlike most of the other functions described here, this 34435function changes @var{m} itself rather than building up a new result 34436matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)} 34437is true, with the side effect of exchanging the first two rows of 34438@var{m}. 34439@end defun 34440 34441@node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals 34442@subsubsection Symbolic Functions 34443 34444@noindent 34445The functions described here operate on symbolic formulas in the 34446Calculator. 34447 34448@defun calc-prepare-selection num 34449Prepare a stack entry for selection operations. If @var{num} is 34450omitted, the stack entry containing the cursor is used; otherwise, 34451it is the number of the stack entry to use. This function stores 34452useful information about the current stack entry into a set of 34453variables. @code{calc-selection-cache-num} contains the number of 34454the stack entry involved (equal to @var{num} if you specified it); 34455@code{calc-selection-cache-entry} contains the stack entry as a 34456list (such as @code{calc-top-list} would return with @code{entry} 34457as the selection mode); and @code{calc-selection-cache-comp} contains 34458a special ``tagged'' composition (@pxref{Formatting Lisp Functions}) 34459which allows Calc to relate cursor positions in the buffer with 34460their corresponding sub-formulas. 34461 34462A slight complication arises in the selection mechanism because 34463formulas may contain small integers. For example, in the vector 34464@samp{[1, 2, 1]} the first and last elements are @code{eq} to each 34465other; selections are recorded as the actual Lisp object that 34466appears somewhere in the tree of the whole formula, but storing 34467@code{1} would falsely select both @code{1}'s in the vector. So 34468@code{calc-prepare-selection} also checks the stack entry and 34469replaces any plain integers with ``complex number'' lists of the form 34470@samp{(cplx @var{n} 0)}. This list will be displayed the same as a 34471plain @var{n} and the change will be completely invisible to the 34472user, but it will guarantee that no two sub-formulas of the stack 34473entry will be @code{eq} to each other. Next time the stack entry 34474is involved in a computation, @code{calc-normalize} will replace 34475these lists with plain numbers again, again invisibly to the user. 34476@end defun 34477 34478@defun calc-encase-atoms x 34479This modifies the formula @var{x} to ensure that each part of the 34480formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick 34481described above. This function may use @code{setcar} to modify 34482the formula in-place. 34483@end defun 34484 34485@defun calc-find-selected-part 34486Find the smallest sub-formula of the current formula that contains 34487the cursor. This assumes @code{calc-prepare-selection} has been 34488called already. If the cursor is not actually on any part of the 34489formula, this returns @code{nil}. 34490@end defun 34491 34492@defun calc-change-current-selection selection 34493Change the currently prepared stack element's selection to 34494@var{selection}, which should be @code{eq} to some sub-formula 34495of the stack element, or @code{nil} to unselect the formula. 34496The stack element's appearance in the Calc buffer is adjusted 34497to reflect the new selection. 34498@end defun 34499 34500@defun calc-find-nth-part expr n 34501Return the @var{n}th sub-formula of @var{expr}. This function is used 34502by the selection commands, and (unless @kbd{j b} has been used) treats 34503sums and products as flat many-element formulas. Thus if @var{expr} 34504is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with 34505@var{n} equal to four will return @samp{d}. 34506@end defun 34507 34508@defun calc-find-parent-formula expr part 34509Return the sub-formula of @var{expr} which immediately contains 34510@var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part} 34511is @code{eq} to the @samp{c+1} term of @var{expr}, then this function 34512will return @samp{(c+1)*d}. If @var{part} turns out not to be a 34513sub-formula of @var{expr}, the function returns @code{nil}. If 34514@var{part} is @code{eq} to @var{expr}, the function returns @code{t}. 34515This function does not take associativity into account. 34516@end defun 34517 34518@defun calc-find-assoc-parent-formula expr part 34519This is the same as @code{calc-find-parent-formula}, except that 34520(unless @kbd{j b} has been used) it continues widening the selection 34521to contain a complete level of the formula. Given @samp{a} from 34522@samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will 34523return @samp{a + b} but @code{calc-find-assoc-parent-formula} will 34524return the whole expression. 34525@end defun 34526 34527@defun calc-grow-assoc-formula expr part 34528This expands sub-formula @var{part} of @var{expr} to encompass a 34529complete level of the formula. If @var{part} and its immediate 34530parent are not compatible associative operators, or if @kbd{j b} 34531has been used, this simply returns @var{part}. 34532@end defun 34533 34534@defun calc-find-sub-formula expr part 34535This finds the immediate sub-formula of @var{expr} which contains 34536@var{part}. It returns an index @var{n} such that 34537@samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}. 34538If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}. 34539If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This 34540function does not take associativity into account. 34541@end defun 34542 34543@defun calc-replace-sub-formula expr old new 34544This function returns a copy of formula @var{expr}, with the 34545sub-formula that is @code{eq} to @var{old} replaced by @var{new}. 34546@end defun 34547 34548@defun simplify expr 34549Simplify the expression @var{expr} by applying Calc's algebraic 34550simplifications. This always returns a copy of the expression; the 34551structure @var{expr} points to remains unchanged in memory. 34552 34553More precisely, here is what @code{simplify} does: The expression is 34554first normalized and evaluated by calling @code{normalize}. If any 34555@code{AlgSimpRules} have been defined, they are then applied. Then 34556the expression is traversed in a depth-first, bottom-up fashion; at 34557each level, any simplifications that can be made are made until no 34558further changes are possible. Once the entire formula has been 34559traversed in this way, it is compared with the original formula (from 34560before the call to @code{normalize}) and, if it has changed, 34561the entire procedure is repeated (starting with @code{normalize}) 34562until no further changes occur. Usually only two iterations are 34563needed: one to simplify the formula, and another to verify that no 34564further simplifications were possible. 34565@end defun 34566 34567@defun simplify-extended expr 34568Simplify the expression @var{expr}, with additional rules enabled that 34569help do a more thorough job, while not being entirely ``safe'' in all 34570circumstances. (For example, this mode will simplify @samp{sqrt(x^2)} 34571to @samp{x}, which is only valid when @var{x} is positive.) This is 34572implemented by temporarily binding the variable @code{math-living-dangerously} 34573to @code{t} (using a @code{let} form) and calling @code{simplify}. 34574Dangerous simplification rules are written to check this variable 34575before taking any action. 34576@end defun 34577 34578@defun simplify-units expr 34579Simplify the expression @var{expr}, treating variable names as units 34580whenever possible. This works by binding the variable 34581@code{math-simplifying-units} to @code{t} while calling @code{simplify}. 34582@end defun 34583 34584@defmac math-defsimplify funcs body 34585Register a new simplification rule; this is normally called as a top-level 34586form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol 34587(like @code{+} or @code{calcFunc-sqrt}), this simplification rule is 34588applied to the formulas which are calls to the specified function. Or, 34589@var{funcs} can be a list of such symbols; the rule applies to all 34590functions on the list. The @var{body} is written like the body of a 34591function with a single argument called @code{expr}. The body will be 34592executed with @code{expr} bound to a formula which is a call to one of 34593the functions @var{funcs}. If the function body returns @code{nil}, or 34594if it returns a result @code{equal} to the original @code{expr}, it is 34595ignored and Calc goes on to try the next simplification rule that applies. 34596If the function body returns something different, that new formula is 34597substituted for @var{expr} in the original formula. 34598 34599At each point in the formula, rules are tried in the order of the 34600original calls to @code{math-defsimplify}; the search stops after the 34601first rule that makes a change. Thus later rules for that same 34602function will not have a chance to trigger until the next iteration 34603of the main @code{simplify} loop. 34604 34605Note that, since @code{defmath} is not being used here, @var{body} must 34606be written in true Lisp code without the conveniences that @code{defmath} 34607provides. If you prefer, you can have @var{body} simply call another 34608function (defined with @code{defmath}) which does the real work. 34609 34610The arguments of a function call will already have been simplified 34611before any rules for the call itself are invoked. Since a new argument 34612list is consed up when this happens, this means that the rule's body is 34613allowed to rearrange the function's arguments destructively if that is 34614convenient. Here is a typical example of a simplification rule: 34615 34616@smallexample 34617(math-defsimplify calcFunc-arcsinh 34618 (or (and (math-looks-negp (nth 1 expr)) 34619 (math-neg (list 'calcFunc-arcsinh 34620 (math-neg (nth 1 expr))))) 34621 (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh) 34622 (or math-living-dangerously 34623 (math-known-realp (nth 1 (nth 1 expr)))) 34624 (nth 1 (nth 1 expr))))) 34625@end smallexample 34626 34627This is really a pair of rules written with one @code{math-defsimplify} 34628for convenience; the first replaces @samp{arcsinh(-x)} with 34629@samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x}, 34630replaces @samp{arcsinh(sinh(x))} with @samp{x}. 34631@end defmac 34632 34633@defun common-constant-factor expr 34634Check @var{expr} to see if it is a sum of terms all multiplied by the 34635same rational value. If so, return this value. If not, return @code{nil}. 34636For example, if called on @samp{6x + 9y + 12z}, it would return 3, since 346373 is a common factor of all the terms. 34638@end defun 34639 34640@defun cancel-common-factor expr factor 34641Assuming @var{expr} is a sum with @var{factor} as a common factor, 34642divide each term of the sum by @var{factor}. This is done by 34643destructively modifying parts of @var{expr}, on the assumption that 34644it is being used by a simplification rule (where such things are 34645allowed; see above). For example, consider this built-in rule for 34646square roots: 34647 34648@smallexample 34649(math-defsimplify calcFunc-sqrt 34650 (let ((fac (math-common-constant-factor (nth 1 expr)))) 34651 (and fac (not (eq fac 1)) 34652 (math-mul (math-normalize (list 'calcFunc-sqrt fac)) 34653 (math-normalize 34654 (list 'calcFunc-sqrt 34655 (math-cancel-common-factor 34656 (nth 1 expr) fac))))))) 34657@end smallexample 34658@end defun 34659 34660@defun frac-gcd a b 34661Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be 34662rational numbers. This is the fraction composed of the GCD of the 34663numerators of @var{a} and @var{b}, over the GCD of the denominators. 34664It is used by @code{common-constant-factor}. Note that the standard 34665@code{gcd} function uses the LCM to combine the denominators. 34666@end defun 34667 34668@defun map-tree func expr many 34669Try applying Lisp function @var{func} to various sub-expressions of 34670@var{expr}. Initially, call @var{func} with @var{expr} itself as an 34671argument. If this returns an expression which is not @code{equal} to 34672@var{expr}, apply @var{func} again until eventually it does return 34673@var{expr} with no changes. Then, if @var{expr} is a function call, 34674recursively apply @var{func} to each of the arguments. This keeps going 34675until no changes occur anywhere in the expression; this final expression 34676is returned by @code{map-tree}. Note that, unlike simplification rules, 34677@var{func} functions may @emph{not} make destructive changes to 34678@var{expr}. If a third argument @var{many} is provided, it is an 34679integer which says how many times @var{func} may be applied; the 34680default, as described above, is infinitely many times. 34681@end defun 34682 34683@defun compile-rewrites rules 34684Compile the rewrite rule set specified by @var{rules}, which should 34685be a formula that is either a vector or a variable name. If the latter, 34686the compiled rules are saved so that later @code{compile-rules} calls 34687for that same variable can return immediately. If there are problems 34688with the rules, this function calls @code{error} with a suitable 34689message. 34690@end defun 34691 34692@defun apply-rewrites expr crules heads 34693Apply the compiled rewrite rule set @var{crules} to the expression 34694@var{expr}. This will make only one rewrite and only checks at the 34695top level of the expression. The result @code{nil} if no rules 34696matched, or if the only rules that matched did not actually change 34697the expression. The @var{heads} argument is optional; if is given, 34698it should be a list of all function names that (may) appear in 34699@var{expr}. The rewrite compiler tags each rule with the 34700rarest-looking function name in the rule; if you specify @var{heads}, 34701@code{apply-rewrites} can use this information to narrow its search 34702down to just a few rules in the rule set. 34703@end defun 34704 34705@defun rewrite-heads expr 34706Compute a @var{heads} list for @var{expr} suitable for use with 34707@code{apply-rewrites}, as discussed above. 34708@end defun 34709 34710@defun rewrite expr rules many 34711This is an all-in-one rewrite function. It compiles the rule set 34712specified by @var{rules}, then uses @code{map-tree} to apply the 34713rules throughout @var{expr} up to @var{many} (default infinity) 34714times. 34715@end defun 34716 34717@defun match-patterns pat vec not-flag 34718Given a Calc vector @var{vec} and an uncompiled pattern set or 34719pattern set variable @var{pat}, this function returns a new vector 34720of all elements of @var{vec} which do (or don't, if @var{not-flag} is 34721non-@code{nil}) match any of the patterns in @var{pat}. 34722@end defun 34723 34724@defun deriv expr var value symb 34725Compute the derivative of @var{expr} with respect to variable @var{var} 34726(which may actually be any sub-expression). If @var{value} is specified, 34727the derivative is evaluated at the value of @var{var}; otherwise, the 34728derivative is left in terms of @var{var}. If the expression contains 34729functions for which no derivative formula is known, new derivative 34730functions are invented by adding primes to the names; @pxref{Calculus}. 34731However, if @var{symb} is non-@code{nil}, the presence of nondifferentiable 34732functions in @var{expr} instead cancels the whole differentiation, and 34733@code{deriv} returns @code{nil} instead. 34734 34735Derivatives of an @var{n}-argument function can be defined by 34736adding a @code{math-derivative-@var{n}} property to the property list 34737of the symbol for the function's derivative, which will be the 34738function name followed by an apostrophe. The value of the property 34739should be a Lisp function; it is called with the same arguments as the 34740original function call that is being differentiated. It should return 34741a formula for the derivative. For example, the derivative of @code{ln} 34742is defined by 34743 34744@smallexample 34745(put 'calcFunc-ln\' 'math-derivative-1 34746 (function (lambda (u) (math-div 1 u)))) 34747@end smallexample 34748 34749The two-argument @code{log} function has two derivatives, 34750@smallexample 34751(put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx 34752 (function (lambda (x b) ... ))) 34753(put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db 34754 (function (lambda (x b) ... ))) 34755@end smallexample 34756@end defun 34757 34758@defun tderiv expr var value symb 34759Compute the total derivative of @var{expr}. This is the same as 34760@code{deriv}, except that variables other than @var{var} are not 34761assumed to be constant with respect to @var{var}. 34762@end defun 34763 34764@defun integ expr var low high 34765Compute the integral of @var{expr} with respect to @var{var}. 34766@xref{Calculus}, for further details. 34767@end defun 34768 34769@defmac math-defintegral funcs body 34770Define a rule for integrating a function or functions of one argument; 34771this macro is very similar in format to @code{math-defsimplify}. 34772The main difference is that here @var{body} is the body of a function 34773with a single argument @code{u} which is bound to the argument to the 34774function being integrated, not the function call itself. Also, the 34775variable of integration is available as @code{math-integ-var}. If 34776evaluation of the integral requires doing further integrals, the body 34777should call @samp{(math-integral @var{x})} to find the integral of 34778@var{x} with respect to @code{math-integ-var}; this function returns 34779@code{nil} if the integral could not be done. Some examples: 34780 34781@smallexample 34782(math-defintegral calcFunc-conj 34783 (let ((int (math-integral u))) 34784 (and int 34785 (list 'calcFunc-conj int)))) 34786 34787(math-defintegral calcFunc-cos 34788 (and (equal u math-integ-var) 34789 (math-from-radians-2 (list 'calcFunc-sin u)))) 34790@end smallexample 34791 34792In the @code{cos} example, we define only the integral of @samp{cos(x) dx}, 34793relying on the general integration-by-substitution facility to handle 34794cosines of more complicated arguments. An integration rule should return 34795@code{nil} if it can't do the integral; if several rules are defined for 34796the same function, they are tried in order until one returns a non-@code{nil} 34797result. 34798@end defmac 34799 34800@defmac math-defintegral-2 funcs body 34801Define a rule for integrating a function or functions of two arguments. 34802This is exactly analogous to @code{math-defintegral}, except that @var{body} 34803is written as the body of a function with two arguments, @var{u} and 34804@var{v}. 34805@end defmac 34806 34807@defun solve-for lhs rhs var full 34808Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating 34809the variable @var{var} on the lefthand side; return the resulting righthand 34810side, or @code{nil} if the equation cannot be solved. The variable 34811@var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that 34812the return value is a formula which does not contain @var{var}; this is 34813different from the user-level @code{solve} and @code{finv} functions, 34814which return a rearranged equation or a functional inverse, respectively. 34815If @var{full} is non-@code{nil}, a full solution including dummy signs 34816and dummy integers will be produced. User-defined inverses are provided 34817as properties in a manner similar to derivatives: 34818 34819@smallexample 34820(put 'calcFunc-ln 'math-inverse 34821 (function (lambda (x) (list 'calcFunc-exp x)))) 34822@end smallexample 34823 34824This function can call @samp{(math-solve-get-sign @var{x})} to create 34825a new arbitrary sign variable, returning @var{x} times that sign, and 34826@samp{(math-solve-get-int @var{x})} to create a new arbitrary integer 34827variable multiplied by @var{x}. These functions simply return @var{x} 34828if the caller requested a non-``full'' solution. 34829@end defun 34830 34831@defun solve-eqn expr var full 34832This version of @code{solve-for} takes an expression which will 34833typically be an equation or inequality. (If it is not, it will be 34834interpreted as the equation @samp{@var{expr} = 0}.) It returns an 34835equation or inequality, or @code{nil} if no solution could be found. 34836@end defun 34837 34838@defun solve-system exprs vars full 34839This function solves a system of equations. Generally, @var{exprs} 34840and @var{vars} will be vectors of equal length. 34841@xref{Solving Systems of Equations}, for other options. 34842@end defun 34843 34844@defun expr-contains expr var 34845Returns a non-@code{nil} value if @var{var} occurs as a subexpression 34846of @var{expr}. 34847 34848This function might seem at first to be identical to 34849@code{calc-find-sub-formula}. The key difference is that 34850@code{expr-contains} uses @code{equal} to test for matches, whereas 34851@code{calc-find-sub-formula} uses @code{eq}. In the formula 34852@samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not 34853@code{eq} to each other. 34854@end defun 34855 34856@defun expr-contains-count expr var 34857Returns the number of occurrences of @var{var} as a subexpression 34858of @var{expr}, or @code{nil} if there are no occurrences. 34859@end defun 34860 34861@defun expr-depends expr var 34862Returns true if @var{expr} refers to any variable the occurs in @var{var}. 34863In other words, it checks if @var{expr} and @var{var} have any variables 34864in common. 34865@end defun 34866 34867@defun expr-contains-vars expr 34868Return true if @var{expr} contains any variables, or @code{nil} if @var{expr} 34869contains only constants and functions with constant arguments. 34870@end defun 34871 34872@defun expr-subst expr old new 34873Returns a copy of @var{expr}, with all occurrences of @var{old} replaced 34874by @var{new}. This treats @code{lambda} forms specially with respect 34875to the dummy argument variables, so that the effect is always to return 34876@var{expr} evaluated at @var{old} = @var{new}. 34877@end defun 34878 34879@defun multi-subst expr old new 34880This is like @code{expr-subst}, except that @var{old} and @var{new} 34881are lists of expressions to be substituted simultaneously. If one 34882list is shorter than the other, trailing elements of the longer list 34883are ignored. 34884@end defun 34885 34886@defun expr-weight expr 34887Returns the ``weight'' of @var{expr}, basically a count of the total 34888number of objects and function calls that appear in @var{expr}. For 34889``primitive'' objects, this will be one. 34890@end defun 34891 34892@defun expr-height expr 34893Returns the ``height'' of @var{expr}, which is the deepest level to 34894which function calls are nested. (Note that @samp{@var{a} + @var{b}} 34895counts as a function call.) For primitive objects, this returns zero. 34896@end defun 34897 34898@defun polynomial-p expr var 34899Check if @var{expr} is a polynomial in variable (or sub-expression) 34900@var{var}. If so, return the degree of the polynomial, that is, the 34901highest power of @var{var} that appears in @var{expr}. For example, 34902for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns 34903@code{nil} unless @var{expr}, when expanded out by @kbd{a x} 34904(@code{calc-expand}), would consist of a sum of terms in which @var{var} 34905appears only raised to nonnegative integer powers. Note that if 34906@var{var} does not occur in @var{expr}, then @var{expr} is considered 34907a polynomial of degree 0. 34908@end defun 34909 34910@defun is-polynomial expr var degree loose 34911Check if @var{expr} is a polynomial in variable or sub-expression 34912@var{var}, and, if so, return a list representation of the polynomial 34913where the elements of the list are coefficients of successive powers of 34914@var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the 34915list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would 34916produce the list @samp{(1 2 1)}. The highest element of the list will 34917be non-zero, with the special exception that if @var{expr} is the 34918constant zero, the returned value will be @samp{(0)}. Return @code{nil} 34919if @var{expr} is not a polynomial in @var{var}. If @var{degree} is 34920specified, this will not consider polynomials of degree higher than that 34921value. This is a good precaution because otherwise an input of 34922@samp{(x+1)^1000} will cause a huge coefficient list to be built. If 34923@var{loose} is non-@code{nil}, then a looser definition of a polynomial 34924is used in which coefficients are no longer required not to depend on 34925@var{var}, but are only required not to take the form of polynomials 34926themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose 34927polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin 34928x))}. The result will never be @code{nil} in loose mode, since any 34929expression can be interpreted as a ``constant'' loose polynomial. 34930@end defun 34931 34932@defun polynomial-base expr pred 34933Check if @var{expr} is a polynomial in any variable that occurs in it; 34934if so, return that variable. (If @var{expr} is a multivariate polynomial, 34935this chooses one variable arbitrarily.) If @var{pred} is specified, it should 34936be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})}, 34937and which should return true if @code{mpb-top-expr} (a global name for 34938the original @var{expr}) is a suitable polynomial in @var{subexpr}. 34939The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})}; 34940you can use @var{pred} to specify additional conditions. Or, you could 34941have @var{pred} build up a list of every suitable @var{subexpr} that 34942is found. 34943@end defun 34944 34945@defun poly-simplify poly 34946Simplify polynomial coefficient list @var{poly} by (destructively) 34947clipping off trailing zeros. 34948@end defun 34949 34950@defun poly-mix a ac b bc 34951Mix two polynomial lists @var{a} and @var{b} (in the form returned by 34952@code{is-polynomial}) in a linear combination with coefficient expressions 34953@var{ac} and @var{bc}. The result is a (not necessarily simplified) 34954polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}. 34955@end defun 34956 34957@defun poly-mul a b 34958Multiply two polynomial coefficient lists @var{a} and @var{b}. The 34959result will be in simplified form if the inputs were simplified. 34960@end defun 34961 34962@defun build-polynomial-expr poly var 34963Construct a Calc formula which represents the polynomial coefficient 34964list @var{poly} applied to variable @var{var}. The @kbd{a c} 34965(@code{calc-collect}) command uses @code{is-polynomial} to turn an 34966expression into a coefficient list, then @code{build-polynomial-expr} 34967to turn the list back into an expression in regular form. 34968@end defun 34969 34970@defun check-unit-name var 34971Check if @var{var} is a variable which can be interpreted as a unit 34972name. If so, return the units table entry for that unit. This 34973will be a list whose first element is the unit name (not counting 34974prefix characters) as a symbol and whose second element is the 34975Calc expression which defines the unit. (Refer to the Calc sources 34976for details on the remaining elements of this list.) If @var{var} 34977is not a variable or is not a unit name, return @code{nil}. 34978@end defun 34979 34980@defun units-in-expr-p expr sub-exprs 34981Return true if @var{expr} contains any variables which can be 34982interpreted as units. If @var{sub-exprs} is @code{t}, the entire 34983expression is searched. If @var{sub-exprs} is @code{nil}, this 34984checks whether @var{expr} is directly a units expression. 34985@end defun 34986 34987@defun single-units-in-expr-p expr 34988Check whether @var{expr} contains exactly one units variable. If so, 34989return the units table entry for the variable. If @var{expr} does 34990not contain any units, return @code{nil}. If @var{expr} contains 34991two or more units, return the symbol @code{wrong}. 34992@end defun 34993 34994@defun to-standard-units expr which 34995Convert units expression @var{expr} to base units. If @var{which} 34996is @code{nil}, use Calc's native base units. Otherwise, @var{which} 34997can specify a units system, which is a list of two-element lists, 34998where the first element is a Calc base symbol name and the second 34999is an expression to substitute for it. 35000@end defun 35001 35002@defun remove-units expr 35003Return a copy of @var{expr} with all units variables replaced by ones. 35004This expression is generally normalized before use. 35005@end defun 35006 35007@defun extract-units expr 35008Return a copy of @var{expr} with everything but units variables replaced 35009by ones. 35010@end defun 35011 35012@node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals 35013@subsubsection I/O and Formatting Functions 35014 35015@noindent 35016The functions described here are responsible for parsing and formatting 35017Calc numbers and formulas. 35018 35019@defun calc-eval str sep arg1 arg2 @dots{} 35020This is the simplest interface to the Calculator from another Lisp program. 35021@xref{Calling Calc from Your Programs}. 35022@end defun 35023 35024@defun read-number str 35025If string @var{str} contains a valid Calc number, either integer, 35026fraction, float, or HMS form, this function parses and returns that 35027number. Otherwise, it returns @code{nil}. 35028@end defun 35029 35030@defun read-expr str 35031Read an algebraic expression from string @var{str}. If @var{str} does 35032not have the form of a valid expression, return a list of the form 35033@samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index 35034into @var{str} of the general location of the error, and @var{msg} is 35035a string describing the problem. 35036@end defun 35037 35038@defun read-exprs str 35039Read a list of expressions separated by commas, and return it as a 35040Lisp list. If an error occurs in any expressions, an error list as 35041shown above is returned instead. 35042@end defun 35043 35044@defun calc-do-alg-entry initial prompt no-norm 35045Read an algebraic formula or formulas using the minibuffer. All 35046conventions of regular algebraic entry are observed. The return value 35047is a list of Calc formulas; there will be more than one if the user 35048entered a list of values separated by commas. The result is @code{nil} 35049if the user presses Return with a blank line. If @var{initial} is 35050given, it is a string which the minibuffer will initially contain. 35051If @var{prompt} is given, it is the prompt string to use; the default 35052is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will 35053be returned exactly as parsed; otherwise, they will be passed through 35054@code{calc-normalize} first. 35055 35056To support the use of @kbd{$} characters in the algebraic entry, use 35057@code{let} to bind @code{calc-dollar-values} to a list of the values 35058to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind 35059@code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used} 35060will have been changed to the highest number of consecutive @kbd{$}s 35061that actually appeared in the input. 35062@end defun 35063 35064@defun format-number a 35065Convert the real or complex number or HMS form @var{a} to string form. 35066@end defun 35067 35068@defun format-flat-expr a prec 35069Convert the arbitrary Calc number or formula @var{a} to string form, 35070in the style used by the trail buffer and the @code{calc-edit} command. 35071This is a simple format designed 35072mostly to guarantee the string is of a form that can be re-parsed by 35073@code{read-expr}. Most formatting modes, such as digit grouping, 35074complex number format, and point character, are ignored to ensure the 35075result will be re-readable. The @var{prec} parameter is normally 0; if 35076you pass a large integer like 1000 instead, the expression will be 35077surrounded by parentheses unless it is a plain number or variable name. 35078@end defun 35079 35080@defun format-nice-expr a width 35081This is like @code{format-flat-expr} (with @var{prec} equal to 0), 35082except that newlines will be inserted to keep lines down to the 35083specified @var{width}, and vectors that look like matrices or rewrite 35084rules are written in a pseudo-matrix format. The @code{calc-edit} 35085command uses this when only one stack entry is being edited. 35086@end defun 35087 35088@defun format-value a width 35089Convert the Calc number or formula @var{a} to string form, using the 35090format seen in the stack buffer. Beware the string returned may 35091not be re-readable by @code{read-expr}, for example, because of digit 35092grouping. Multi-line objects like matrices produce strings that 35093contain newline characters to separate the lines. The @var{w} 35094parameter, if given, is the target window size for which to format 35095the expressions. If @var{w} is omitted, the width of the Calculator 35096window is used. 35097@end defun 35098 35099@defun compose-expr a prec 35100Format the Calc number or formula @var{a} according to the current 35101language mode, returning a ``composition.'' To learn about the 35102structure of compositions, see the comments in the Calc source code. 35103You can specify the format of a given type of function call by putting 35104a @code{math-compose-@var{lang}} property on the function's symbol, 35105whose value is a Lisp function that takes @var{a} and @var{prec} as 35106arguments and returns a composition. Here @var{lang} is a language 35107mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal}, 35108@code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}. 35109In Big mode, Calc actually tries @code{math-compose-big} first, then 35110tries @code{math-compose-normal}. If this property does not exist, 35111or if the function returns @code{nil}, the function is written in the 35112normal function-call notation for that language. 35113@end defun 35114 35115@defun composition-to-string c w 35116Convert a composition structure returned by @code{compose-expr} into 35117a string. Multi-line compositions convert to strings containing 35118newline characters. The target window size is given by @var{w}. 35119The @code{format-value} function basically calls @code{compose-expr} 35120followed by @code{composition-to-string}. 35121@end defun 35122 35123@defun comp-width c 35124Compute the width in characters of composition @var{c}. 35125@end defun 35126 35127@defun comp-height c 35128Compute the height in lines of composition @var{c}. 35129@end defun 35130 35131@defun comp-ascent c 35132Compute the portion of the height of composition @var{c} which is on or 35133above the baseline. For a one-line composition, this will be one. 35134@end defun 35135 35136@defun comp-descent c 35137Compute the portion of the height of composition @var{c} which is below 35138the baseline. For a one-line composition, this will be zero. 35139@end defun 35140 35141@defun comp-first-char c 35142If composition @var{c} is a ``flat'' composition, return the first 35143(leftmost) character of the composition as an integer. Otherwise, 35144return @code{nil}. 35145@end defun 35146 35147@defun comp-last-char c 35148If composition @var{c} is a ``flat'' composition, return the last 35149(rightmost) character, otherwise return @code{nil}. 35150@end defun 35151 35152@comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals 35153@comment @subsubsection Lisp Variables 35154@comment 35155@comment @noindent 35156@comment (This section is currently unfinished.) 35157 35158@node Hooks, , Formatting Lisp Functions, Internals 35159@subsubsection Hooks 35160 35161@noindent 35162Hooks are variables which contain Lisp functions (or lists of functions) 35163which are called at various times. Calc defines a number of hooks 35164that help you to customize it in various ways. Calc uses the Lisp 35165function @code{run-hooks} to invoke the hooks shown below. Several 35166other customization-related variables are also described here. 35167 35168@defvar calc-load-hook 35169This hook is called at the end of @file{calc.el}, after the file has 35170been loaded, before any functions in it have been called, but after 35171@code{calc-mode-map} and similar variables have been set up. 35172@end defvar 35173 35174@defvar calc-ext-load-hook 35175This hook is called at the end of @file{calc-ext.el}. 35176@end defvar 35177 35178@defvar calc-start-hook 35179This hook is called as the last step in a @kbd{M-x calc} command. 35180At this point, the Calc buffer has been created and initialized if 35181necessary, the Calc window and trail window have been created, 35182and the ``Welcome to Calc'' message has been displayed. 35183@end defvar 35184 35185@defvar calc-mode-hook 35186This hook is called when the Calc buffer is being created. Usually 35187this will only happen once per Emacs session. The hook is called 35188after Emacs has switched to the new buffer, the mode-settings file 35189has been read if necessary, and all other buffer-local variables 35190have been set up. After this hook returns, Calc will perform a 35191@code{calc-refresh} operation, set up the mode line display, then 35192evaluate any deferred @code{calc-define} properties that have not 35193been evaluated yet. 35194@end defvar 35195 35196@defvar calc-trail-mode-hook 35197This hook is called when the Calc Trail buffer is being created. 35198It is called as the very last step of setting up the Trail buffer. 35199Like @code{calc-mode-hook}, this will normally happen only once 35200per Emacs session. 35201@end defvar 35202 35203@defvar calc-end-hook 35204This hook is called by @code{calc-quit}, generally because the user 35205presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will 35206be the current buffer. The hook is called as the very first 35207step, before the Calc window is destroyed. 35208@end defvar 35209 35210@defvar calc-window-hook 35211If this hook is non-@code{nil}, it is called to create the Calc window. 35212Upon return, this new Calc window should be the current window. 35213(The Calc buffer will already be the current buffer when the 35214hook is called.) If the hook is not defined, Calc will 35215generally use @code{split-window}, @code{set-window-buffer}, 35216and @code{select-window} to create the Calc window. 35217@end defvar 35218 35219@defvar calc-trail-window-hook 35220If this hook is non-@code{nil}, it is called to create the Calc Trail 35221window. The variable @code{calc-trail-buffer} will contain the buffer 35222which the window should use. Unlike @code{calc-window-hook}, this hook 35223must @emph{not} switch into the new window. 35224@end defvar 35225 35226@defvar calc-embedded-mode-hook 35227This hook is called the first time that Embedded mode is entered. 35228@end defvar 35229 35230@defvar calc-embedded-new-buffer-hook 35231This hook is called each time that Embedded mode is entered in a 35232new buffer. 35233@end defvar 35234 35235@defvar calc-embedded-new-formula-hook 35236This hook is called each time that Embedded mode is enabled for a 35237new formula. 35238@end defvar 35239 35240@defvar calc-edit-mode-hook 35241This hook is called by @code{calc-edit} (and the other ``edit'' 35242commands) when the temporary editing buffer is being created. 35243The buffer will have been selected and set up to be in 35244@code{calc-edit-mode}, but will not yet have been filled with 35245text. (In fact it may still have leftover text from a previous 35246@code{calc-edit} command.) 35247@end defvar 35248 35249@defvar calc-mode-save-hook 35250This hook is called by the @code{calc-save-modes} command, 35251after Calc's own mode features have been inserted into the 35252Calc init file and just before the ``End of mode settings'' 35253message is inserted. 35254@end defvar 35255 35256@defvar calc-reset-hook 35257This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has 35258reset all modes. The Calc buffer will be the current buffer. 35259@end defvar 35260 35261@defvar calc-other-modes 35262This variable contains a list of strings. The strings are 35263concatenated at the end of the modes portion of the Calc 35264mode line (after standard modes such as ``Deg'', ``Inv'' and 35265``Hyp''). Each string should be a short, single word followed 35266by a space. The variable is @code{nil} by default. 35267@end defvar 35268 35269@defvar calc-mode-map 35270This is the keymap that is used by Calc mode. The best time 35271to adjust it is probably in a @code{calc-mode-hook}. If the 35272Calc extensions package (@file{calc-ext.el}) has not yet been 35273loaded, many of these keys will be bound to @code{calc-missing-key}, 35274which is a command that loads the extensions package and 35275``retypes'' the key. If your @code{calc-mode-hook} rebinds 35276one of these keys, it will probably be overridden when the 35277extensions are loaded. 35278@end defvar 35279 35280@defvar calc-digit-map 35281This is the keymap that is used during numeric entry. Numeric 35282entry uses the minibuffer, but this map binds every non-numeric 35283key to @code{calcDigit-nondigit} which generally calls 35284@code{exit-minibuffer} and ``retypes'' the key. 35285@end defvar 35286 35287@defvar calc-alg-ent-map 35288This is the keymap that is used during algebraic entry. This is 35289mostly a copy of @code{minibuffer-local-map}. 35290@end defvar 35291 35292@defvar calc-store-var-map 35293This is the keymap that is used during entry of variable names for 35294commands like @code{calc-store} and @code{calc-recall}. This is 35295mostly a copy of @code{minibuffer-local-completion-map}. 35296@end defvar 35297 35298@defvar calc-edit-mode-map 35299This is the (sparse) keymap used by @code{calc-edit} and other 35300temporary editing commands. It binds @key{RET}, @key{LFD}, 35301and @kbd{C-c C-c} to @code{calc-edit-finish}. 35302@end defvar 35303 35304@defvar calc-mode-var-list 35305This is a list of variables which are saved by @code{calc-save-modes}. 35306Each entry is a list of two items, the variable (as a Lisp symbol) 35307and its default value. When modes are being saved, each variable 35308is compared with its default value (using @code{equal}) and any 35309non-default variables are written out. 35310@end defvar 35311 35312@defvar calc-local-var-list 35313This is a list of variables which should be buffer-local to the 35314Calc buffer. Each entry is a variable name (as a Lisp symbol). 35315These variables also have their default values manipulated by 35316the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}. 35317Since @code{calc-mode-hook} is called after this list has been 35318used the first time, your hook should add a variable to the 35319list and also call @code{make-local-variable} itself. 35320@end defvar 35321 35322@node Copying, GNU Free Documentation License, Programming, Top 35323@appendix GNU GENERAL PUBLIC LICENSE 35324@include gpl.texi 35325 35326@node GNU Free Documentation License, Customizing Calc, Copying, Top 35327@appendix GNU Free Documentation License 35328@include doclicense.texi 35329 35330@node Customizing Calc, Reporting Bugs, GNU Free Documentation License, Top 35331@appendix Customizing Calc 35332 35333The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish 35334to use a different prefix, you can put 35335 35336@example 35337(global-set-key "NEWPREFIX" 'calc-dispatch) 35338@end example 35339 35340@noindent 35341in your .emacs file. 35342(@xref{Key Bindings,,Customizing Key Bindings,emacs, 35343The GNU Emacs Manual}, for more information on binding keys.) 35344A convenient way to start Calc is with @kbd{C-x * *}; to make it equally 35345convenient for users who use a different prefix, the prefix can be 35346followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or 35347@kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last 35348character of the prefix can simply be typed twice. 35349 35350Calc is controlled by many variables, most of which can be reset from 35351within Calc. Some variables are less involved with actual calculation 35352and can be set outside of Calc using Emacs's customization facilities. 35353These variables are listed below. Typing @kbd{M-x customize-variable 35354@key{RET} @var{variable-name} @key{RET}} will bring up a buffer in 35355which the variable's value can be redefined. Typing @kbd{M-x 35356customize-group @key{RET} calc @key{RET}} will bring up a buffer which 35357contains all of Calc's customizable variables. (These variables can 35358also be reset by putting the appropriate lines in your .emacs file; 35359@xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.) 35360 35361Some of the customizable variables are regular expressions. A regular 35362expression is basically a pattern that Calc can search for. 35363See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual} 35364to see how regular expressions work. 35365 35366@defvar calc-settings-file 35367The variable @code{calc-settings-file} holds the file name in 35368which commands like @kbd{m m} and @kbd{Z P} store ``permanent'' 35369definitions. 35370If @code{calc-settings-file} is not your user init file (typically 35371@file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is 35372@code{nil}, then Calc will automatically load your settings file (if it 35373exists) the first time Calc is invoked. 35374 35375The default value for this variable is @code{"~/.emacs.d/calc.el"} 35376unless the file @file{~/.calc.el} exists, in which case the default 35377value will be @code{"~/.calc.el"}. 35378@end defvar 35379 35380@defvar calc-gnuplot-name 35381See @ref{Graphics}.@* 35382The variable @code{calc-gnuplot-name} should be the name of the 35383GNUPLOT program (a string). If you have GNUPLOT installed on your 35384system but Calc is unable to find it, you may need to set this 35385variable. You may also need to set some Lisp variables to show Calc how 35386to run GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} . 35387The default value of @code{calc-gnuplot-name} is @code{"gnuplot"}. 35388@end defvar 35389 35390@defvar calc-gnuplot-plot-command 35391@defvarx calc-gnuplot-print-command 35392See @ref{Devices, ,Graphical Devices}.@* 35393The variables @code{calc-gnuplot-plot-command} and 35394@code{calc-gnuplot-print-command} represent system commands to 35395display and print the output of GNUPLOT, respectively. These may be 35396@code{nil} if no command is necessary, or strings which can include 35397@samp{%s} to signify the name of the file to be displayed or printed. 35398Or, these variables may contain Lisp expressions which are evaluated 35399to display or print the output. 35400 35401The default value of @code{calc-gnuplot-plot-command} is @code{nil}, 35402and the default value of @code{calc-gnuplot-print-command} is 35403@code{"lp %s"}. 35404@end defvar 35405 35406@defvar calc-language-alist 35407See @ref{Basic Embedded Mode}.@* 35408The variable @code{calc-language-alist} controls the languages that 35409Calc will associate with major modes. When Calc embedded mode is 35410enabled, it will try to use the current major mode to 35411determine what language should be used. (This can be overridden using 35412Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.) 35413The variable @code{calc-language-alist} consists of a list of pairs of 35414the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example, 35415@code{(latex-mode . latex)} is one such pair. If Calc embedded is 35416activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself 35417to use the language @var{LANGUAGE}. 35418 35419The default value of @code{calc-language-alist} is 35420@example 35421 ((latex-mode . latex) 35422 (tex-mode . tex) 35423 (plain-tex-mode . tex) 35424 (context-mode . tex) 35425 (nroff-mode . eqn) 35426 (pascal-mode . pascal) 35427 (c-mode . c) 35428 (c++-mode . c) 35429 (fortran-mode . fortran) 35430 (f90-mode . fortran)) 35431@end example 35432@end defvar 35433 35434@defvar calc-embedded-announce-formula 35435@defvarx calc-embedded-announce-formula-alist 35436See @ref{Customizing Embedded Mode}.@* 35437The variable @code{calc-embedded-announce-formula} helps determine 35438what formulas @kbd{C-x * a} will activate in a buffer. It is a 35439regular expression, and when activating embedded formulas with 35440@kbd{C-x * a}, it will tell Calc that what follows is a formula to be 35441activated. (Calc also uses other patterns to find formulas, such as 35442@samp{=>} and @samp{:=}.) 35443 35444The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks 35445for @samp{%Embed} followed by any number of lines beginning with 35446@samp{%} and a space. 35447 35448The variable @code{calc-embedded-announce-formula-alist} is used to 35449set @code{calc-embedded-announce-formula} to different regular 35450expressions depending on the major mode of the editing buffer. 35451It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} . 35452@var{REGEXP})}, and its default value is 35453@example 35454 ((c++-mode . "//Embed\n\\(// .*\n\\)*") 35455 (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*") 35456 (f90-mode . "!Embed\n\\(! .*\n\\)*") 35457 (fortran-mode . "C Embed\n\\(C .*\n\\)*") 35458 (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") 35459 (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") 35460 (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*") 35461 (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*") 35462 (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") 35463 (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") 35464 (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*")) 35465@end example 35466Any major modes added to @code{calc-embedded-announce-formula-alist} 35467should also be added to @code{calc-embedded-open-close-plain-alist} 35468and @code{calc-embedded-open-close-mode-alist}. 35469@end defvar 35470 35471@defvar calc-embedded-open-formula 35472@defvarx calc-embedded-close-formula 35473@defvarx calc-embedded-open-close-formula-alist 35474See @ref{Customizing Embedded Mode}.@* 35475The variables @code{calc-embedded-open-formula} and 35476@code{calc-embedded-close-formula} control the region that Calc will 35477activate as a formula when Embedded mode is entered with @kbd{C-x * e}. 35478They are regular expressions; 35479Calc normally scans backward and forward in the buffer for the 35480nearest text matching these regular expressions to be the ``formula 35481delimiters''. 35482 35483The simplest delimiters are blank lines. Other delimiters that 35484Embedded mode understands by default are: 35485@enumerate 35486@item 35487The @TeX{} and @LaTeX{} math delimiters @samp{$ $}, @samp{$$ $$}, 35488@samp{\[ \]}, and @samp{\( \)}; 35489@item 35490Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters); 35491@item 35492Lines beginning with @samp{@@} (Texinfo delimiters). 35493@item 35494Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters); 35495@item 35496Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else. 35497@end enumerate 35498 35499The variable @code{calc-embedded-open-close-formula-alist} is used to 35500set @code{calc-embedded-open-formula} and 35501@code{calc-embedded-close-formula} to different regular 35502expressions depending on the major mode of the editing buffer. 35503It consists of a list of lists of the form 35504@code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP} 35505@var{CLOSE-FORMULA-REGEXP})}, and its default value is 35506@code{nil}. 35507@end defvar 35508 35509@defvar calc-embedded-word-regexp 35510@defvarx calc-embedded-word-regexp-alist 35511See @ref{Customizing Embedded Mode}.@* 35512The variable @code{calc-embedded-word-regexp} determines the expression 35513that Calc will activate when Embedded mode is entered with @kbd{C-x * 35514w}. It is a regular expressions. 35515 35516The default value of @code{calc-embedded-word-regexp} is 35517@code{"[-+]?[0-9]+\\(\\.[0-9]+\\)?\\([eE][-+]?[0-9]+\\)?"}. 35518 35519The variable @code{calc-embedded-word-regexp-alist} is used to 35520set @code{calc-embedded-word-regexp} to a different regular 35521expression depending on the major mode of the editing buffer. 35522It consists of a list of lists of the form 35523@code{(@var{MAJOR-MODE} @var{WORD-REGEXP})}, and its default value is 35524@code{nil}. 35525@end defvar 35526 35527@defvar calc-embedded-open-plain 35528@defvarx calc-embedded-close-plain 35529@defvarx calc-embedded-open-close-plain-alist 35530See @ref{Customizing Embedded Mode}.@* 35531The variables @code{calc-embedded-open-plain} and 35532@code{calc-embedded-open-plain} are used to delimit ``plain'' 35533formulas. Note that these are actual strings, not regular 35534expressions, because Calc must be able to write these string into a 35535buffer as well as to recognize them. 35536 35537The default string for @code{calc-embedded-open-plain} is 35538@code{"%%% "}, note the trailing space. The default string for 35539@code{calc-embedded-close-plain} is @code{" %%%\n"}, without 35540the trailing newline here, the first line of a Big mode formula 35541that followed might be shifted over with respect to the other lines. 35542 35543The variable @code{calc-embedded-open-close-plain-alist} is used to 35544set @code{calc-embedded-open-plain} and 35545@code{calc-embedded-close-plain} to different strings 35546depending on the major mode of the editing buffer. 35547It consists of a list of lists of the form 35548@code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING} 35549@var{CLOSE-PLAIN-STRING})}, and its default value is 35550@example 35551 ((c++-mode "// %% " " %%\n") 35552 (c-mode "/* %% " " %% */\n") 35553 (f90-mode "! %% " " %%\n") 35554 (fortran-mode "C %% " " %%\n") 35555 (html-helper-mode "<!-- %% " " %% -->\n") 35556 (html-mode "<!-- %% " " %% -->\n") 35557 (nroff-mode "\\\" %% " " %%\n") 35558 (pascal-mode "@{%% " " %%@}\n") 35559 (sgml-mode "<!-- %% " " %% -->\n") 35560 (xml-mode "<!-- %% " " %% -->\n") 35561 (texinfo-mode "@@c %% " " %%\n")) 35562@end example 35563Any major modes added to @code{calc-embedded-open-close-plain-alist} 35564should also be added to @code{calc-embedded-announce-formula-alist} 35565and @code{calc-embedded-open-close-mode-alist}. 35566@end defvar 35567 35568@defvar calc-embedded-open-new-formula 35569@defvarx calc-embedded-close-new-formula 35570@defvarx calc-embedded-open-close-new-formula-alist 35571See @ref{Customizing Embedded Mode}.@* 35572The variables @code{calc-embedded-open-new-formula} and 35573@code{calc-embedded-close-new-formula} are strings which are 35574inserted before and after a new formula when you type @kbd{C-x * f}. 35575 35576The default value of @code{calc-embedded-open-new-formula} is 35577@code{"\n\n"}. If this string begins with a newline character and the 35578@kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip 35579this first newline to avoid introducing unnecessary blank lines in the 35580file. The default value of @code{calc-embedded-close-new-formula} is 35581also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}} 35582if typed at the end of a line. (It follows that if @kbd{C-x * f} is 35583typed on a blank line, both a leading opening newline and a trailing 35584closing newline are omitted.) 35585 35586The variable @code{calc-embedded-open-close-new-formula-alist} is used to 35587set @code{calc-embedded-open-new-formula} and 35588@code{calc-embedded-close-new-formula} to different strings 35589depending on the major mode of the editing buffer. 35590It consists of a list of lists of the form 35591@code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING} 35592@var{CLOSE-NEW-FORMULA-STRING})}, and its default value is 35593@code{nil}. 35594@end defvar 35595 35596@defvar calc-embedded-open-mode 35597@defvarx calc-embedded-close-mode 35598@defvarx calc-embedded-open-close-mode-alist 35599See @ref{Customizing Embedded Mode}.@* 35600The variables @code{calc-embedded-open-mode} and 35601@code{calc-embedded-close-mode} are strings which Calc will place before 35602and after any mode annotations that it inserts. Calc never scans for 35603these strings; Calc always looks for the annotation itself, so it is not 35604necessary to add them to user-written annotations. 35605 35606The default value of @code{calc-embedded-open-mode} is @code{"% "} 35607and the default value of @code{calc-embedded-close-mode} is 35608@code{"\n"}. 35609If you change the value of @code{calc-embedded-close-mode}, it is a good 35610idea still to end with a newline so that mode annotations will appear on 35611lines by themselves. 35612 35613The variable @code{calc-embedded-open-close-mode-alist} is used to 35614set @code{calc-embedded-open-mode} and 35615@code{calc-embedded-close-mode} to different strings 35616expressions depending on the major mode of the editing buffer. 35617It consists of a list of lists of the form 35618@code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING} 35619@var{CLOSE-MODE-STRING})}, and its default value is 35620@example 35621 ((c++-mode "// " "\n") 35622 (c-mode "/* " " */\n") 35623 (f90-mode "! " "\n") 35624 (fortran-mode "C " "\n") 35625 (html-helper-mode "<!-- " " -->\n") 35626 (html-mode "<!-- " " -->\n") 35627 (nroff-mode "\\\" " "\n") 35628 (pascal-mode "@{ " " @}\n") 35629 (sgml-mode "<!-- " " -->\n") 35630 (xml-mode "<!-- " " -->\n") 35631 (texinfo-mode "@@c " "\n")) 35632@end example 35633Any major modes added to @code{calc-embedded-open-close-mode-alist} 35634should also be added to @code{calc-embedded-announce-formula-alist} 35635and @code{calc-embedded-open-close-plain-alist}. 35636@end defvar 35637 35638@defvar calc-lu-power-reference 35639@defvarx calc-lu-field-reference 35640See @ref{Logarithmic Units}.@* 35641The variables @code{calc-lu-power-reference} and 35642@code{calc-lu-field-reference} are unit expressions (written as 35643strings) which Calc will use as reference quantities for logarithmic 35644units. 35645 35646The default value of @code{calc-lu-power-reference} is @code{"mW"} 35647and the default value of @code{calc-lu-field-reference} is 35648@code{"20 uPa"}. 35649@end defvar 35650 35651@defvar calc-note-threshold 35652See @ref{Musical Notes}.@* 35653The variable @code{calc-note-threshold} is a number (written as a 35654string) which determines how close (in cents) a frequency needs to be 35655to a note to be recognized as that note. 35656 35657The default value of @code{calc-note-threshold} is 1. 35658@end defvar 35659 35660@defvar calc-highlight-selections-with-faces 35661@defvarx calc-selected-face 35662@defvarx calc-nonselected-face 35663See @ref{Displaying Selections}.@* 35664The variable @code{calc-highlight-selections-with-faces} 35665determines how selected sub-formulas are distinguished. 35666If @code{calc-highlight-selections-with-faces} is nil, then 35667a selected sub-formula is distinguished either by changing every 35668character not part of the sub-formula with a dot or by changing every 35669character in the sub-formula with a @samp{#} sign. 35670If @code{calc-highlight-selections-with-faces} is t, 35671then a selected sub-formula is distinguished either by displaying the 35672non-selected portion of the formula with @code{calc-nonselected-face} 35673or by displaying the selected sub-formula with 35674@code{calc-nonselected-face}. 35675@end defvar 35676 35677@defvar calc-multiplication-has-precedence 35678The variable @code{calc-multiplication-has-precedence} determines 35679whether multiplication has precedence over division in algebraic 35680formulas in normal language modes. If 35681@code{calc-multiplication-has-precedence} is non-@code{nil}, then 35682multiplication has precedence (and, for certain obscure reasons, is 35683right associative), and so for example @samp{a/b*c} will be interpreted 35684as @samp{a/(b*c)}. If @code{calc-multiplication-has-precedence} is 35685@code{nil}, then multiplication has the same precedence as division 35686(and, like division, is left associative), and so for example 35687@samp{a/b*c} will be interpreted as @samp{(a/b)*c}. The default value 35688of @code{calc-multiplication-has-precedence} is @code{t}. 35689@end defvar 35690 35691@defvar calc-context-sensitive-enter 35692The commands @code{calc-enter} and @code{calc-pop} will typically 35693duplicate the top of the stack. If 35694@code{calc-context-sensitive-enter} is non-@code{nil}, then the 35695@code{calc-enter} will copy the element at the cursor to the 35696top of the stack and @code{calc-pop} will delete the element at the 35697cursor. The default value of @code{calc-context-sensitive-enter} is 35698@code{nil}. 35699@end defvar 35700 35701@defvar calc-undo-length 35702The variable @code{calc-undo-length} determines the number of undo 35703steps that Calc will keep track of when @code{calc-quit} is called. 35704If @code{calc-undo-length} is a non-negative integer, then this is the 35705number of undo steps that will be preserved; if 35706@code{calc-undo-length} has any other value, then all undo steps will 35707be preserved. The default value of @code{calc-undo-length} is @expr{100}. 35708@end defvar 35709 35710@defvar calc-gregorian-switch 35711See @ref{Date Forms}.@* 35712The variable @code{calc-gregorian-switch} is either a list of integers 35713@code{(@var{YEAR} @var{MONTH} @var{DAY})} or @code{nil}. 35714If it is @code{nil}, then Calc's date forms always represent Gregorian dates. 35715Otherwise, @code{calc-gregorian-switch} represents the date that the 35716calendar switches from Julian dates to Gregorian dates; 35717@code{(@var{YEAR} @var{MONTH} @var{DAY})} will be the first Gregorian 35718date. The customization buffer will offer several standard dates to 35719choose from, or the user can enter their own date. 35720 35721The default value of @code{calc-gregorian-switch} is @code{nil}. 35722@end defvar 35723 35724@node Reporting Bugs, Summary, Customizing Calc, Top 35725@appendix Reporting Bugs 35726 35727@noindent 35728If you find a bug in Calc, send e-mail to @email{bug-gnu-emacs@@gnu.org}. 35729There is an automatic command @kbd{M-x report-emacs-bug} which helps 35730you to report bugs. This command prompts you for a brief subject 35731line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to 35732send your mail. Make sure your subject line indicates that you are 35733reporting a Calc bug. 35734 35735If you have suggestions for additional features for Calc, please send 35736them. Some have dared to suggest that Calc is already top-heavy with 35737features; this obviously cannot be the case, so if you have ideas, send 35738them right in. 35739 35740At the front of the source file, @file{calc.el}, is a list of ideas for 35741future work. If any enthusiastic souls wish to take it upon themselves 35742to work on these, please send a message (using @kbd{M-x report-emacs-bug}) 35743so any efforts can be coordinated. 35744 35745The latest version of Calc is available from Savannah, in the Emacs 35746repository. See @uref{https://savannah.gnu.org/projects/emacs}. 35747 35748@c [summary] 35749@node Summary, Key Index, Reporting Bugs, Top 35750@appendix Calc Summary 35751 35752@noindent 35753This section includes a complete list of Calc keystroke commands. 35754Each line lists the stack entries used by the command (top-of-stack 35755last), the keystrokes themselves, the prompts asked by the command, 35756and the result of the command (also with top-of-stack last). 35757The result is expressed using the equivalent algebraic function. 35758Commands which put no results on the stack show the full @kbd{M-x} 35759command name in that position. Numbers preceding the result or 35760command name refer to notes at the end. 35761 35762Algebraic functions and @kbd{M-x} commands that don't have corresponding 35763keystrokes are not listed in this summary. 35764@xref{Command Index}. @xref{Function Index}. 35765 35766@iftex 35767@begingroup 35768@tex 35769\vskip-2\baselineskip \null 35770\gdef\sumrow#1{\sumrowx#1\relax}% 35771\gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{% 35772\leavevmode% 35773{\smallfonts 35774\hbox to5em{\sl\hss#1}% 35775\hbox to5em{\tt#2\hss}% 35776\hbox to4em{\sl#3\hss}% 35777\hbox to5em{\rm\hss#4}% 35778\thinspace% 35779{\tt#5}% 35780{\sl#6}% 35781}}% 35782\gdef\sumlpar{{\rm(}}% 35783\gdef\sumrpar{{\rm)}}% 35784\gdef\sumcomma{{\rm,\thinspace}}% 35785\gdef\sumexcl{{\rm!}}% 35786\gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}% 35787\gdef\minus#1{{\tt-}}% 35788@end tex 35789@let@:=@sumsep 35790@let@r=@sumrow 35791@catcode`@(=@active @let(=@sumlpar 35792@catcode`@)=@active @let)=@sumrpar 35793@catcode`@,=@active @let,=@sumcomma 35794@catcode`@!=@active @let!=@sumexcl 35795@end iftex 35796@format 35797@iftex 35798@advance@baselineskip-2.5pt 35799@let@c@sumbreak 35800@end iftex 35801@r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:} 35802@r{ @: C-x * b @: @: @:calc-big-or-small@:} 35803@r{ @: C-x * c @: @: @:calc@:} 35804@r{ @: C-x * d @: @: @:calc-embedded-duplicate@:} 35805@r{ @: C-x * e @: @: 34 @:calc-embedded@:} 35806@r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:} 35807@r{ @: C-x * g @: @: 35 @:calc-grab-region@:} 35808@r{ @: C-x * i @: @: @:calc-info@:} 35809@r{ @: C-x * j @: @: @:calc-embedded-select@:} 35810@r{ @: C-x * k @: @: @:calc-keypad@:} 35811@r{ @: C-x * l @: @: @:calc-load-everything@:} 35812@r{ @: C-x * m @: @: @:read-kbd-macro@:} 35813@r{ @: C-x * n @: @: 4 @:calc-embedded-next@:} 35814@r{ @: C-x * o @: @: @:calc-other-window@:} 35815@r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:} 35816@r{ @: C-x * q @:formula @: @:quick-calc@:} 35817@r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:} 35818@r{ @: C-x * s @: @: @:calc-info-summary@:} 35819@r{ @: C-x * t @: @: @:calc-tutorial@:} 35820@r{ @: C-x * u @: @: @:calc-embedded-update-formula@:} 35821@r{ @: C-x * w @: @: @:calc-embedded-word@:} 35822@r{ @: C-x * x @: @: @:calc-quit@:} 35823@r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:} 35824@r{ @: C-x * z @: @: @:calc-user-invocation@:} 35825@r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:} 35826@r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:} 35827@r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:} 35828@r{ @: C-x * 0 @:(zero) @: @:calc-reset@:} 35829 35830@c 35831@r{ @: 0-9 @:number @: @:@:number} 35832@r{ @: . @:number @: @:@:0.number} 35833@r{ @: _ @:number @: @:-@:number} 35834@r{ @: e @:number @: @:@:1e number} 35835@r{ @: # @:number @: @:@:current-radix@tfn{#}number} 35836@r{ @: p @:(in number) @: @:+/-@:} 35837@r{ @: M @:(in number) @: @:mod@:} 35838@r{ @: @@ ' " @: (in number)@: @:@:HMS form} 35839@r{ @: h m s @: (in number)@: @:@:HMS form} 35840 35841@c 35842@r{ @: ' @:formula @: 37,46 @:@:formula} 35843@r{ @: $ @:formula @: 37,46 @:$@:formula} 35844@r{ @: " @:string @: 37,46 @:@:string} 35845 35846@c 35847@r{ a b@: + @: @: 2 @:add@:(a,b) a+b} 35848@r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b} 35849@r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b} 35850@r{ a b@: / @: @: 2 @:div@:(a,b) a/b} 35851@r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b} 35852@r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)} 35853@r{ a b@: % @: @: 2 @:mod@:(a,b) a%b} 35854@r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b} 35855@r{ a b@: : @: @: 2 @:fdiv@:(a,b)} 35856@r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b} 35857@r{ a b@: I | @: @: @:vconcat@:(b,a) b|a} 35858@r{ a b@: H | @: @: 2 @:append@:(a,b)} 35859@r{ a b@: I H | @: @: @:append@:(b,a)} 35860@r{ a@: & @: @: 1 @:inv@:(a) 1/a} 35861@r{ a@: ! @: @: 1 @:fact@:(a) a!} 35862@r{ a@: = @: @: 1 @:evalv@:(a)} 35863@r{ a@: M-% @: @: @:percent@:(a) a%} 35864 35865@c 35866@r{ ... a@: @summarykey{RET} @: @: 1 @:@:... a a} 35867@r{ ... a@: @summarykey{SPC} @: @: 1 @:@:... a a} 35868@r{... a b@: @summarykey{TAB} @: @: 3 @:@:... b a} 35869@r{. a b c@: M-@summarykey{TAB} @: @: 3 @:@:... b c a} 35870@r{... a b@: @summarykey{LFD} @: @: 1 @:@:... a b a} 35871@r{ ... a@: @summarykey{DEL} @: @: 1 @:@:...} 35872@r{... a b@: M-@summarykey{DEL} @: @: 1 @:@:... b} 35873@r{ @: M-@summarykey{RET} @: @: 4 @:calc-last-args@:} 35874@r{ a@: ` @:editing @: 1,30 @:calc-edit@:} 35875 35876@c 35877@r{ ... a@: C-d @: @: 1 @:@:...} 35878@r{ @: C-k @: @: 27 @:calc-kill@:} 35879@r{ @: C-w @: @: 27 @:calc-kill-region@:} 35880@r{ @: C-y @: @: @:calc-yank@:} 35881@r{ @: C-_ @: @: 4 @:calc-undo@:} 35882@r{ @: M-k @: @: 27 @:calc-copy-as-kill@:} 35883@r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:} 35884 35885@c 35886@r{ @: [ @: @: @:@:[...} 35887@r{[.. a b@: ] @: @: @:@:[a,b]} 35888@r{ @: ( @: @: @:@:(...} 35889@r{(.. a b@: ) @: @: @:@:(a,b)} 35890@r{ @: , @: @: @:@:vector or rect complex} 35891@r{ @: ; @: @: @:@:matrix or polar complex} 35892@r{ @: .. @: @: @:@:interval} 35893 35894@c 35895@r{ @: ~ @: @: @:calc-num-prefix@:} 35896@r{ @: < @: @: 4 @:calc-scroll-left@:} 35897@r{ @: > @: @: 4 @:calc-scroll-right@:} 35898@r{ @: @{ @: @: 4 @:calc-scroll-down@:} 35899@r{ @: @} @: @: 4 @:calc-scroll-up@:} 35900@r{ @: ? @: @: @:calc-help@:} 35901 35902@c 35903@r{ a@: n @: @: 1 @:neg@:(a) @minus{}a} 35904@r{ @: o @: @: 4 @:calc-realign@:} 35905@r{ @: p @:precision @: 31 @:calc-precision@:} 35906@r{ @: q @: @: @:calc-quit@:} 35907@r{ @: w @: @: @:calc-why@:} 35908@r{ @: x @:command @: @:M-x calc-@:command} 35909@r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:} 35910 35911@c 35912@r{ a@: A @: @: 1 @:abs@:(a)} 35913@r{ a b@: B @: @: 2 @:log@:(a,b)} 35914@r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a} 35915@r{ a@: C @: @: 1 @:cos@:(a)} 35916@r{ a@: I C @: @: 1 @:arccos@:(a)} 35917@r{ a@: H C @: @: 1 @:cosh@:(a)} 35918@r{ a@: I H C @: @: 1 @:arccosh@:(a)} 35919@r{ @: D @: @: 4 @:calc-redo@:} 35920@r{ a@: E @: @: 1 @:exp@:(a)} 35921@r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a} 35922@r{ a@: F @: @: 1,11 @:floor@:(a,d)} 35923@r{ a@: I F @: @: 1,11 @:ceil@:(a,d)} 35924@r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)} 35925@r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)} 35926@r{ a@: G @: @: 1 @:arg@:(a)} 35927@r{ @: H @:command @: 32 @:@:Hyperbolic} 35928@r{ @: I @:command @: 32 @:@:Inverse} 35929@r{ a@: J @: @: 1 @:conj@:(a)} 35930@r{ @: K @:command @: 32 @:@:Keep-args} 35931@r{ a@: L @: @: 1 @:ln@:(a)} 35932@r{ a@: H L @: @: 1 @:log10@:(a)} 35933@r{ @: M @: @: @:calc-more-recursion-depth@:} 35934@r{ @: I M @: @: @:calc-less-recursion-depth@:} 35935@r{ a@: N @: @: 5 @:evalvn@:(a)} 35936@r{ @: O @:command @: 32 @:@:Option} 35937@r{ @: P @: @: @:@:pi} 35938@r{ @: I P @: @: @:@:gamma} 35939@r{ @: H P @: @: @:@:e} 35940@r{ @: I H P @: @: @:@:phi} 35941@r{ a@: Q @: @: 1 @:sqrt@:(a)} 35942@r{ a@: I Q @: @: 1 @:sqr@:(a) a^2} 35943@r{ a@: R @: @: 1,11 @:round@:(a,d)} 35944@r{ a@: I R @: @: 1,11 @:trunc@:(a,d)} 35945@r{ a@: H R @: @: 1,11 @:fround@:(a,d)} 35946@r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)} 35947@r{ a@: S @: @: 1 @:sin@:(a)} 35948@r{ a@: I S @: @: 1 @:arcsin@:(a)} 35949@r{ a@: H S @: @: 1 @:sinh@:(a)} 35950@r{ a@: I H S @: @: 1 @:arcsinh@:(a)} 35951@r{ a@: T @: @: 1 @:tan@:(a)} 35952@r{ a@: I T @: @: 1 @:arctan@:(a)} 35953@r{ a@: H T @: @: 1 @:tanh@:(a)} 35954@r{ a@: I H T @: @: 1 @:arctanh@:(a)} 35955@r{ @: U @: @: 4 @:calc-undo@:} 35956@r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:} 35957 35958@c 35959@r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b} 35960@r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b} 35961@r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b} 35962@r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b} 35963@r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b} 35964@r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b} 35965@r{ a b@: a @{ @: @: 2 @:in@:(a,b)} 35966@r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b} 35967@r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b} 35968@r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a} 35969@r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c} 35970@r{ a@: a . @: @: 1 @:rmeq@:(a)} 35971@r{ a@: a " @: @: 7,8 @:calc-expand-formula@:} 35972 35973@c 35974@r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)} 35975@r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)} 35976@r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)} 35977@r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b} 35978 35979@c 35980@r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)} 35981@r{ a b@: a % @: @: 2 @:prem@:(a,b)} 35982@r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]} 35983@r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b} 35984 35985@c 35986@r{ a@: a a @: @: 1 @:apart@:(a)} 35987@r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)} 35988@r{ a@: a c @:v @: 38 @:collect@:(a,v)} 35989@r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)} 35990@r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)} 35991@r{ a@: a e @: @: @:esimplify@:(a)} 35992@r{ a@: a f @: @: 1 @:factor@:(a)} 35993@r{ a@: H a f @: @: 1 @:factors@:(a)} 35994@r{ a b@: a g @: @: 2 @:pgcd@:(a,b)} 35995@r{ a@: a i @:v @: 38 @:integ@:(a,v)} 35996@r{ a@: a m @:pats @: 38 @:match@:(a,pats)} 35997@r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)} 35998@r{ data x@: a p @: @: 28 @:polint@:(data,x)} 35999@r{ data x@: H a p @: @: 28 @:ratint@:(data,x)} 36000@r{ a@: a n @: @: 1 @:nrat@:(a)} 36001@r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)} 36002@r{ a@: a s @: @: @:simplify@:(a)} 36003@r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)} 36004@r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:} 36005@r{ a@: a x @: @: 4,8 @:expand@:(a)} 36006 36007@c 36008@r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)} 36009@r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)} 36010@r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)} 36011@r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)} 36012@r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)} 36013@r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)} 36014@r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)} 36015@r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)} 36016@r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)} 36017@r{ a@: a P @:v @: 38 @:roots@:(a,v)} 36018@r{ a g@: a R @:v @: 38 @:root@:(a,v,g)} 36019@r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)} 36020@r{ a@: a S @:v @: 38 @:solve@:(a,v)} 36021@r{ a@: I a S @:v @: 38 @:finv@:(a,v)} 36022@r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)} 36023@r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)} 36024@r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)} 36025@r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)} 36026@r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)} 36027 36028@c 36029@r{ a b@: b a @: @: 9 @:and@:(a,b,w)} 36030@r{ a@: b c @: @: 9 @:clip@:(a,w)} 36031@r{ a b@: b d @: @: 9 @:diff@:(a,b,w)} 36032@r{ a@: b l @: @: 10 @:lsh@:(a,n,w)} 36033@r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)} 36034@r{ a@: b n @: @: 9 @:not@:(a,w)} 36035@r{ a b@: b o @: @: 9 @:or@:(a,b,w)} 36036@r{ v@: b p @: @: 1 @:vpack@:(v)} 36037@r{ a@: b r @: @: 10 @:rsh@:(a,n,w)} 36038@r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)} 36039@r{ a@: b t @: @: 10 @:rot@:(a,n,w)} 36040@r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)} 36041@r{ a@: b u @: @: 1 @:vunpack@:(a)} 36042@r{ @: b w @:w @: 9,50 @:calc-word-size@:} 36043@r{ a b@: b x @: @: 9 @:xor@:(a,b,w)} 36044 36045@c 36046@r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)} 36047@r{ r n p@: b F @: @: @:fv@:(r,n,p)} 36048@r{ r n p@: I b F @: @: @:fvb@:(r,n,p)} 36049@r{ r n p@: H b F @: @: @:fvl@:(r,n,p)} 36050@r{ v@: b I @: @: 19 @:irr@:(v)} 36051@r{ v@: I b I @: @: 19 @:irrb@:(v)} 36052@r{ a@: b L @: @: 10 @:ash@:(a,n,w)} 36053@r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)} 36054@r{ r n a@: b M @: @: @:pmt@:(r,n,a)} 36055@r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)} 36056@r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)} 36057@r{ r v@: b N @: @: 19 @:npv@:(r,v)} 36058@r{ r v@: I b N @: @: 19 @:npvb@:(r,v)} 36059@r{ r n p@: b P @: @: @:pv@:(r,n,p)} 36060@r{ r n p@: I b P @: @: @:pvb@:(r,n,p)} 36061@r{ r n p@: H b P @: @: @:pvl@:(r,n,p)} 36062@r{ a@: b R @: @: 10 @:rash@:(a,n,w)} 36063@r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)} 36064@r{ c s l@: b S @: @: @:sln@:(c,s,l)} 36065@r{ n p a@: b T @: @: @:rate@:(n,p,a)} 36066@r{ n p a@: I b T @: @: @:rateb@:(n,p,a)} 36067@r{ n p a@: H b T @: @: @:ratel@:(n,p,a)} 36068@r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)} 36069 36070@r{ r p a@: b # @: @: @:nper@:(r,p,a)} 36071@r{ r p a@: I b # @: @: @:nperb@:(r,p,a)} 36072@r{ r p a@: H b # @: @: @:nperl@:(r,p,a)} 36073@r{ a b@: b % @: @: @:relch@:(a,b)} 36074 36075@c 36076@r{ a@: c c @: @: 5 @:pclean@:(a,p)} 36077@r{ a@: c 0-9 @: @: @:pclean@:(a,p)} 36078@r{ a@: H c c @: @: 5 @:clean@:(a,p)} 36079@r{ a@: H c 0-9 @: @: @:clean@:(a,p)} 36080@r{ a@: c d @: @: 1 @:deg@:(a)} 36081@r{ a@: c f @: @: 1 @:pfloat@:(a)} 36082@r{ a@: H c f @: @: 1 @:float@:(a)} 36083@r{ a@: c h @: @: 1 @:hms@:(a)} 36084@r{ a@: c p @: @: @:polar@:(a)} 36085@r{ a@: I c p @: @: @:rect@:(a)} 36086@r{ a@: c r @: @: 1 @:rad@:(a)} 36087 36088@c 36089@r{ a@: c F @: @: 5 @:pfrac@:(a,p)} 36090@r{ a@: H c F @: @: 5 @:frac@:(a,p)} 36091 36092@c 36093@r{ a@: c % @: @: @:percent@:(a*100)} 36094 36095@c 36096@r{ @: d . @:char @: 50 @:calc-point-char@:} 36097@r{ @: d , @:char @: 50 @:calc-group-char@:} 36098@r{ @: d < @: @: 13,50 @:calc-left-justify@:} 36099@r{ @: d = @: @: 13,50 @:calc-center-justify@:} 36100@r{ @: d > @: @: 13,50 @:calc-right-justify@:} 36101@r{ @: d @{ @:label @: 50 @:calc-left-label@:} 36102@r{ @: d @} @:label @: 50 @:calc-right-label@:} 36103@r{ @: d [ @: @: 4 @:calc-truncate-up@:} 36104@r{ @: d ] @: @: 4 @:calc-truncate-down@:} 36105@r{ @: d " @: @: 12,50 @:calc-display-strings@:} 36106@r{ @: d @summarykey{SPC} @: @: @:calc-refresh@:} 36107@r{ @: d @summarykey{RET} @: @: 1 @:calc-refresh-top@:} 36108 36109@c 36110@r{ @: d 0 @: @: 50 @:calc-decimal-radix@:} 36111@r{ @: d 2 @: @: 50 @:calc-binary-radix@:} 36112@r{ @: d 6 @: @: 50 @:calc-hex-radix@:} 36113@r{ @: d 8 @: @: 50 @:calc-octal-radix@:} 36114 36115@c 36116@r{ @: d b @: @:12,13,50 @:calc-line-breaking@:} 36117@r{ @: d c @: @: 50 @:calc-complex-notation@:} 36118@r{ @: d d @:format @: 50 @:calc-date-notation@:} 36119@r{ @: d e @: @: 5,50 @:calc-eng-notation@:} 36120@r{ @: d f @:num @: 31,50 @:calc-fix-notation@:} 36121@r{ @: d g @: @:12,13,50 @:calc-group-digits@:} 36122@r{ @: d h @:format @: 50 @:calc-hms-notation@:} 36123@r{ @: d i @: @: 50 @:calc-i-notation@:} 36124@r{ @: d j @: @: 50 @:calc-j-notation@:} 36125@r{ @: d l @: @: 12,50 @:calc-line-numbering@:} 36126@r{ @: d n @: @: 5,50 @:calc-normal-notation@:} 36127@r{ @: d o @:format @: 50 @:calc-over-notation@:} 36128@r{ @: d p @: @: 12,50 @:calc-show-plain@:} 36129@r{ @: d r @:radix @: 31,50 @:calc-radix@:} 36130@r{ @: d s @: @: 5,50 @:calc-sci-notation@:} 36131@r{ @: d t @: @: 27 @:calc-truncate-stack@:} 36132@r{ @: d w @: @: 12,13 @:calc-auto-why@:} 36133@r{ @: d z @: @: 12,50 @:calc-leading-zeros@:} 36134 36135@c 36136@r{ @: d B @: @: 50 @:calc-big-language@:} 36137@r{ @: d C @: @: 50 @:calc-c-language@:} 36138@r{ @: d E @: @: 50 @:calc-eqn-language@:} 36139@r{ @: d F @: @: 50 @:calc-fortran-language@:} 36140@r{ @: d M @: @: 50 @:calc-mathematica-language@:} 36141@r{ @: d N @: @: 50 @:calc-normal-language@:} 36142@r{ @: d O @: @: 50 @:calc-flat-language@:} 36143@r{ @: d P @: @: 50 @:calc-pascal-language@:} 36144@r{ @: d T @: @: 50 @:calc-tex-language@:} 36145@r{ @: d L @: @: 50 @:calc-latex-language@:} 36146@r{ @: d U @: @: 50 @:calc-unformatted-language@:} 36147@r{ @: d W @: @: 50 @:calc-maple-language@:} 36148 36149@c 36150@r{ a@: f [ @: @: 4 @:decr@:(a,n)} 36151@r{ a@: f ] @: @: 4 @:incr@:(a,n)} 36152 36153@c 36154@r{ a b@: f b @: @: 2 @:beta@:(a,b)} 36155@r{ a@: f e @: @: 1 @:erf@:(a)} 36156@r{ a@: I f e @: @: 1 @:erfc@:(a)} 36157@r{ a@: f g @: @: 1 @:gamma@:(a)} 36158@r{ a b@: f h @: @: 2 @:hypot@:(a,b)} 36159@r{ a@: f i @: @: 1 @:im@:(a)} 36160@r{ n a@: f j @: @: 2 @:besJ@:(n,a)} 36161@r{ a b@: f n @: @: 2 @:min@:(a,b)} 36162@r{ a@: f r @: @: 1 @:re@:(a)} 36163@r{ a@: f s @: @: 1 @:sign@:(a)} 36164@r{ a b@: f x @: @: 2 @:max@:(a,b)} 36165@r{ n a@: f y @: @: 2 @:besY@:(n,a)} 36166 36167@c 36168@r{ a@: f A @: @: 1 @:abssqr@:(a)} 36169@r{ x a b@: f B @: @: @:betaI@:(x,a,b)} 36170@r{ x a b@: H f B @: @: @:betaB@:(x,a,b)} 36171@r{ a@: f E @: @: 1 @:expm1@:(a)} 36172@r{ a x@: f G @: @: 2 @:gammaP@:(a,x)} 36173@r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)} 36174@r{ a x@: H f G @: @: 2 @:gammag@:(a,x)} 36175@r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)} 36176@r{ a b@: f I @: @: 2 @:ilog@:(a,b)} 36177@r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a} 36178@r{ a@: f L @: @: 1 @:lnp1@:(a)} 36179@r{ a@: f M @: @: 1 @:mant@:(a)} 36180@r{ a@: f Q @: @: 1 @:isqrt@:(a)} 36181@r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2} 36182@r{ a n@: f S @: @: 2 @:scf@:(a,n)} 36183@r{ y x@: f T @: @: @:arctan2@:(y,x)} 36184@r{ a@: f X @: @: 1 @:xpon@:(a)} 36185 36186@c 36187@r{ x y@: g a @: @: 28,40 @:calc-graph-add@:} 36188@r{ @: g b @: @: 12 @:calc-graph-border@:} 36189@r{ @: g c @: @: @:calc-graph-clear@:} 36190@r{ @: g d @: @: 41 @:calc-graph-delete@:} 36191@r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:} 36192@r{ @: g g @: @: 12 @:calc-graph-grid@:} 36193@r{ @: g h @:title @: @:calc-graph-header@:} 36194@r{ @: g j @: @: 4 @:calc-graph-juggle@:} 36195@r{ @: g k @: @: 12 @:calc-graph-key@:} 36196@r{ @: g l @: @: 12 @:calc-graph-log-x@:} 36197@r{ @: g n @:name @: @:calc-graph-name@:} 36198@r{ @: g p @: @: 42 @:calc-graph-plot@:} 36199@r{ @: g q @: @: @:calc-graph-quit@:} 36200@r{ @: g r @:range @: @:calc-graph-range-x@:} 36201@r{ @: g s @: @: 12,13 @:calc-graph-line-style@:} 36202@r{ @: g t @:title @: @:calc-graph-title-x@:} 36203@r{ @: g v @: @: @:calc-graph-view-commands@:} 36204@r{ @: g x @:display @: @:calc-graph-display@:} 36205@r{ @: g z @: @: 12 @:calc-graph-zero-x@:} 36206 36207@c 36208@r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:} 36209@r{ @: g C @:command @: @:calc-graph-command@:} 36210@r{ @: g D @:device @: 43,44 @:calc-graph-device@:} 36211@r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:} 36212@r{ @: g H @: @: 12 @:calc-graph-hide@:} 36213@r{ @: g K @: @: @:calc-graph-kill@:} 36214@r{ @: g L @: @: 12 @:calc-graph-log-y@:} 36215@r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:} 36216@r{ @: g O @:filename @: 43,44 @:calc-graph-output@:} 36217@r{ @: g P @: @: 42 @:calc-graph-print@:} 36218@r{ @: g R @:range @: @:calc-graph-range-y@:} 36219@r{ @: g S @: @: 12,13 @:calc-graph-point-style@:} 36220@r{ @: g T @:title @: @:calc-graph-title-y@:} 36221@r{ @: g V @: @: @:calc-graph-view-trail@:} 36222@r{ @: g X @:format @: @:calc-graph-geometry@:} 36223@r{ @: g Z @: @: 12 @:calc-graph-zero-y@:} 36224 36225@c 36226@r{ @: g C-l @: @: 12 @:calc-graph-log-z@:} 36227@r{ @: g C-r @:range @: @:calc-graph-range-z@:} 36228@r{ @: g C-t @:title @: @:calc-graph-title-z@:} 36229 36230@c 36231@r{ @: h b @: @: @:calc-describe-bindings@:} 36232@r{ @: h c @:key @: @:calc-describe-key-briefly@:} 36233@r{ @: h f @:function @: @:calc-describe-function@:} 36234@r{ @: h h @: @: @:calc-full-help@:} 36235@r{ @: h i @: @: @:calc-info@:} 36236@r{ @: h k @:key @: @:calc-describe-key@:} 36237@r{ @: h n @: @: @:calc-view-news@:} 36238@r{ @: h s @: @: @:calc-info-summary@:} 36239@r{ @: h t @: @: @:calc-tutorial@:} 36240@r{ @: h v @:var @: @:calc-describe-variable@:} 36241 36242@c 36243@r{ @: j 1-9 @: @: @:calc-select-part@:} 36244@r{ @: j @summarykey{RET} @: @: 27 @:calc-copy-selection@:} 36245@r{ @: j @summarykey{DEL} @: @: 27 @:calc-del-selection@:} 36246@r{ @: j ' @:formula @: 27 @:calc-enter-selection@:} 36247@r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:} 36248@r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:} 36249 36250@c 36251@r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:} 36252@r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:} 36253@r{ @: j * @:formula @: 27 @:calc-sel-mult-both-sides@:} 36254@r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:} 36255@r{ @: j & @: @: 27 @:calc-sel-invert@:} 36256 36257@c 36258@r{ @: j a @: @: 27 @:calc-select-additional@:} 36259@r{ @: j b @: @: 12 @:calc-break-selections@:} 36260@r{ @: j c @: @: @:calc-clear-selections@:} 36261@r{ @: j d @: @: 12,50 @:calc-show-selections@:} 36262@r{ @: j e @: @: 12 @:calc-enable-selections@:} 36263@r{ @: j l @: @: 4,27 @:calc-select-less@:} 36264@r{ @: j m @: @: 4,27 @:calc-select-more@:} 36265@r{ @: j n @: @: 4 @:calc-select-next@:} 36266@r{ @: j o @: @: 4,27 @:calc-select-once@:} 36267@r{ @: j p @: @: 4 @:calc-select-previous@:} 36268@r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:} 36269@r{ @: j s @: @: 4,27 @:calc-select-here@:} 36270@r{ @: j u @: @: 27 @:calc-unselect@:} 36271@r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:} 36272 36273@c 36274@r{ @: j C @: @: 27 @:calc-sel-commute@:} 36275@r{ @: j D @: @: 4,27 @:calc-sel-distribute@:} 36276@r{ @: j E @: @: 27 @:calc-sel-jump-equals@:} 36277@r{ @: j I @: @: 27 @:calc-sel-isolate@:} 36278@r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)} 36279@r{ @: j L @: @: 4,27 @:calc-commute-left@:} 36280@r{ @: j M @: @: 27 @:calc-sel-merge@:} 36281@r{ @: j N @: @: 27 @:calc-sel-negate@:} 36282@r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:} 36283@r{ @: j R @: @: 4,27 @:calc-commute-right@:} 36284@r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:} 36285@r{ @: j U @: @: 27 @:calc-sel-unpack@:} 36286 36287@c 36288@r{ @: k a @: @: @:calc-random-again@:} 36289@r{ n@: k b @: @: 1 @:bern@:(n)} 36290@r{ n x@: H k b @: @: 2 @:bern@:(n,x)} 36291@r{ n m@: k c @: @: 2 @:choose@:(n,m)} 36292@r{ n m@: H k c @: @: 2 @:perm@:(n,m)} 36293@r{ n@: k d @: @: 1 @:dfact@:(n) n!!} 36294@r{ n@: k e @: @: 1 @:euler@:(n)} 36295@r{ n x@: H k e @: @: 2 @:euler@:(n,x)} 36296@r{ n@: k f @: @: 4 @:prfac@:(n)} 36297@r{ n m@: k g @: @: 2 @:gcd@:(n,m)} 36298@r{ m n@: k h @: @: 14 @:shuffle@:(n,m)} 36299@r{ n m@: k l @: @: 2 @:lcm@:(n,m)} 36300@r{ n@: k m @: @: 1 @:moebius@:(n)} 36301@r{ n@: k n @: @: 4 @:nextprime@:(n)} 36302@r{ n@: I k n @: @: 4 @:prevprime@:(n)} 36303@r{ n@: k p @: @: 4,28 @:calc-prime-test@:} 36304@r{ m@: k r @: @: 14 @:random@:(m)} 36305@r{ n m@: k s @: @: 2 @:stir1@:(n,m)} 36306@r{ n m@: H k s @: @: 2 @:stir2@:(n,m)} 36307@r{ n@: k t @: @: 1 @:totient@:(n)} 36308 36309@c 36310@r{ n p x@: k B @: @: @:utpb@:(x,n,p)} 36311@r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)} 36312@r{ v x@: k C @: @: @:utpc@:(x,v)} 36313@r{ v x@: I k C @: @: @:ltpc@:(x,v)} 36314@r{ n m@: k E @: @: @:egcd@:(n,m)} 36315@r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)} 36316@r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)} 36317@r{ m s x@: k N @: @: @:utpn@:(x,m,s)} 36318@r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)} 36319@r{ m x@: k P @: @: @:utpp@:(x,m)} 36320@r{ m x@: I k P @: @: @:ltpp@:(x,m)} 36321@r{ v x@: k T @: @: @:utpt@:(x,v)} 36322@r{ v x@: I k T @: @: @:ltpt@:(x,v)} 36323 36324@c 36325@r{ a b@: l + @: @: @:lupadd@:(a,b)} 36326@r{ a b@: H l + @: @: @:lufadd@:(a,b)} 36327@r{ a b@: l - @: @: @:lupsub@:(a,b)} 36328@r{ a b@: H l - @: @: @:lufsub@:(a,b)} 36329@r{ a b@: l * @: @: @:lupmul@:(a,b)} 36330@r{ a b@: H l * @: @: @:lufmul@:(a,b)} 36331@r{ a b@: l / @: @: @:lupdiv@:(a,b)} 36332@r{ a b@: H l / @: @: @:lufdiv@:(a,b)} 36333@r{ a@: l d @: @: @:dbpower@:(a)} 36334@r{ a b@: O l d @: @: @:dbpower@:(a,b)} 36335@r{ a@: H l d @: @: @:dbfield@:(a)} 36336@r{ a b@: O H l d @: @: @:dbfield@:(a,b)} 36337@r{ a@: l n @: @: @:nppower@:(a)} 36338@r{ a b@: O l n @: @: @:nppower@:(a,b)} 36339@r{ a@: H l n @: @: @:npfield@:(a)} 36340@r{ a b@: O H l n @: @: @:npfield@:(a,b)} 36341@r{ a@: l q @: @: @:lupquant@:(a)} 36342@r{ a b@: O l q @: @: @:lupquant@:(a,b)} 36343@r{ a@: H l q @: @: @:lufquant@:(a)} 36344@r{ a b@: O H l q @: @: @:lufquant@:(a,b)} 36345@r{ a@: l s @: @: @:spn@:(a)} 36346@r{ a@: l m @: @: @:midi@:(a)} 36347@r{ a@: l f @: @: @:freq@:(a)} 36348 36349@c 36350@r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:} 36351@r{ @: m d @: @: @:calc-degrees-mode@:} 36352@r{ @: m e @: @: @:calc-embedded-preserve-modes@:} 36353@r{ @: m f @: @: 12 @:calc-frac-mode@:} 36354@r{ @: m g @: @: 52 @:calc-get-modes@:} 36355@r{ @: m h @: @: @:calc-hms-mode@:} 36356@r{ @: m i @: @: 12,13 @:calc-infinite-mode@:} 36357@r{ @: m m @: @: @:calc-save-modes@:} 36358@r{ @: m p @: @: 12 @:calc-polar-mode@:} 36359@r{ @: m r @: @: @:calc-radians-mode@:} 36360@r{ @: m s @: @: 12 @:calc-symbolic-mode@:} 36361@r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:} 36362@r{ @: m v @: @: 12,13 @:calc-matrix-mode@:} 36363@r{ @: m w @: @: 13 @:calc-working@:} 36364@r{ @: m x @: @: @:calc-always-load-extensions@:} 36365 36366@c 36367@r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:} 36368@r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:} 36369@r{ @: m C @: @: 12 @:calc-auto-recompute@:} 36370@r{ @: m D @: @: @:calc-default-simplify-mode@:} 36371@r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:} 36372@r{ @: m F @:filename @: 13 @:calc-settings-file-name@:} 36373@r{ @: m N @: @: 12 @:calc-num-simplify-mode@:} 36374@r{ @: m O @: @: 12 @:calc-no-simplify-mode@:} 36375@r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:} 36376@r{ @: m S @: @: 12 @:calc-shift-prefix@:} 36377@r{ @: m U @: @: 12 @:calc-units-simplify-mode@:} 36378 36379@c 36380@r{ @: r s @:register @: 27 @:calc-copy-to-register@:} 36381@r{ @: r i @:register @: @:calc-insert-register@:} 36382 36383@c 36384@r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:} 36385@r{ @: s d @:var, decl @: @:calc-declare-variable@:} 36386@r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:} 36387@r{ @: s i @:buffer @: @:calc-insert-variables@:} 36388@r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:} 36389@r{ a b@: s l @:var @: 29 @:@:a (letting var=b)} 36390@r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:} 36391@r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)} 36392@r{ @: s p @:var @: 29 @:calc-permanent-variable@:} 36393@r{ @: s r @:var @: 29 @:@:v (recalled value)} 36394@r{ @: r 0-9 @: @: @:calc-recall-quick@:} 36395@r{ a@: s s @:var @: 28,29 @:calc-store@:} 36396@r{ a@: s 0-9 @: @: @:calc-store-quick@:} 36397@r{ a@: s t @:var @: 29 @:calc-store-into@:} 36398@r{ a@: t 0-9 @: @: @:calc-store-into-quick@:} 36399@r{ @: s u @:var @: 29 @:calc-unstore@:} 36400@r{ a@: s x @:var @: 29 @:calc-store-exchange@:} 36401 36402@c 36403@r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:} 36404@r{ @: s D @:editing @: 30 @:calc-edit-Decls@:} 36405@r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:} 36406@r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:} 36407@r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:} 36408@r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:} 36409@r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:} 36410@r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:} 36411@r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:} 36412@r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:} 36413@r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:} 36414@r{ @: s U @:editing @: 30 @:calc-edit-Units@:} 36415@r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:} 36416 36417@c 36418@r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)} 36419@r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)} 36420@r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)} 36421@r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)} 36422@r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)} 36423@r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)} 36424@r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)} 36425@r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)} 36426@r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))} 36427@r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b} 36428@r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}} 36429 36430@c 36431@r{ @: t [ @: @: 4 @:calc-trail-first@:} 36432@r{ @: t ] @: @: 4 @:calc-trail-last@:} 36433@r{ @: t < @: @: 4 @:calc-trail-scroll-left@:} 36434@r{ @: t > @: @: 4 @:calc-trail-scroll-right@:} 36435@r{ @: t . @: @: 12 @:calc-full-trail-vectors@:} 36436 36437@c 36438@r{ @: t b @: @: 4 @:calc-trail-backward@:} 36439@r{ @: t d @: @: 12,50 @:calc-trail-display@:} 36440@r{ @: t f @: @: 4 @:calc-trail-forward@:} 36441@r{ @: t h @: @: @:calc-trail-here@:} 36442@r{ @: t i @: @: @:calc-trail-in@:} 36443@r{ @: t k @: @: 4 @:calc-trail-kill@:} 36444@r{ @: t m @:string @: @:calc-trail-marker@:} 36445@r{ @: t n @: @: 4 @:calc-trail-next@:} 36446@r{ @: t o @: @: @:calc-trail-out@:} 36447@r{ @: t p @: @: 4 @:calc-trail-previous@:} 36448@r{ @: t r @:string @: @:calc-trail-isearch-backward@:} 36449@r{ @: t s @:string @: @:calc-trail-isearch-forward@:} 36450@r{ @: t y @: @: 4 @:calc-trail-yank@:} 36451 36452@c 36453@r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)} 36454@r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)} 36455@r{ d@: t D @: @: 15 @:date@:(d)} 36456@r{ d@: t I @: @: 4 @:incmonth@:(d,n)} 36457@r{ d@: t J @: @: 16 @:julian@:(d,z)} 36458@r{ d@: t M @: @: 17 @:newmonth@:(d,n)} 36459@r{ @: t N @: @: 16 @:now@:(z)} 36460@r{ d@: t P @:1 @: 31 @:year@:(d)} 36461@r{ d@: t P @:2 @: 31 @:month@:(d)} 36462@r{ d@: t P @:3 @: 31 @:day@:(d)} 36463@r{ d@: t P @:4 @: 31 @:hour@:(d)} 36464@r{ d@: t P @:5 @: 31 @:minute@:(d)} 36465@r{ d@: t P @:6 @: 31 @:second@:(d)} 36466@r{ d@: t P @:7 @: 31 @:weekday@:(d)} 36467@r{ d@: t P @:8 @: 31 @:yearday@:(d)} 36468@r{ d@: t P @:9 @: 31 @:time@:(d)} 36469@r{ d@: t U @: @: 16 @:unixtime@:(d,z)} 36470@r{ d@: t W @: @: 17 @:newweek@:(d,w)} 36471@r{ d@: t Y @: @: 17 @:newyear@:(d,n)} 36472 36473@c 36474@r{ a b@: t + @: @: 2 @:badd@:(a,b)} 36475@r{ a b@: t - @: @: 2 @:bsub@:(a,b)} 36476 36477@c 36478@r{ @: u a @: @: 12 @:calc-autorange-units@:} 36479@r{ a@: u b @: @: @:calc-base-units@:} 36480@r{ a@: u c @:units @: 18 @:calc-convert-units@:} 36481@r{ defn@: u d @:unit, descr @: @:calc-define-unit@:} 36482@r{ @: u e @: @: @:calc-explain-units@:} 36483@r{ @: u g @:unit @: @:calc-get-unit-definition@:} 36484@r{ @: u n @:units @: 18 @:calc-convert-exact-units@:} 36485@r{ @: u p @: @: @:calc-permanent-units@:} 36486@r{ a@: u r @: @: @:calc-remove-units@:} 36487@r{ a@: u s @: @: @:usimplify@:(a)} 36488@r{ a@: u t @:units @: 18 @:calc-convert-temperature@:} 36489@r{ @: u u @:unit @: @:calc-undefine-unit@:} 36490@r{ @: u v @: @: @:calc-enter-units-table@:} 36491@r{ a@: u x @: @: @:calc-extract-units@:} 36492@r{ a@: u 0-9 @: @: @:calc-quick-units@:} 36493 36494@c 36495@r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)} 36496@r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)} 36497@r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)} 36498@r{ v@: u G @: @: 19 @:vgmean@:(v)} 36499@r{ a b@: H u G @: @: 2 @:agmean@:(a,b)} 36500@r{ v@: u M @: @: 19 @:vmean@:(v)} 36501@r{ v@: I u M @: @: 19 @:vmeane@:(v)} 36502@r{ v@: H u M @: @: 19 @:vmedian@:(v)} 36503@r{ v@: I H u M @: @: 19 @:vhmean@:(v)} 36504@r{ v@: u N @: @: 19 @:vmin@:(v)} 36505@r{ v@: u R @: @: @:rms@:(v)} 36506@r{ v@: u S @: @: 19 @:vsdev@:(v)} 36507@r{ v@: I u S @: @: 19 @:vpsdev@:(v)} 36508@r{ v@: H u S @: @: 19 @:vvar@:(v)} 36509@r{ v@: I H u S @: @: 19 @:vpvar@:(v)} 36510@r{ @: u V @: @: @:calc-view-units-table@:} 36511@r{ v@: u X @: @: 19 @:vmax@:(v)} 36512 36513@c 36514@r{ v@: u + @: @: 19 @:vsum@:(v)} 36515@r{ v@: u * @: @: 19 @:vprod@:(v)} 36516@r{ v@: u # @: @: 19 @:vcount@:(v)} 36517 36518@c 36519@r{ @: V ( @: @: 50 @:calc-vector-parens@:} 36520@r{ @: V @{ @: @: 50 @:calc-vector-braces@:} 36521@r{ @: V [ @: @: 50 @:calc-vector-brackets@:} 36522@r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:} 36523@r{ @: V , @: @: 50 @:calc-vector-commas@:} 36524@r{ @: V < @: @: 50 @:calc-matrix-left-justify@:} 36525@r{ @: V = @: @: 50 @:calc-matrix-center-justify@:} 36526@r{ @: V > @: @: 50 @:calc-matrix-right-justify@:} 36527@r{ @: V / @: @: 12,50 @:calc-break-vectors@:} 36528@r{ @: V . @: @: 12,50 @:calc-full-vectors@:} 36529 36530@c 36531@r{ s t@: V ^ @: @: 2 @:vint@:(s,t)} 36532@r{ s t@: V - @: @: 2 @:vdiff@:(s,t)} 36533@r{ s@: V ~ @: @: 1 @:vcompl@:(s)} 36534@r{ s@: V # @: @: 1 @:vcard@:(s)} 36535@r{ s@: V : @: @: 1 @:vspan@:(s)} 36536@r{ s@: V + @: @: 1 @:rdup@:(s)} 36537 36538@c 36539@r{ m@: V & @: @: 1 @:inv@:(m) 1/m} 36540 36541@c 36542@r{ v@: v a @:n @: @:arrange@:(v,n)} 36543@r{ a@: v b @:n @: @:cvec@:(a,n)} 36544@r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)} 36545@r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)} 36546@r{ m@: v c @:0 @: 31 @:getdiag@:(m)} 36547@r{ v@: v d @: @: 25 @:diag@:(v,n)} 36548@r{ v m@: v e @: @: 2 @:vexp@:(v,m)} 36549@r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)} 36550@r{ v a@: v f @: @: 26 @:find@:(v,a,n)} 36551@r{ v@: v h @: @: 1 @:head@:(v)} 36552@r{ v@: I v h @: @: 1 @:tail@:(v)} 36553@r{ v@: H v h @: @: 1 @:rhead@:(v)} 36554@r{ v@: I H v h @: @: 1 @:rtail@:(v)} 36555@r{ @: v i @:n @: 31 @:idn@:(1,n)} 36556@r{ @: v i @:0 @: 31 @:idn@:(1)} 36557@r{ h t@: v k @: @: 2 @:cons@:(h,t)} 36558@r{ h t@: H v k @: @: 2 @:rcons@:(h,t)} 36559@r{ v@: v l @: @: 1 @:vlen@:(v)} 36560@r{ v@: H v l @: @: 1 @:mdims@:(v)} 36561@r{ v m@: v m @: @: 2 @:vmask@:(v,m)} 36562@r{ v@: v n @: @: 1 @:rnorm@:(v)} 36563@r{ a b c@: v p @: @: 24 @:calc-pack@:} 36564@r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)} 36565@r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)} 36566@r{ m@: v r @:0 @: 31 @:getdiag@:(m)} 36567@r{ v i j@: v s @: @: @:subvec@:(v,i,j)} 36568@r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)} 36569@r{ m@: v t @: @: 1 @:trn@:(m)} 36570@r{ v@: v u @: @: 24 @:calc-unpack@:} 36571@r{ v@: v v @: @: 1 @:rev@:(v)} 36572@r{ @: v x @:n @: 31 @:index@:(n)} 36573@r{ n s i@: C-u v x @: @: @:index@:(n,s,i)} 36574 36575@c 36576@r{ v@: V A @:op @: 22 @:apply@:(op,v)} 36577@r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)} 36578@r{ m@: V D @: @: 1 @:det@:(m)} 36579@r{ s@: V E @: @: 1 @:venum@:(s)} 36580@r{ s@: V F @: @: 1 @:vfloor@:(s)} 36581@r{ v@: V G @: @: @:grade@:(v)} 36582@r{ v@: I V G @: @: @:rgrade@:(v)} 36583@r{ v@: V H @:n @: 31 @:histogram@:(v,n)} 36584@r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)} 36585@r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)} 36586@r{ m@: V J @: @: 1 @:ctrn@:(m)} 36587@r{ m1 m2@: V K @: @: @:kron@:(m1,m2)} 36588@r{ m@: V L @: @: 1 @:lud@:(m)} 36589@r{ v@: V M @:op @: 22,23 @:map@:(op,v)} 36590@r{ v@: V N @: @: 1 @:cnorm@:(v)} 36591@r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)} 36592@r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)} 36593@r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)} 36594@r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)} 36595@r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)} 36596@r{ v@: V S @: @: @:sort@:(v)} 36597@r{ v@: I V S @: @: @:rsort@:(v)} 36598@r{ m@: V T @: @: 1 @:tr@:(m)} 36599@r{ v@: V U @:op @: 22 @:accum@:(op,v)} 36600@r{ v@: I V U @:op @: 22 @:raccum@:(op,v)} 36601@r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)} 36602@r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)} 36603@r{ s t@: V V @: @: 2 @:vunion@:(s,t)} 36604@r{ s t@: V X @: @: 2 @:vxor@:(s,t)} 36605 36606@c 36607@r{ @: Y @: @: @:@:user commands} 36608 36609@c 36610@r{ @: z @: @: @:@:user commands} 36611 36612@c 36613@r{ c@: Z [ @: @: 45 @:calc-kbd-if@:} 36614@r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:} 36615@r{ @: Z : @: @: @:calc-kbd-else@:} 36616@r{ @: Z ] @: @: @:calc-kbd-end-if@:} 36617 36618@c 36619@r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:} 36620@r{ c@: Z / @: @: 45 @:calc-kbd-break@:} 36621@r{ @: Z @} @: @: @:calc-kbd-end-loop@:} 36622@r{ n@: Z < @: @: @:calc-kbd-repeat@:} 36623@r{ @: Z > @: @: @:calc-kbd-end-repeat@:} 36624@r{ n m@: Z ( @: @: @:calc-kbd-for@:} 36625@r{ s@: Z ) @: @: @:calc-kbd-end-for@:} 36626 36627@c 36628@r{ @: Z C-g @: @: @:@:cancel if/loop command} 36629 36630@c 36631@r{ @: Z ` @: @: @:calc-kbd-push@:} 36632@r{ @: Z ' @: @: @:calc-kbd-pop@:} 36633@r{ @: Z # @: @: @:calc-kbd-query@:} 36634 36635@c 36636@r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:} 36637@r{ @: Z D @:key, command @: @:calc-user-define@:} 36638@r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:} 36639@r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:} 36640@r{ @: Z G @:key @: @:calc-get-user-defn@:} 36641@r{ @: Z I @: @: @:calc-user-define-invocation@:} 36642@r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:} 36643@r{ @: Z P @:key @: @:calc-user-define-permanent@:} 36644@r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:} 36645@r{ @: Z T @: @: 12 @:calc-timing@:} 36646@r{ @: Z U @:key @: @:calc-user-undefine@:} 36647 36648@end format 36649 36650@c Avoid '@:' from here on, as it now means \sumsep in tex mode. 36651 36652@noindent 36653NOTES 36654 36655@enumerate 36656@c 1 36657@item 36658Positive prefix arguments apply to @expr{n} stack entries. 36659Negative prefix arguments apply to the @expr{-n}th stack entry. 36660A prefix of zero applies to the entire stack. (For @key{LFD} and 36661@kbd{M-@key{DEL}}, the meaning of the sign is reversed.) 36662 36663@c 2 36664@item 36665Positive prefix arguments apply to @expr{n} stack entries. 36666Negative prefix arguments apply to the top stack entry 36667and the next @expr{-n} stack entries. 36668 36669@c 3 36670@item 36671Positive prefix arguments rotate top @expr{n} stack entries by one. 36672Negative prefix arguments rotate the entire stack by @expr{-n}. 36673A prefix of zero reverses the entire stack. 36674 36675@c 4 36676@item 36677Prefix argument specifies a repeat count or distance. 36678 36679@c 5 36680@item 36681Positive prefix arguments specify a precision @expr{p}. 36682Negative prefix arguments reduce the current precision by @expr{-p}. 36683 36684@c 6 36685@item 36686A prefix argument is interpreted as an additional step-size parameter. 36687A plain @kbd{C-u} prefix means to prompt for the step size. 36688 36689@c 7 36690@item 36691A prefix argument specifies simplification level and depth. 366921=Basic simplifications, 2=Algebraic simplifications, 3=Extended simplifications 36693 36694@c 8 36695@item 36696A negative prefix operates only on the top level of the input formula. 36697 36698@c 9 36699@item 36700Positive prefix arguments specify a word size of @expr{w} bits, unsigned. 36701Negative prefix arguments specify a word size of @expr{w} bits, signed. 36702 36703@c 10 36704@item 36705Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument 36706cannot be specified in the keyboard version of this command. 36707 36708@c 11 36709@item 36710From the keyboard, @expr{d} is omitted and defaults to zero. 36711 36712@c 12 36713@item 36714Mode is toggled; a positive prefix always sets the mode, and a negative 36715prefix always clears the mode. 36716 36717@c 13 36718@item 36719Some prefix argument values provide special variations of the mode. 36720 36721@c 14 36722@item 36723A prefix argument, if any, is used for @expr{m} instead of taking 36724@expr{m} from the stack. @expr{M} may take any of these values: 36725@iftex 36726{@advance@tableindent10pt 36727@end iftex 36728@table @asis 36729@item Integer 36730Random integer in the interval @expr{[0 .. m)}. 36731@item Float 36732Random floating-point number in the interval @expr{[0 .. m)}. 36733@item 0.0 36734Gaussian with mean 1 and standard deviation 0. 36735@item Error form 36736Gaussian with specified mean and standard deviation. 36737@item Interval 36738Random integer or floating-point number in that interval. 36739@item Vector 36740Random element from the vector. 36741@end table 36742@iftex 36743} 36744@end iftex 36745 36746@c 15 36747@item 36748A prefix argument from 1 to 6 specifies number of date components 36749to remove from the stack. @xref{Date Conversions}. 36750 36751@c 16 36752@item 36753A prefix argument specifies a time zone; @kbd{C-u} says to take the 36754time zone number or name from the top of the stack. @xref{Time Zones}. 36755 36756@c 17 36757@item 36758A prefix argument specifies a day number (0--6, 0--31, or 0--366). 36759 36760@c 18 36761@item 36762If the input has no units, you will be prompted for both the old and 36763the new units. 36764 36765@c 19 36766@item 36767With a prefix argument, collect that many stack entries to form the 36768input data set. Each entry may be a single value or a vector of values. 36769 36770@c 20 36771@item 36772With a prefix argument of 1, take a single 36773@texline @var{n}@math{\times2} 36774@infoline @mathit{@var{N}x2} 36775matrix from the stack instead of two separate data vectors. 36776 36777@c 21 36778@item 36779The row or column number @expr{n} may be given as a numeric prefix 36780argument instead. A plain @kbd{C-u} prefix says to take @expr{n} 36781from the top of the stack. If @expr{n} is a vector or interval, 36782a subvector/submatrix of the input is created. 36783 36784@c 22 36785@item 36786The @expr{op} prompt can be answered with the key sequence for the 36787desired function, or with @kbd{x} or @kbd{z} followed by a function name, 36788or with @kbd{$} to take a formula from the top of the stack, or with 36789@kbd{'} and a typed formula. In the last two cases, the formula may 36790be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}; or it 36791may include @kbd{$}, @kbd{$$}, etc., where @kbd{$} will correspond to the 36792last argument of the created function; or otherwise you will be 36793prompted for an argument list. The number of vectors popped from the 36794stack by @kbd{V M} depends on the number of arguments of the function. 36795 36796@c 23 36797@item 36798One of the mapping direction keys @kbd{_} (horizontal, i.e., map 36799by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or 36800reduce down), or @kbd{=} (map or reduce by rows) may be used before 36801entering @expr{op}; these modify the function name by adding the letter 36802@code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,'' 36803or @code{d} for ``down.'' 36804 36805@c 24 36806@item 36807The prefix argument specifies a packing mode. A nonnegative mode 36808is the number of items (for @kbd{v p}) or the number of levels 36809(for @kbd{v u}). A negative mode is as described below. With no 36810prefix argument, the mode is taken from the top of the stack and 36811may be an integer or a vector of integers. 36812@iftex 36813{@advance@tableindent-20pt 36814@end iftex 36815@table @cite 36816@item -1 36817(@var{2}) Rectangular complex number. 36818@item -2 36819(@var{2}) Polar complex number. 36820@item -3 36821(@var{3}) HMS form. 36822@item -4 36823(@var{2}) Error form. 36824@item -5 36825(@var{2}) Modulo form. 36826@item -6 36827(@var{2}) Closed interval. 36828@item -7 36829(@var{2}) Closed .. open interval. 36830@item -8 36831(@var{2}) Open .. closed interval. 36832@item -9 36833(@var{2}) Open interval. 36834@item -10 36835(@var{2}) Fraction. 36836@item -11 36837(@var{2}) Float with integer mantissa. 36838@item -12 36839(@var{2}) Float with mantissa in @expr{[1 .. 10)}. 36840@item -13 36841(@var{1}) Date form (using date numbers). 36842@item -14 36843(@var{3}) Date form (using year, month, day). 36844@item -15 36845(@var{6}) Date form (using year, month, day, hour, minute, second). 36846@end table 36847@iftex 36848} 36849@end iftex 36850 36851@c 25 36852@item 36853A prefix argument specifies the size @expr{n} of the matrix. With no 36854prefix argument, @expr{n} is omitted and the size is inferred from 36855the input vector. 36856 36857@c 26 36858@item 36859The prefix argument specifies the starting position @expr{n} (default 1). 36860 36861@c 27 36862@item 36863Cursor position within stack buffer affects this command. 36864 36865@c 28 36866@item 36867Arguments are not actually removed from the stack by this command. 36868 36869@c 29 36870@item 36871Variable name may be a single digit or a full name. 36872 36873@c 30 36874@item 36875Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or 36876@key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the 36877buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation 36878of the result of the edit. 36879 36880@c 31 36881@item 36882The number prompted for can also be provided as a prefix argument. 36883 36884@c 32 36885@item 36886Press this key a second time to cancel the prefix. 36887 36888@c 33 36889@item 36890With a negative prefix, deactivate all formulas. With a positive 36891prefix, deactivate and then reactivate from scratch. 36892 36893@c 34 36894@item 36895Default is to scan for nearest formula delimiter symbols. With a 36896prefix of zero, formula is delimited by mark and point. With a 36897non-zero prefix, formula is delimited by scanning forward or 36898backward by that many lines. 36899 36900@c 35 36901@item 36902Parse the region between point and mark as a vector. A nonzero prefix 36903parses @var{n} lines before or after point as a vector. A zero prefix 36904parses the current line as a vector. A @kbd{C-u} prefix parses the 36905region between point and mark as a single formula. 36906 36907@c 36 36908@item 36909Parse the rectangle defined by point and mark as a matrix. A positive 36910prefix @var{n} divides the rectangle into columns of width @var{n}. 36911A zero or @kbd{C-u} prefix parses each line as one formula. A negative 36912prefix suppresses special treatment of bracketed portions of a line. 36913 36914@c 37 36915@item 36916A numeric prefix causes the current language mode to be ignored. 36917 36918@c 38 36919@item 36920Responding to a prompt with a blank line answers that and all 36921later prompts by popping additional stack entries. 36922 36923@c 39 36924@item 36925Answer for @expr{v} may also be of the form @expr{v = v_0} or 36926@expr{v - v_0}. 36927 36928@c 40 36929@item 36930With a positive prefix argument, stack contains many @expr{y}'s and one 36931common @expr{x}. With a zero prefix, stack contains a vector of 36932@expr{y}s and a common @expr{x}. With a negative prefix, stack 36933contains many @expr{[x,y]} vectors. (For 3D plots, substitute 36934@expr{z} for @expr{y} and @expr{x,y} for @expr{x}.) 36935 36936@c 41 36937@item 36938With any prefix argument, all curves in the graph are deleted. 36939 36940@c 42 36941@item 36942With a positive prefix, refines an existing plot with more data points. 36943With a negative prefix, forces recomputation of the plot data. 36944 36945@c 43 36946@item 36947With any prefix argument, set the default value instead of the 36948value for this graph. 36949 36950@c 44 36951@item 36952With a negative prefix argument, set the value for the printer. 36953 36954@c 45 36955@item 36956Condition is considered ``true'' if it is a nonzero real or complex 36957number, or a formula whose value is known to be nonzero; it is ``false'' 36958otherwise. 36959 36960@c 46 36961@item 36962Several formulas separated by commas are pushed as multiple stack 36963entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"} 36964delimiters may be omitted. The notation @kbd{$$$} refers to the value 36965in stack level three, and causes the formula to replace the top three 36966stack levels. The notation @kbd{$3} refers to stack level three without 36967causing that value to be removed from the stack. Use @key{LFD} in place 36968of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET} 36969to evaluate variables. 36970 36971@c 47 36972@item 36973The variable is replaced by the formula shown on the right. The 36974Inverse flag reverses the order of the operands, e.g., @kbd{I s - x} 36975assigns 36976@texline @math{x \coloneq a-x}. 36977@infoline @expr{x := a-x}. 36978 36979@c 48 36980@item 36981Press @kbd{?} repeatedly to see how to choose a model. Answer the 36982variables prompt with @expr{iv} or @expr{iv;pv} to specify 36983independent and parameter variables. A positive prefix argument 36984takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix 36985and a vector from the stack. 36986 36987@c 49 36988@item 36989With a plain @kbd{C-u} prefix, replace the current region of the 36990destination buffer with the yanked text instead of inserting. 36991 36992@c 50 36993@item 36994All stack entries are reformatted; the @kbd{H} prefix inhibits this. 36995The @kbd{I} prefix sets the mode temporarily, redraws the top stack 36996entry, then restores the original setting of the mode. 36997 36998@c 51 36999@item 37000A negative prefix sets the default 3D resolution instead of the 37001default 2D resolution. 37002 37003@c 52 37004@item 37005This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize}, 37006@var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar}, 37007@var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12 37008grabs the @var{n}th mode value only. 37009@end enumerate 37010 37011@iftex 37012(Space is provided below for you to keep your own written notes.) 37013@page 37014@endgroup 37015@end iftex 37016 37017 37018@c [end-summary] 37019 37020@node Key Index, Command Index, Summary, Top 37021@unnumbered Index of Key Sequences 37022 37023@printindex ky 37024 37025@node Command Index, Function Index, Key Index, Top 37026@unnumbered Index of Calculator Commands 37027 37028Since all Calculator commands begin with the prefix @samp{calc-}, the 37029@kbd{x} key has been provided as a variant of @kbd{M-x} which automatically 37030types @samp{calc-} for you. Thus, @kbd{x last-args} is short for 37031@kbd{M-x calc-last-args}. 37032 37033@printindex pg 37034 37035@node Function Index, Concept Index, Command Index, Top 37036@unnumbered Index of Algebraic Functions 37037 37038This is a list of built-in functions and operators usable in algebraic 37039expressions. Their full Lisp names are derived by adding the prefix 37040@samp{calcFunc-}, as in @code{calcFunc-sqrt}. 37041@iftex 37042All functions except those noted with ``*'' have corresponding 37043Calc keystrokes and can also be found in the Calc Summary. 37044@end iftex 37045 37046@printindex tp 37047 37048@node Concept Index, Variable Index, Function Index, Top 37049@unnumbered Concept Index 37050 37051@printindex cp 37052 37053@node Variable Index, Lisp Function Index, Concept Index, Top 37054@unnumbered Index of Variables 37055 37056The variables in this list that do not contain dashes are accessible 37057as Calc variables. Add a @samp{var-} prefix to get the name of the 37058corresponding Lisp variable. 37059 37060The remaining variables are Lisp variables suitable for @code{setq}ing 37061in your Calc init file or @file{.emacs} file. 37062 37063@printindex vr 37064 37065@node Lisp Function Index, , Variable Index, Top 37066@unnumbered Index of Lisp Math Functions 37067 37068The following functions are meant to be used with @code{defmath}, not 37069@code{defun} definitions. For names that do not start with @samp{calc-}, 37070the corresponding full Lisp name is derived by adding a prefix of 37071@samp{math-}. 37072 37073@printindex fn 37074 37075@bye 37076