Commit | Line | Data |
---|---|---|
d7b8e6c6 EZ |
1 | \input texinfo @c -*-texinfo-*- |
2 | @comment %**start of header (This is for running Texinfo on a region.) | |
3 | @c smallbook | |
4 | @setfilename ../info/calc | |
5 | @c [title] | |
5208b407 | 6 | @settitle GNU Emacs Calc 2.1 Manual |
d7b8e6c6 EZ |
7 | @setchapternewpage odd |
8 | @comment %**end of header (This is for running Texinfo on a region.) | |
9 | ||
a4231b04 JB |
10 | @c The following macros are used for conditional output for single lines. |
11 | @c @texline foo | |
12 | @c `foo' will appear only in TeX output | |
13 | @c @infoline foo | |
14 | @c `foo' will appear only in non-TeX output | |
15 | ||
8e04863e | 16 | @c @expr{expr} will typeset an expression; |
a4231b04 JB |
17 | @c $x$ in TeX, @samp{x} otherwise. |
18 | ||
19 | @iftex | |
bd712b70 | 20 | @macro texline |
a4231b04 | 21 | @end macro |
a4231b04 | 22 | @alias infoline=comment |
bd712b70 JB |
23 | @alias expr=math |
24 | @alias tfn=code | |
8e04863e | 25 | @alias mathit=expr |
a4231b04 JB |
26 | @macro cpi{} |
27 | @math{@pi{}} | |
28 | @end macro | |
29 | @macro cpiover{den} | |
30 | @math{@pi/\den\} | |
31 | @end macro | |
32 | @end iftex | |
33 | ||
34 | @ifnottex | |
35 | @alias texline=comment | |
36 | @macro infoline{stuff} | |
37 | \stuff\ | |
38 | @end macro | |
39 | @alias expr=samp | |
bd712b70 | 40 | @alias tfn=t |
8e04863e | 41 | @alias mathit=i |
a4231b04 JB |
42 | @macro cpi{} |
43 | @expr{pi} | |
44 | @end macro | |
45 | @macro cpiover{den} | |
46 | @expr{pi/\den\} | |
47 | @end macro | |
48 | @end ifnottex | |
49 | ||
50 | ||
d7b8e6c6 | 51 | @tex |
b275eac7 EZ |
52 | % Suggested by Karl Berry <karl@@freefriends.org> |
53 | \gdef\!{\mskip-\thinmuskip} | |
d7b8e6c6 EZ |
54 | @end tex |
55 | ||
d7b8e6c6 EZ |
56 | @c Fix some other things specifically for this manual. |
57 | @iftex | |
58 | @finalout | |
59 | @mathcode`@:=`@: @c Make Calc fractions come out right in math mode | |
d7b8e6c6 EZ |
60 | @tex |
61 | \gdef\coloneq{\mathrel{\mathord:\mathord=}} | |
5d67986c | 62 | |
d7b8e6c6 EZ |
63 | \gdef\beforedisplay{\vskip-10pt} |
64 | \gdef\afterdisplay{\vskip-5pt} | |
65 | \gdef\beforedisplayh{\vskip-25pt} | |
66 | \gdef\afterdisplayh{\vskip-10pt} | |
d7b8e6c6 EZ |
67 | @end tex |
68 | @newdimen@kyvpos @kyvpos=0pt | |
69 | @newdimen@kyhpos @kyhpos=0pt | |
70 | @newcount@calcclubpenalty @calcclubpenalty=1000 | |
5d67986c | 71 | @ignore |
d7b8e6c6 EZ |
72 | @newcount@calcpageno |
73 | @newtoks@calcoldeverypar @calcoldeverypar=@everypar | |
74 | @everypar={@calceverypar@the@calcoldeverypar} | |
75 | @ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi | |
76 | @ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi | |
77 | @catcode`@\=0 \catcode`\@=11 | |
78 | \r@ggedbottomtrue | |
79 | \catcode`\@=0 @catcode`@\=@active | |
5d67986c | 80 | @end ignore |
d7b8e6c6 EZ |
81 | @end iftex |
82 | ||
18f952d5 | 83 | @copying |
d7b8e6c6 EZ |
84 | This file documents Calc, the GNU Emacs calculator. |
85 | ||
b223e22d | 86 | Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004, |
4e6835db | 87 | 2005, 2006, 2007 Free Software Foundation, Inc. |
d7b8e6c6 | 88 | |
18f952d5 | 89 | @quotation |
0d48e8aa | 90 | Permission is granted to copy, distribute and/or modify this document |
678e7c71 | 91 | under the terms of the GNU Free Documentation License, Version 1.2 or |
0d48e8aa EZ |
92 | any later version published by the Free Software Foundation; with the |
93 | Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the | |
94 | Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover | |
95 | Texts as in (a) below. | |
d7b8e6c6 | 96 | |
0d48e8aa EZ |
97 | (a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify |
98 | this GNU Manual, like GNU software. Copies published by the Free | |
99 | Software Foundation raise funds for GNU development.'' | |
18f952d5 KB |
100 | @end quotation |
101 | @end copying | |
102 | ||
103 | @dircategory Emacs | |
104 | @direntry | |
b223e22d | 105 | * Calc: (calc). Advanced desk calculator and mathematical tool. |
18f952d5 | 106 | @end direntry |
d7b8e6c6 EZ |
107 | |
108 | @titlepage | |
109 | @sp 6 | |
110 | @center @titlefont{Calc Manual} | |
111 | @sp 4 | |
5208b407 | 112 | @center GNU Emacs Calc Version 2.1 |
d7b8e6c6 EZ |
113 | @c [volume] |
114 | @sp 1 | |
ce7c7522 | 115 | @center March 2005 |
d7b8e6c6 EZ |
116 | @sp 5 |
117 | @center Dave Gillespie | |
118 | @center daveg@@synaptics.com | |
119 | @page | |
120 | ||
121 | @vskip 0pt plus 1filll | |
b65d8176 | 122 | Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004, |
4e6835db | 123 | 2005, 2006, 2007 Free Software Foundation, Inc. |
18f952d5 | 124 | @insertcopying |
d7b8e6c6 EZ |
125 | @end titlepage |
126 | ||
127 | @c [begin] | |
128 | @ifinfo | |
b275eac7 EZ |
129 | @node Top, , (dir), (dir) |
130 | @chapter The GNU Emacs Calculator | |
d7b8e6c6 EZ |
131 | |
132 | @noindent | |
0d48e8aa | 133 | @dfn{Calc} is an advanced desk calculator and mathematical tool |
d7b8e6c6 EZ |
134 | that runs as part of the GNU Emacs environment. |
135 | ||
0d48e8aa EZ |
136 | This manual is divided into three major parts: ``Getting Started,'' |
137 | the ``Calc Tutorial,'' and the ``Calc Reference.'' The Tutorial | |
138 | introduces all the major aspects of Calculator use in an easy, | |
139 | hands-on way. The remainder of the manual is a complete reference to | |
140 | the features of the Calculator. | |
d7b8e6c6 EZ |
141 | |
142 | For help in the Emacs Info system (which you are using to read this | |
143 | file), type @kbd{?}. (You can also type @kbd{h} to run through a | |
144 | longer Info tutorial.) | |
145 | ||
146 | @end ifinfo | |
147 | @menu | |
148 | * Copying:: How you can copy and share Calc. | |
149 | ||
150 | * Getting Started:: General description and overview. | |
b275eac7 | 151 | * Interactive Tutorial:: |
d7b8e6c6 EZ |
152 | * Tutorial:: A step-by-step introduction for beginners. |
153 | ||
154 | * Introduction:: Introduction to the Calc reference manual. | |
155 | * Data Types:: Types of objects manipulated by Calc. | |
156 | * Stack and Trail:: Manipulating the stack and trail buffers. | |
157 | * Mode Settings:: Adjusting display format and other modes. | |
158 | * Arithmetic:: Basic arithmetic functions. | |
159 | * Scientific Functions:: Transcendentals and other scientific functions. | |
160 | * Matrix Functions:: Operations on vectors and matrices. | |
161 | * Algebra:: Manipulating expressions algebraically. | |
162 | * Units:: Operations on numbers with units. | |
163 | * Store and Recall:: Storing and recalling variables. | |
164 | * Graphics:: Commands for making graphs of data. | |
165 | * Kill and Yank:: Moving data into and out of Calc. | |
17c5c219 | 166 | * Keypad Mode:: Operating Calc from a keypad. |
d7b8e6c6 EZ |
167 | * Embedded Mode:: Working with formulas embedded in a file. |
168 | * Programming:: Calc as a programmable calculator. | |
169 | ||
58547c3e | 170 | * Customizing Calc:: Customizing Calc. |
d7b8e6c6 EZ |
171 | * Reporting Bugs:: How to report bugs and make suggestions. |
172 | ||
173 | * Summary:: Summary of Calc commands and functions. | |
174 | ||
175 | * Key Index:: The standard Calc key sequences. | |
176 | * Command Index:: The interactive Calc commands. | |
177 | * Function Index:: Functions (in algebraic formulas). | |
178 | * Concept Index:: General concepts. | |
179 | * Variable Index:: Variables used by Calc (both user and internal). | |
180 | * Lisp Function Index:: Internal Lisp math functions. | |
181 | @end menu | |
182 | ||
183 | @node Copying, Getting Started, Top, Top | |
184 | @unnumbered GNU GENERAL PUBLIC LICENSE | |
5208b407 JB |
185 | @center Version 2, June 1991 |
186 | ||
187 | @c This file is intended to be included in another file. | |
d7b8e6c6 EZ |
188 | |
189 | @display | |
5208b407 | 190 | Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc. |
364c38d3 | 191 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
d7b8e6c6 EZ |
192 | |
193 | Everyone is permitted to copy and distribute verbatim copies | |
194 | of this license document, but changing it is not allowed. | |
195 | @end display | |
196 | ||
197 | @unnumberedsec Preamble | |
198 | ||
5208b407 JB |
199 | The licenses for most software are designed to take away your |
200 | freedom to share and change it. By contrast, the GNU General Public | |
d7b8e6c6 | 201 | License is intended to guarantee your freedom to share and change free |
5208b407 JB |
202 | software---to make sure the software is free for all its users. This |
203 | General Public License applies to most of the Free Software | |
204 | Foundation's software and to any other program whose authors commit to | |
205 | using it. (Some other Free Software Foundation software is covered by | |
efb8d76b | 206 | the GNU Lesser General Public License instead.) You can apply it to |
5208b407 | 207 | your programs, too. |
d7b8e6c6 EZ |
208 | |
209 | When we speak of free software, we are referring to freedom, not | |
5208b407 JB |
210 | price. Our General Public Licenses are designed to make sure that you |
211 | have the freedom to distribute copies of free software (and charge for | |
212 | this service if you wish), that you receive source code or can get it | |
213 | if you want it, that you can change the software or use pieces of it | |
214 | in new free programs; and that you know you can do these things. | |
d7b8e6c6 EZ |
215 | |
216 | To protect your rights, we need to make restrictions that forbid | |
217 | anyone to deny you these rights or to ask you to surrender the rights. | |
218 | These restrictions translate to certain responsibilities for you if you | |
219 | distribute copies of the software, or if you modify it. | |
220 | ||
5208b407 | 221 | For example, if you distribute copies of such a program, whether |
d7b8e6c6 EZ |
222 | gratis or for a fee, you must give the recipients all the rights that |
223 | you have. You must make sure that they, too, receive or can get the | |
5208b407 JB |
224 | source code. And you must show them these terms so they know their |
225 | rights. | |
d7b8e6c6 EZ |
226 | |
227 | We protect your rights with two steps: (1) copyright the software, and | |
228 | (2) offer you this license which gives you legal permission to copy, | |
229 | distribute and/or modify the software. | |
230 | ||
231 | Also, for each author's protection and ours, we want to make certain | |
232 | that everyone understands that there is no warranty for this free | |
233 | software. If the software is modified by someone else and passed on, we | |
234 | want its recipients to know that what they have is not the original, so | |
235 | that any problems introduced by others will not reflect on the original | |
236 | authors' reputations. | |
237 | ||
5208b407 JB |
238 | Finally, any free program is threatened constantly by software |
239 | patents. We wish to avoid the danger that redistributors of a free | |
240 | program will individually obtain patent licenses, in effect making the | |
241 | program proprietary. To prevent this, we have made it clear that any | |
242 | patent must be licensed for everyone's free use or not licensed at all. | |
243 | ||
d7b8e6c6 EZ |
244 | The precise terms and conditions for copying, distribution and |
245 | modification follow. | |
246 | ||
247 | @iftex | |
5208b407 | 248 | @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
d7b8e6c6 EZ |
249 | @end iftex |
250 | @ifinfo | |
5208b407 | 251 | @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
d7b8e6c6 EZ |
252 | @end ifinfo |
253 | ||
5208b407 | 254 | @enumerate 0 |
d7b8e6c6 | 255 | @item |
5208b407 JB |
256 | This License applies to any program or other work which contains |
257 | a notice placed by the copyright holder saying it may be distributed | |
258 | under the terms of this General Public License. The ``Program'', below, | |
259 | refers to any such program or work, and a ``work based on the Program'' | |
260 | means either the Program or any derivative work under copyright law: | |
261 | that is to say, a work containing the Program or a portion of it, | |
262 | either verbatim or with modifications and/or translated into another | |
263 | language. (Hereinafter, translation is included without limitation in | |
264 | the term ``modification''.) Each licensee is addressed as ``you''. | |
265 | ||
266 | Activities other than copying, distribution and modification are not | |
267 | covered by this License; they are outside its scope. The act of | |
268 | running the Program is not restricted, and the output from the Program | |
269 | is covered only if its contents constitute a work based on the | |
270 | Program (independent of having been made by running the Program). | |
271 | Whether that is true depends on what the Program does. | |
d7b8e6c6 EZ |
272 | |
273 | @item | |
5208b407 JB |
274 | You may copy and distribute verbatim copies of the Program's |
275 | source code as you receive it, in any medium, provided that you | |
276 | conspicuously and appropriately publish on each copy an appropriate | |
277 | copyright notice and disclaimer of warranty; keep intact all the | |
278 | notices that refer to this License and to the absence of any warranty; | |
279 | and give any other recipients of the Program a copy of this License | |
280 | along with the Program. | |
d7b8e6c6 | 281 | |
5208b407 JB |
282 | You may charge a fee for the physical act of transferring a copy, and |
283 | you may at your option offer warranty protection in exchange for a fee. | |
d7b8e6c6 | 284 | |
d7b8e6c6 | 285 | @item |
5208b407 JB |
286 | You may modify your copy or copies of the Program or any portion |
287 | of it, thus forming a work based on the Program, and copy and | |
288 | distribute such modifications or work under the terms of Section 1 | |
289 | above, provided that you also meet all of these conditions: | |
d7b8e6c6 | 290 | |
5208b407 | 291 | @enumerate a |
d7b8e6c6 | 292 | @item |
5208b407 JB |
293 | You must cause the modified files to carry prominent notices |
294 | stating that you changed the files and the date of any change. | |
d7b8e6c6 EZ |
295 | |
296 | @item | |
5208b407 JB |
297 | You must cause any work that you distribute or publish, that in |
298 | whole or in part contains or is derived from the Program or any | |
299 | part thereof, to be licensed as a whole at no charge to all third | |
300 | parties under the terms of this License. | |
d7b8e6c6 EZ |
301 | |
302 | @item | |
5208b407 JB |
303 | If the modified program normally reads commands interactively |
304 | when run, you must cause it, when started running for such | |
305 | interactive use in the most ordinary way, to print or display an | |
306 | announcement including an appropriate copyright notice and a | |
307 | notice that there is no warranty (or else, saying that you provide | |
308 | a warranty) and that users may redistribute the program under | |
309 | these conditions, and telling the user how to view a copy of this | |
310 | License. (Exception: if the Program itself is interactive but | |
311 | does not normally print such an announcement, your work based on | |
312 | the Program is not required to print an announcement.) | |
313 | @end enumerate | |
d7b8e6c6 | 314 | |
5208b407 JB |
315 | These requirements apply to the modified work as a whole. If |
316 | identifiable sections of that work are not derived from the Program, | |
317 | and can be reasonably considered independent and separate works in | |
318 | themselves, then this License, and its terms, do not apply to those | |
319 | sections when you distribute them as separate works. But when you | |
320 | distribute the same sections as part of a whole which is a work based | |
321 | on the Program, the distribution of the whole must be on the terms of | |
322 | this License, whose permissions for other licensees extend to the | |
323 | entire whole, and thus to each and every part regardless of who wrote it. | |
324 | ||
325 | Thus, it is not the intent of this section to claim rights or contest | |
326 | your rights to work written entirely by you; rather, the intent is to | |
327 | exercise the right to control the distribution of derivative or | |
328 | collective works based on the Program. | |
329 | ||
330 | In addition, mere aggregation of another work not based on the Program | |
331 | with the Program (or with a work based on the Program) on a volume of | |
332 | a storage or distribution medium does not bring the other work under | |
333 | the scope of this License. | |
d7b8e6c6 EZ |
334 | |
335 | @item | |
5208b407 JB |
336 | You may copy and distribute the Program (or a work based on it, |
337 | under Section 2) in object code or executable form under the terms of | |
338 | Sections 1 and 2 above provided that you also do one of the following: | |
d7b8e6c6 | 339 | |
5208b407 | 340 | @enumerate a |
d7b8e6c6 | 341 | @item |
5208b407 JB |
342 | Accompany it with the complete corresponding machine-readable |
343 | source code, which must be distributed under the terms of Sections | |
344 | 1 and 2 above on a medium customarily used for software interchange; or, | |
d7b8e6c6 EZ |
345 | |
346 | @item | |
5208b407 JB |
347 | Accompany it with a written offer, valid for at least three |
348 | years, to give any third party, for a charge no more than your | |
349 | cost of physically performing source distribution, a complete | |
350 | machine-readable copy of the corresponding source code, to be | |
351 | distributed under the terms of Sections 1 and 2 above on a medium | |
352 | customarily used for software interchange; or, | |
d7b8e6c6 EZ |
353 | |
354 | @item | |
5208b407 JB |
355 | Accompany it with the information you received as to the offer |
356 | to distribute corresponding source code. (This alternative is | |
d7b8e6c6 | 357 | allowed only for noncommercial distribution and only if you |
5208b407 JB |
358 | received the program in object code or executable form with such |
359 | an offer, in accord with Subsection b above.) | |
360 | @end enumerate | |
d7b8e6c6 | 361 | |
5208b407 JB |
362 | The source code for a work means the preferred form of the work for |
363 | making modifications to it. For an executable work, complete source | |
364 | code means all the source code for all modules it contains, plus any | |
365 | associated interface definition files, plus the scripts used to | |
366 | control compilation and installation of the executable. However, as a | |
367 | special exception, the source code distributed need not include | |
368 | anything that is normally distributed (in either source or binary | |
369 | form) with the major components (compiler, kernel, and so on) of the | |
370 | operating system on which the executable runs, unless that component | |
371 | itself accompanies the executable. | |
372 | ||
373 | If distribution of executable or object code is made by offering | |
374 | access to copy from a designated place, then offering equivalent | |
375 | access to copy the source code from the same place counts as | |
376 | distribution of the source code, even though third parties are not | |
377 | compelled to copy the source along with the object code. | |
d7b8e6c6 EZ |
378 | |
379 | @item | |
5208b407 JB |
380 | You may not copy, modify, sublicense, or distribute the Program |
381 | except as expressly provided under this License. Any attempt | |
382 | otherwise to copy, modify, sublicense or distribute the Program is | |
383 | void, and will automatically terminate your rights under this License. | |
384 | However, parties who have received copies, or rights, from you under | |
385 | this License will not have their licenses terminated so long as such | |
386 | parties remain in full compliance. | |
d7b8e6c6 EZ |
387 | |
388 | @item | |
5208b407 JB |
389 | You are not required to accept this License, since you have not |
390 | signed it. However, nothing else grants you permission to modify or | |
391 | distribute the Program or its derivative works. These actions are | |
392 | prohibited by law if you do not accept this License. Therefore, by | |
393 | modifying or distributing the Program (or any work based on the | |
394 | Program), you indicate your acceptance of this License to do so, and | |
395 | all its terms and conditions for copying, distributing or modifying | |
396 | the Program or works based on it. | |
d7b8e6c6 EZ |
397 | |
398 | @item | |
399 | Each time you redistribute the Program (or any work based on the | |
5208b407 JB |
400 | Program), the recipient automatically receives a license from the |
401 | original licensor to copy, distribute or modify the Program subject to | |
402 | these terms and conditions. You may not impose any further | |
403 | restrictions on the recipients' exercise of the rights granted herein. | |
404 | You are not responsible for enforcing compliance by third parties to | |
405 | this License. | |
406 | ||
407 | @item | |
408 | If, as a consequence of a court judgment or allegation of patent | |
409 | infringement or for any other reason (not limited to patent issues), | |
410 | conditions are imposed on you (whether by court order, agreement or | |
411 | otherwise) that contradict the conditions of this License, they do not | |
412 | excuse you from the conditions of this License. If you cannot | |
413 | distribute so as to satisfy simultaneously your obligations under this | |
414 | License and any other pertinent obligations, then as a consequence you | |
415 | may not distribute the Program at all. For example, if a patent | |
416 | license would not permit royalty-free redistribution of the Program by | |
417 | all those who receive copies directly or indirectly through you, then | |
418 | the only way you could satisfy both it and this License would be to | |
419 | refrain entirely from distribution of the Program. | |
420 | ||
421 | If any portion of this section is held invalid or unenforceable under | |
422 | any particular circumstance, the balance of the section is intended to | |
423 | apply and the section as a whole is intended to apply in other | |
424 | circumstances. | |
425 | ||
426 | It is not the purpose of this section to induce you to infringe any | |
427 | patents or other property right claims or to contest validity of any | |
428 | such claims; this section has the sole purpose of protecting the | |
429 | integrity of the free software distribution system, which is | |
430 | implemented by public license practices. Many people have made | |
431 | generous contributions to the wide range of software distributed | |
432 | through that system in reliance on consistent application of that | |
433 | system; it is up to the author/donor to decide if he or she is willing | |
434 | to distribute software through any other system and a licensee cannot | |
435 | impose that choice. | |
436 | ||
437 | This section is intended to make thoroughly clear what is believed to | |
438 | be a consequence of the rest of this License. | |
439 | ||
440 | @item | |
441 | If the distribution and/or use of the Program is restricted in | |
442 | certain countries either by patents or by copyrighted interfaces, the | |
443 | original copyright holder who places the Program under this License | |
444 | may add an explicit geographical distribution limitation excluding | |
445 | those countries, so that distribution is permitted only in or among | |
446 | countries not thus excluded. In such case, this License incorporates | |
447 | the limitation as if written in the body of this License. | |
d7b8e6c6 EZ |
448 | |
449 | @item | |
450 | The Free Software Foundation may publish revised and/or new versions | |
451 | of the General Public License from time to time. Such new versions will | |
452 | be similar in spirit to the present version, but may differ in detail to | |
453 | address new problems or concerns. | |
454 | ||
455 | Each version is given a distinguishing version number. If the Program | |
5208b407 | 456 | specifies a version number of this License which applies to it and ``any |
d7b8e6c6 EZ |
457 | later version'', you have the option of following the terms and conditions |
458 | either of that version or of any later version published by the Free | |
459 | Software Foundation. If the Program does not specify a version number of | |
5208b407 | 460 | this License, you may choose any version ever published by the Free Software |
d7b8e6c6 EZ |
461 | Foundation. |
462 | ||
463 | @item | |
464 | If you wish to incorporate parts of the Program into other free | |
465 | programs whose distribution conditions are different, write to the author | |
466 | to ask for permission. For software which is copyrighted by the Free | |
467 | Software Foundation, write to the Free Software Foundation; we sometimes | |
468 | make exceptions for this. Our decision will be guided by the two goals | |
469 | of preserving the free status of all derivatives of our free software and | |
470 | of promoting the sharing and reuse of software generally. | |
471 | ||
472 | @iftex | |
473 | @heading NO WARRANTY | |
474 | @end iftex | |
475 | @ifinfo | |
476 | @center NO WARRANTY | |
477 | @end ifinfo | |
478 | ||
479 | @item | |
480 | BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY | |
481 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN | |
482 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES | |
483 | PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED | |
484 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
485 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS | |
486 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE | |
487 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, | |
488 | REPAIR OR CORRECTION. | |
489 | ||
490 | @item | |
5208b407 JB |
491 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
492 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR | |
d7b8e6c6 | 493 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
5208b407 JB |
494 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
495 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED | |
496 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY | |
497 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER | |
498 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE | |
499 | POSSIBILITY OF SUCH DAMAGES. | |
d7b8e6c6 EZ |
500 | @end enumerate |
501 | ||
5208b407 JB |
502 | @iftex |
503 | @heading END OF TERMS AND CONDITIONS | |
504 | @end iftex | |
505 | @ifinfo | |
506 | @center END OF TERMS AND CONDITIONS | |
507 | @end ifinfo | |
508 | ||
509 | @page | |
510 | @unnumberedsec Appendix: How to Apply These Terms to Your New Programs | |
511 | ||
512 | If you develop a new program, and you want it to be of the greatest | |
513 | possible use to the public, the best way to achieve this is to make it | |
514 | free software which everyone can redistribute and change under these terms. | |
515 | ||
516 | To do so, attach the following notices to the program. It is safest | |
517 | to attach them to the start of each source file to most effectively | |
518 | convey the exclusion of warranty; and each file should have at least | |
519 | the ``copyright'' line and a pointer to where the full notice is found. | |
520 | ||
521 | @smallexample | |
522 | @var{one line to give the program's name and a brief idea of what it does.} | |
523 | Copyright (C) @var{yyyy} @var{name of author} | |
524 | ||
525 | This program is free software; you can redistribute it and/or modify | |
526 | it under the terms of the GNU General Public License as published by | |
527 | the Free Software Foundation; either version 2 of the License, or | |
528 | (at your option) any later version. | |
529 | ||
530 | This program is distributed in the hope that it will be useful, | |
531 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
532 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
533 | GNU General Public License for more details. | |
534 | ||
535 | You should have received a copy of the GNU General Public License | |
536 | along with this program; if not, write to the Free Software | |
086add15 | 537 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
5208b407 JB |
538 | @end smallexample |
539 | ||
540 | Also add information on how to contact you by electronic and paper mail. | |
541 | ||
542 | If the program is interactive, make it output a short notice like this | |
543 | when it starts in an interactive mode: | |
544 | ||
545 | @smallexample | |
baa2a74e | 546 | Gnomovision version 69, Copyright (C) @var{yyyy} @var{name of author} |
5208b407 JB |
547 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
548 | This is free software, and you are welcome to redistribute it | |
549 | under certain conditions; type `show c' for details. | |
550 | @end smallexample | |
551 | ||
552 | The hypothetical commands @samp{show w} and @samp{show c} should show | |
553 | the appropriate parts of the General Public License. Of course, the | |
554 | commands you use may be called something other than @samp{show w} and | |
555 | @samp{show c}; they could even be mouse-clicks or menu items---whatever | |
556 | suits your program. | |
557 | ||
558 | You should also get your employer (if you work as a programmer) or your | |
559 | school, if any, to sign a ``copyright disclaimer'' for the program, if | |
560 | necessary. Here is a sample; alter the names: | |
561 | ||
562 | @example | |
563 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program | |
564 | `Gnomovision' (which makes passes at compilers) written by James Hacker. | |
565 | ||
566 | @var{signature of Ty Coon}, 1 April 1989 | |
567 | Ty Coon, President of Vice | |
568 | @end example | |
569 | ||
570 | This General Public License does not permit incorporating your program into | |
571 | proprietary programs. If your program is a subroutine library, you may | |
572 | consider it more useful to permit linking proprietary applications with the | |
efb8d76b | 573 | library. If this is what you want to do, use the GNU Lesser General |
5208b407 JB |
574 | Public License instead of this License. |
575 | ||
b275eac7 | 576 | @node Getting Started, Tutorial, Copying, Top |
d7b8e6c6 | 577 | @chapter Getting Started |
d7b8e6c6 EZ |
578 | @noindent |
579 | This chapter provides a general overview of Calc, the GNU Emacs | |
580 | Calculator: What it is, how to start it and how to exit from it, | |
581 | and what are the various ways that it can be used. | |
582 | ||
583 | @menu | |
584 | * What is Calc:: | |
585 | * About This Manual:: | |
586 | * Notations Used in This Manual:: | |
d7059a75 | 587 | * Demonstration of Calc:: |
d7b8e6c6 | 588 | * Using Calc:: |
d7b8e6c6 EZ |
589 | * History and Acknowledgements:: |
590 | @end menu | |
591 | ||
592 | @node What is Calc, About This Manual, Getting Started, Getting Started | |
593 | @section What is Calc? | |
594 | ||
595 | @noindent | |
596 | @dfn{Calc} is an advanced calculator and mathematical tool that runs as | |
597 | part of the GNU Emacs environment. Very roughly based on the HP-28/48 | |
598 | series of calculators, its many features include: | |
599 | ||
600 | @itemize @bullet | |
601 | @item | |
602 | Choice of algebraic or RPN (stack-based) entry of calculations. | |
603 | ||
604 | @item | |
605 | Arbitrary precision integers and floating-point numbers. | |
606 | ||
607 | @item | |
608 | Arithmetic on rational numbers, complex numbers (rectangular and polar), | |
609 | error forms with standard deviations, open and closed intervals, vectors | |
610 | and matrices, dates and times, infinities, sets, quantities with units, | |
611 | and algebraic formulas. | |
612 | ||
613 | @item | |
614 | Mathematical operations such as logarithms and trigonometric functions. | |
615 | ||
616 | @item | |
617 | Programmer's features (bitwise operations, non-decimal numbers). | |
618 | ||
619 | @item | |
620 | Financial functions such as future value and internal rate of return. | |
621 | ||
622 | @item | |
623 | Number theoretical features such as prime factorization and arithmetic | |
5d67986c | 624 | modulo @var{m} for any @var{m}. |
d7b8e6c6 EZ |
625 | |
626 | @item | |
627 | Algebraic manipulation features, including symbolic calculus. | |
628 | ||
629 | @item | |
630 | Moving data to and from regular editing buffers. | |
631 | ||
632 | @item | |
07ce2eb3 | 633 | Embedded mode for manipulating Calc formulas and data directly |
d7b8e6c6 EZ |
634 | inside any editing buffer. |
635 | ||
636 | @item | |
637 | Graphics using GNUPLOT, a versatile (and free) plotting program. | |
638 | ||
639 | @item | |
640 | Easy programming using keyboard macros, algebraic formulas, | |
641 | algebraic rewrite rules, or extended Emacs Lisp. | |
642 | @end itemize | |
643 | ||
644 | Calc tries to include a little something for everyone; as a result it is | |
645 | large and might be intimidating to the first-time user. If you plan to | |
646 | use Calc only as a traditional desk calculator, all you really need to | |
647 | read is the ``Getting Started'' chapter of this manual and possibly the | |
648 | first few sections of the tutorial. As you become more comfortable with | |
87101b33 RS |
649 | the program you can learn its additional features. Calc does not |
650 | have the scope and depth of a fully-functional symbolic math package, | |
651 | but Calc has the advantages of convenience, portability, and freedom. | |
d7b8e6c6 EZ |
652 | |
653 | @node About This Manual, Notations Used in This Manual, What is Calc, Getting Started | |
654 | @section About This Manual | |
655 | ||
656 | @noindent | |
657 | This document serves as a complete description of the GNU Emacs | |
658 | Calculator. It works both as an introduction for novices, and as | |
659 | a reference for experienced users. While it helps to have some | |
660 | experience with GNU Emacs in order to get the most out of Calc, | |
661 | this manual ought to be readable even if you don't know or use Emacs | |
662 | regularly. | |
663 | ||
664 | @ifinfo | |
665 | The manual is divided into three major parts:@: the ``Getting | |
666 | Started'' chapter you are reading now, the Calc tutorial (chapter 2), | |
667 | and the Calc reference manual (the remaining chapters and appendices). | |
668 | @end ifinfo | |
669 | @iftex | |
670 | The manual is divided into three major parts:@: the ``Getting | |
671 | Started'' chapter you are reading now, the Calc tutorial (chapter 2), | |
672 | and the Calc reference manual (the remaining chapters and appendices). | |
673 | @c [when-split] | |
674 | @c This manual has been printed in two volumes, the @dfn{Tutorial} and the | |
675 | @c @dfn{Reference}. Both volumes include a copy of the ``Getting Started'' | |
676 | @c chapter. | |
677 | @end iftex | |
678 | ||
679 | If you are in a hurry to use Calc, there is a brief ``demonstration'' | |
680 | below which illustrates the major features of Calc in just a couple of | |
681 | pages. If you don't have time to go through the full tutorial, this | |
682 | will show you everything you need to know to begin. | |
683 | @xref{Demonstration of Calc}. | |
684 | ||
685 | The tutorial chapter walks you through the various parts of Calc | |
686 | with lots of hands-on examples and explanations. If you are new | |
687 | to Calc and you have some time, try going through at least the | |
688 | beginning of the tutorial. The tutorial includes about 70 exercises | |
689 | with answers. These exercises give you some guided practice with | |
690 | Calc, as well as pointing out some interesting and unusual ways | |
691 | to use its features. | |
692 | ||
693 | The reference section discusses Calc in complete depth. You can read | |
694 | the reference from start to finish if you want to learn every aspect | |
695 | of Calc. Or, you can look in the table of contents or the Concept | |
696 | Index to find the parts of the manual that discuss the things you | |
697 | need to know. | |
698 | ||
699 | @cindex Marginal notes | |
700 | Every Calc keyboard command is listed in the Calc Summary, and also | |
701 | in the Key Index. Algebraic functions, @kbd{M-x} commands, and | |
a4231b04 JB |
702 | variables also have their own indices. |
703 | @texline Each | |
704 | @infoline In the printed manual, each | |
d7b8e6c6 EZ |
705 | paragraph that is referenced in the Key or Function Index is marked |
706 | in the margin with its index entry. | |
707 | ||
708 | @c [fix-ref Help Commands] | |
709 | You can access this manual on-line at any time within Calc by | |
710 | pressing the @kbd{h i} key sequence. Outside of the Calc window, | |
58547c3e JB |
711 | you can press @kbd{C-x * i} to read the manual on-line. Also, you |
712 | can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{C-x * t}, | |
713 | or to the Summary by pressing @kbd{h s} or @kbd{C-x * s}. Within Calc, | |
d7b8e6c6 EZ |
714 | you can also go to the part of the manual describing any Calc key, |
715 | function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v}, | |
716 | respectively. @xref{Help Commands}. | |
717 | ||
029b2a44 JB |
718 | The Calc manual can be printed, but because the manual is so large, you |
719 | should only make a printed copy if you really need it. To print the | |
720 | manual, you will need the @TeX{} typesetting program (this is a free | |
721 | program by Donald Knuth at Stanford University) as well as the | |
722 | @file{texindex} program and @file{texinfo.tex} file, both of which can | |
723 | be obtained from the FSF as part of the @code{texinfo} package. | |
724 | To print the Calc manual in one huge tome, you will need the | |
725 | source code to this manual, @file{calc.texi}, available as part of the | |
726 | Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}. | |
727 | Alternatively, change to the @file{man} subdirectory of the Emacs | |
728 | source distribution, and type @kbd{make calc.dvi}. (Don't worry if you | |
729 | get some ``overfull box'' warnings while @TeX{} runs.) | |
730 | The result will be a device-independent output file called | |
731 | @file{calc.dvi}, which you must print in whatever way is right | |
732 | for your system. On many systems, the command is | |
733 | ||
734 | @example | |
735 | lpr -d calc.dvi | |
736 | @end example | |
737 | ||
738 | @noindent | |
739 | or | |
740 | ||
741 | @example | |
742 | dvips calc.dvi | |
743 | @end example | |
744 | ||
745 | @c Printed copies of this manual are also available from the Free Software | |
746 | @c Foundation. | |
d7b8e6c6 EZ |
747 | |
748 | @node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started | |
749 | @section Notations Used in This Manual | |
750 | ||
751 | @noindent | |
752 | This section describes the various notations that are used | |
753 | throughout the Calc manual. | |
754 | ||
755 | In keystroke sequences, uppercase letters mean you must hold down | |
756 | the shift key while typing the letter. Keys pressed with Control | |
757 | held down are shown as @kbd{C-x}. Keys pressed with Meta held down | |
758 | are shown as @kbd{M-x}. Other notations are @key{RET} for the | |
759 | Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key, | |
760 | @key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key. | |
909a758a JB |
761 | The @key{DEL} key is called Backspace on some keyboards, it is |
762 | whatever key you would use to correct a simple typing error when | |
763 | regularly using Emacs. | |
d7b8e6c6 EZ |
764 | |
765 | (If you don't have the @key{LFD} or @key{TAB} keys on your keyboard, | |
766 | the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively. | |
767 | If you don't have a Meta key, look for Alt or Extend Char. You can | |
d7059a75 | 768 | also press @key{ESC} or @kbd{C-[} first to get the same effect, so |
5d67986c | 769 | that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.) |
d7b8e6c6 EZ |
770 | |
771 | Sometimes the @key{RET} key is not shown when it is ``obvious'' | |
5d67986c | 772 | that you must press @key{RET} to proceed. For example, the @key{RET} |
d7b8e6c6 EZ |
773 | is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}. |
774 | ||
775 | Commands are generally shown like this: @kbd{p} (@code{calc-precision}) | |
58547c3e JB |
776 | or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is |
777 | normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence, | |
d7b8e6c6 EZ |
778 | but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}. |
779 | ||
780 | Commands that correspond to functions in algebraic notation | |
781 | are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means | |
782 | the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that | |
783 | the corresponding function in an algebraic-style formula would | |
784 | be @samp{cos(@var{x})}. | |
785 | ||
786 | A few commands don't have key equivalents: @code{calc-sincos} | |
a4231b04 | 787 | [@code{sincos}]. |
d7b8e6c6 EZ |
788 | |
789 | @node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started | |
790 | @section A Demonstration of Calc | |
791 | ||
792 | @noindent | |
793 | @cindex Demonstration of Calc | |
794 | This section will show some typical small problems being solved with | |
795 | Calc. The focus is more on demonstration than explanation, but | |
796 | everything you see here will be covered more thoroughly in the | |
797 | Tutorial. | |
798 | ||
799 | To begin, start Emacs if necessary (usually the command @code{emacs} | |
58547c3e | 800 | does this), and type @kbd{C-x * c} to start the |
d7059a75 JB |
801 | Calculator. (You can also use @kbd{M-x calc} if this doesn't work. |
802 | @xref{Starting Calc}, for various ways of starting the Calculator.) | |
d7b8e6c6 EZ |
803 | |
804 | Be sure to type all the sample input exactly, especially noting the | |
805 | difference between lower-case and upper-case letters. Remember, | |
5d67986c | 806 | @key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab, |
d7b8e6c6 EZ |
807 | Delete, and Space keys. |
808 | ||
809 | @strong{RPN calculation.} In RPN, you type the input number(s) first, | |
810 | then the command to operate on the numbers. | |
811 | ||
812 | @noindent | |
a4231b04 | 813 | Type @kbd{2 @key{RET} 3 + Q} to compute |
8e04863e | 814 | @texline @math{\sqrt{2+3} = 2.2360679775}. |
a4231b04 | 815 | @infoline the square root of 2+3, which is 2.2360679775. |
d7b8e6c6 EZ |
816 | |
817 | @noindent | |
a4231b04 | 818 | Type @kbd{P 2 ^} to compute |
8e04863e | 819 | @texline @math{\pi^2 = 9.86960440109}. |
a4231b04 | 820 | @infoline the value of `pi' squared, 9.86960440109. |
d7b8e6c6 EZ |
821 | |
822 | @noindent | |
5d67986c | 823 | Type @key{TAB} to exchange the order of these two results. |
d7b8e6c6 EZ |
824 | |
825 | @noindent | |
826 | Type @kbd{- I H S} to subtract these results and compute the Inverse | |
827 | Hyperbolic sine of the difference, 2.72996136574. | |
828 | ||
829 | @noindent | |
5d67986c | 830 | Type @key{DEL} to erase this result. |
d7b8e6c6 EZ |
831 | |
832 | @strong{Algebraic calculation.} You can also enter calculations using | |
833 | conventional ``algebraic'' notation. To enter an algebraic formula, | |
834 | use the apostrophe key. | |
835 | ||
836 | @noindent | |
a4231b04 | 837 | Type @kbd{' sqrt(2+3) @key{RET}} to compute |
8e04863e | 838 | @texline @math{\sqrt{2+3}}. |
a4231b04 | 839 | @infoline the square root of 2+3. |
d7b8e6c6 EZ |
840 | |
841 | @noindent | |
a4231b04 | 842 | Type @kbd{' pi^2 @key{RET}} to enter |
8e04863e | 843 | @texline @math{\pi^2}. |
a4231b04 JB |
844 | @infoline `pi' squared. |
845 | To evaluate this symbolic formula as a number, type @kbd{=}. | |
d7b8e6c6 EZ |
846 | |
847 | @noindent | |
5d67986c | 848 | Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent |
d7b8e6c6 EZ |
849 | result from the most-recent and compute the Inverse Hyperbolic sine. |
850 | ||
851 | @strong{Keypad mode.} If you are using the X window system, press | |
58547c3e | 852 | @w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to |
d7b8e6c6 EZ |
853 | the next section.) |
854 | ||
855 | @noindent | |
856 | Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT} | |
857 | ``buttons'' using your left mouse button. | |
858 | ||
859 | @noindent | |
bd712b70 | 860 | Click on @key{PI}, @key{2}, and @tfn{y^x}. |
d7b8e6c6 EZ |
861 | |
862 | @noindent | |
863 | Click on @key{INV}, then @key{ENTER} to swap the two results. | |
864 | ||
865 | @noindent | |
866 | Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}. | |
867 | ||
868 | @noindent | |
869 | Click on @key{<-} to erase the result, then click @key{OFF} to turn | |
870 | the Keypad Calculator off. | |
871 | ||
58547c3e | 872 | @strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc. |
d7b8e6c6 | 873 | Now select the following numbers as an Emacs region: ``Mark'' the |
5d67986c | 874 | front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there, |
d7b8e6c6 | 875 | then move to the other end of the list. (Either get this list from |
58547c3e JB |
876 | the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just |
877 | type these numbers into a scratch file.) Now type @kbd{C-x * g} to | |
d7b8e6c6 EZ |
878 | ``grab'' these numbers into Calc. |
879 | ||
d7b8e6c6 | 880 | @example |
5d67986c | 881 | @group |
d7b8e6c6 EZ |
882 | 1.23 1.97 |
883 | 1.6 2 | |
884 | 1.19 1.08 | |
d7b8e6c6 | 885 | @end group |
5d67986c | 886 | @end example |
d7b8e6c6 EZ |
887 | |
888 | @noindent | |
889 | The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.'' | |
890 | Type @w{@kbd{V R +}} to compute the sum of these numbers. | |
891 | ||
892 | @noindent | |
893 | Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute | |
894 | the product of the numbers. | |
895 | ||
896 | @noindent | |
897 | You can also grab data as a rectangular matrix. Place the cursor on | |
898 | the upper-leftmost @samp{1} and set the mark, then move to just after | |
58547c3e | 899 | the lower-right @samp{8} and press @kbd{C-x * r}. |
d7b8e6c6 EZ |
900 | |
901 | @noindent | |
a4231b04 | 902 | Type @kbd{v t} to transpose this |
8e04863e | 903 | @texline @math{3\times2} |
a4231b04 JB |
904 | @infoline 3x2 |
905 | matrix into a | |
8e04863e | 906 | @texline @math{2\times3} |
a4231b04 JB |
907 | @infoline 2x3 |
908 | matrix. Type @w{@kbd{v u}} to unpack the rows into two separate | |
909 | vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums | |
910 | of the two original columns. (There is also a special | |
58547c3e | 911 | grab-and-sum-columns command, @kbd{C-x * :}.) |
d7b8e6c6 EZ |
912 | |
913 | @strong{Units conversion.} Units are entered algebraically. | |
5d67986c RS |
914 | Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour. |
915 | Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}. | |
d7b8e6c6 EZ |
916 | |
917 | @strong{Date arithmetic.} Type @kbd{t N} to get the current date and | |
918 | time. Type @kbd{90 +} to find the date 90 days from now. Type | |
5d67986c | 919 | @kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how |
d7b8e6c6 EZ |
920 | many weeks have passed since then. |
921 | ||
922 | @strong{Algebra.} Algebraic entries can also include formulas | |
5d67986c | 923 | or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}} |
d7b8e6c6 EZ |
924 | to enter a pair of equations involving three variables. |
925 | (Note the leading apostrophe in this example; also, note that the space | |
5d67986c | 926 | between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve |
a4231b04 | 927 | these equations for the variables @expr{x} and @expr{y}. |
d7b8e6c6 EZ |
928 | |
929 | @noindent | |
930 | Type @kbd{d B} to view the solutions in more readable notation. | |
8ed713c6 JB |
931 | Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T} |
932 | to view them in the notation for the @TeX{} typesetting system, | |
053bc283 | 933 | and @kbd{d L} to view them in the notation for the La@TeX{} typesetting |
8ed713c6 | 934 | system. Type @kbd{d N} to return to normal notation. |
d7b8e6c6 EZ |
935 | |
936 | @noindent | |
a4231b04 | 937 | Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas. |
d7b8e6c6 EZ |
938 | (That's a letter @kbd{l}, not a numeral @kbd{1}.) |
939 | ||
940 | @iftex | |
941 | @strong{Help functions.} You can read about any command in the on-line | |
58547c3e | 942 | manual. Type @kbd{C-x * c} to return to Calc after each of these |
d7b8e6c6 | 943 | commands: @kbd{h k t N} to read about the @kbd{t N} command, |
5d67986c | 944 | @kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and |
d7b8e6c6 EZ |
945 | @kbd{h s} to read the Calc summary. |
946 | @end iftex | |
947 | @ifinfo | |
948 | @strong{Help functions.} You can read about any command in the on-line | |
58547c3e | 949 | manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to |
d7b8e6c6 | 950 | return here after each of these commands: @w{@kbd{h k t N}} to read |
5d67986c | 951 | about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the |
d7b8e6c6 EZ |
952 | @code{sqrt} function, and @kbd{h s} to read the Calc summary. |
953 | @end ifinfo | |
954 | ||
5d67986c | 955 | Press @key{DEL} repeatedly to remove any leftover results from the stack. |
58547c3e | 956 | To exit from Calc, press @kbd{q} or @kbd{C-x * c} again. |
d7b8e6c6 EZ |
957 | |
958 | @node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started | |
959 | @section Using Calc | |
960 | ||
961 | @noindent | |
962 | Calc has several user interfaces that are specialized for | |
963 | different kinds of tasks. As well as Calc's standard interface, | |
07ce2eb3 | 964 | there are Quick mode, Keypad mode, and Embedded mode. |
d7b8e6c6 | 965 | |
d7b8e6c6 EZ |
966 | @menu |
967 | * Starting Calc:: | |
968 | * The Standard Interface:: | |
969 | * Quick Mode Overview:: | |
970 | * Keypad Mode Overview:: | |
971 | * Standalone Operation:: | |
972 | * Embedded Mode Overview:: | |
58547c3e | 973 | * Other C-x * Commands:: |
d7b8e6c6 EZ |
974 | @end menu |
975 | ||
976 | @node Starting Calc, The Standard Interface, Using Calc, Using Calc | |
977 | @subsection Starting Calc | |
978 | ||
979 | @noindent | |
58547c3e JB |
980 | On most systems, you can type @kbd{C-x *} to start the Calculator. |
981 | The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch}, | |
982 | which can be rebound if convenient (@pxref{Customizing Calc}). | |
d7b8e6c6 | 983 | |
58547c3e JB |
984 | When you press @kbd{C-x *}, Emacs waits for you to press a second key to |
985 | complete the command. In this case, you will follow @kbd{C-x *} with a | |
986 | letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says | |
d7059a75 | 987 | which Calc interface you want to use. |
d7b8e6c6 | 988 | |
58547c3e JB |
989 | To get Calc's standard interface, type @kbd{C-x * c}. To get |
990 | Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief | |
d7b8e6c6 EZ |
991 | list of the available options, and type a second @kbd{?} to get |
992 | a complete list. | |
993 | ||
58547c3e JB |
994 | To ease typing, @kbd{C-x * *} also works to start Calc. It starts the |
995 | same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last | |
996 | used, selecting the @kbd{C-x * c} interface by default. | |
d7b8e6c6 | 997 | |
58547c3e | 998 | If @kbd{C-x *} doesn't work for you, you can always type explicit |
d7b8e6c6 | 999 | commands like @kbd{M-x calc} (for the standard user interface) or |
07ce2eb3 | 1000 | @w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x} |
d7b8e6c6 EZ |
1001 | (that's Meta with the letter @kbd{x}), then, at the prompt, |
1002 | type the full command (like @kbd{calc-keypad}) and press Return. | |
1003 | ||
58547c3e | 1004 | The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start |
d7b8e6c6 EZ |
1005 | the Calculator also turn it off if it is already on. |
1006 | ||
1007 | @node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc | |
1008 | @subsection The Standard Calc Interface | |
1009 | ||
1010 | @noindent | |
1011 | @cindex Standard user interface | |
1012 | Calc's standard interface acts like a traditional RPN calculator, | |
58547c3e | 1013 | operated by the normal Emacs keyboard. When you type @kbd{C-x * c} |
d7b8e6c6 EZ |
1014 | to start the Calculator, the Emacs screen splits into two windows |
1015 | with the file you were editing on top and Calc on the bottom. | |
1016 | ||
d7b8e6c6 | 1017 | @smallexample |
5d67986c | 1018 | @group |
d7b8e6c6 EZ |
1019 | |
1020 | ... | |
1021 | --**-Emacs: myfile (Fundamental)----All---------------------- | |
17c5c219 | 1022 | --- Emacs Calculator Mode --- |Emacs Calc Mode v2.1 ... |
d7b8e6c6 EZ |
1023 | 2: 17.3 | 17.3 |
1024 | 1: -5 | 3 | |
1025 | . | 2 | |
1026 | | 4 | |
1027 | | * 8 | |
1028 | | ->-5 | |
1029 | | | |
1030 | --%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail* | |
d7b8e6c6 | 1031 | @end group |
5d67986c | 1032 | @end smallexample |
d7b8e6c6 EZ |
1033 | |
1034 | In this figure, the mode-line for @file{myfile} has moved up and the | |
1035 | ``Calculator'' window has appeared below it. As you can see, Calc | |
1036 | actually makes two windows side-by-side. The lefthand one is | |
1037 | called the @dfn{stack window} and the righthand one is called the | |
1038 | @dfn{trail window.} The stack holds the numbers involved in the | |
1039 | calculation you are currently performing. The trail holds a complete | |
1040 | record of all calculations you have done. In a desk calculator with | |
1041 | a printer, the trail corresponds to the paper tape that records what | |
1042 | you do. | |
1043 | ||
1044 | In this case, the trail shows that four numbers (17.3, 3, 2, and 4) | |
1045 | were first entered into the Calculator, then the 2 and 4 were | |
8e04863e | 1046 | multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}. |
d7b8e6c6 | 1047 | (The @samp{>} symbol shows that this was the most recent calculation.) |
8e04863e | 1048 | The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack. |
d7b8e6c6 EZ |
1049 | |
1050 | Most Calculator commands deal explicitly with the stack only, but | |
1051 | there is a set of commands that allow you to search back through | |
1052 | the trail and retrieve any previous result. | |
1053 | ||
1054 | Calc commands use the digits, letters, and punctuation keys. | |
1055 | Shifted (i.e., upper-case) letters are different from lowercase | |
1056 | letters. Some letters are @dfn{prefix} keys that begin two-letter | |
1057 | commands. For example, @kbd{e} means ``enter exponent'' and shifted | |
a4231b04 | 1058 | @kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix |
d7b8e6c6 EZ |
1059 | the letter ``e'' takes on very different meanings: @kbd{d e} means |
1060 | ``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.'' | |
1061 | ||
1062 | There is nothing stopping you from switching out of the Calc | |
1063 | window and back into your editing window, say by using the Emacs | |
1064 | @w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is | |
1065 | inside a regular window, Emacs acts just like normal. When the | |
1066 | cursor is in the Calc stack or trail windows, keys are interpreted | |
1067 | as Calc commands. | |
1068 | ||
58547c3e | 1069 | When you quit by pressing @kbd{C-x * c} a second time, the Calculator |
d7b8e6c6 | 1070 | windows go away but the actual Stack and Trail are not gone, just |
58547c3e | 1071 | hidden. When you press @kbd{C-x * c} once again you will get the |
d7b8e6c6 EZ |
1072 | same stack and trail contents you had when you last used the |
1073 | Calculator. | |
1074 | ||
1075 | The Calculator does not remember its state between Emacs sessions. | |
58547c3e | 1076 | Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you |
d7b8e6c6 EZ |
1077 | a fresh stack and trail. There is a command (@kbd{m m}) that lets |
1078 | you save your favorite mode settings between sessions, though. | |
1079 | One of the things it saves is which user interface (standard or | |
1080 | Keypad) you last used; otherwise, a freshly started Emacs will | |
58547c3e | 1081 | always treat @kbd{C-x * *} the same as @kbd{C-x * c}. |
d7b8e6c6 EZ |
1082 | |
1083 | The @kbd{q} key is another equivalent way to turn the Calculator off. | |
1084 | ||
58547c3e | 1085 | If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a |
d7b8e6c6 EZ |
1086 | full-screen version of Calc (@code{full-calc}) in which the stack and |
1087 | trail windows are still side-by-side but are now as tall as the whole | |
58547c3e JB |
1088 | Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit, |
1089 | the file you were editing before reappears. The @kbd{C-x * b} key | |
d7b8e6c6 EZ |
1090 | switches back and forth between ``big'' full-screen mode and the |
1091 | normal partial-screen mode. | |
1092 | ||
58547c3e | 1093 | Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c} |
d7b8e6c6 | 1094 | except that the Calc window is not selected. The buffer you were |
58547c3e | 1095 | editing before remains selected instead. @kbd{C-x * o} is a handy |
d7b8e6c6 | 1096 | way to switch out of Calc momentarily to edit your file; type |
58547c3e | 1097 | @kbd{C-x * c} to switch back into Calc when you are done. |
d7b8e6c6 EZ |
1098 | |
1099 | @node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc | |
1100 | @subsection Quick Mode (Overview) | |
1101 | ||
1102 | @noindent | |
07ce2eb3 | 1103 | @dfn{Quick mode} is a quick way to use Calc when you don't need the |
58547c3e | 1104 | full complexity of the stack and trail. To use it, type @kbd{C-x * q} |
d7b8e6c6 EZ |
1105 | (@code{quick-calc}) in any regular editing buffer. |
1106 | ||
07ce2eb3 | 1107 | Quick mode is very simple: It prompts you to type any formula in |
d7b8e6c6 | 1108 | standard algebraic notation (like @samp{4 - 2/3}) and then displays |
8e04863e | 1109 | the result at the bottom of the Emacs screen (@mathit{3.33333333333} |
d7b8e6c6 | 1110 | in this case). You are then back in the same editing buffer you |
58547c3e | 1111 | were in before, ready to continue editing or to type @kbd{C-x * q} |
d7b8e6c6 EZ |
1112 | again to do another quick calculation. The result of the calculation |
1113 | will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command | |
1114 | at this point will yank the result into your editing buffer. | |
1115 | ||
07ce2eb3 | 1116 | Calc mode settings affect Quick mode, too, though you will have to |
58547c3e | 1117 | go into regular Calc (with @kbd{C-x * c}) to change the mode settings. |
d7b8e6c6 EZ |
1118 | |
1119 | @c [fix-ref Quick Calculator mode] | |
1120 | @xref{Quick Calculator}, for further information. | |
1121 | ||
1122 | @node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc | |
1123 | @subsection Keypad Mode (Overview) | |
1124 | ||
1125 | @noindent | |
07ce2eb3 | 1126 | @dfn{Keypad mode} is a mouse-based interface to the Calculator. |
7d8c2d57 | 1127 | It is designed for use with terminals that support a mouse. If you |
07ce2eb3 | 1128 | don't have a mouse, you will have to operate Keypad mode with your |
be6a9738 | 1129 | arrow keys (which is probably more trouble than it's worth). |
d7b8e6c6 | 1130 | |
58547c3e | 1131 | Type @kbd{C-x * k} to turn Keypad mode on or off. Once again you |
d7b8e6c6 EZ |
1132 | get two new windows, this time on the righthand side of the screen |
1133 | instead of at the bottom. The upper window is the familiar Calc | |
1134 | Stack; the lower window is a picture of a typical calculator keypad. | |
1135 | ||
1136 | @tex | |
1137 | \dimen0=\pagetotal% | |
1138 | \advance \dimen0 by 24\baselineskip% | |
1139 | \ifdim \dimen0>\pagegoal \vfill\eject \fi% | |
1140 | \medskip | |
1141 | @end tex | |
1142 | @smallexample | |
17c5c219 JB |
1143 | @group |
1144 | |--- Emacs Calculator Mode --- | |
1145 | |2: 17.3 | |
1146 | |1: -5 | |
1147 | | . | |
1148 | |--%%-Calc: 12 Deg (Calcul | |
1149 | |----+-----Calc 2.1------+----1 | |
1150 | |FLR |CEIL|RND |TRNC|CLN2|FLT | | |
1151 | |----+----+----+----+----+----| | |
1152 | | LN |EXP | |ABS |IDIV|MOD | | |
1153 | |----+----+----+----+----+----| | |
1154 | |SIN |COS |TAN |SQRT|y^x |1/x | | |
1155 | |----+----+----+----+----+----| | |
1156 | | ENTER |+/- |EEX |UNDO| <- | | |
1157 | |-----+---+-+--+--+-+---++----| | |
1158 | | INV | 7 | 8 | 9 | / | | |
1159 | |-----+-----+-----+-----+-----| | |
1160 | | HYP | 4 | 5 | 6 | * | | |
1161 | |-----+-----+-----+-----+-----| | |
1162 | |EXEC | 1 | 2 | 3 | - | | |
1163 | |-----+-----+-----+-----+-----| | |
1164 | | OFF | 0 | . | PI | + | | |
1165 | |-----+-----+-----+-----+-----+ | |
1166 | @end group | |
d7b8e6c6 | 1167 | @end smallexample |
d7b8e6c6 | 1168 | |
07ce2eb3 | 1169 | Keypad mode is much easier for beginners to learn, because there |
d7b8e6c6 EZ |
1170 | is no need to memorize lots of obscure key sequences. But not all |
1171 | commands in regular Calc are available on the Keypad. You can | |
1172 | always switch the cursor into the Calc stack window to use | |
1173 | standard Calc commands if you need. Serious Calc users, though, | |
07ce2eb3 | 1174 | often find they prefer the standard interface over Keypad mode. |
d7b8e6c6 EZ |
1175 | |
1176 | To operate the Calculator, just click on the ``buttons'' of the | |
1177 | keypad using your left mouse button. To enter the two numbers | |
1178 | shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to | |
1179 | add them together you would then click @kbd{+} (to get 12.3 on | |
1180 | the stack). | |
1181 | ||
1182 | If you click the right mouse button, the top three rows of the | |
1183 | keypad change to show other sets of commands, such as advanced | |
1184 | math functions, vector operations, and operations on binary | |
1185 | numbers. | |
1186 | ||
07ce2eb3 | 1187 | Because Keypad mode doesn't use the regular keyboard, Calc leaves |
d7b8e6c6 EZ |
1188 | the cursor in your original editing buffer. You can type in |
1189 | this buffer in the usual way while also clicking on the Calculator | |
07ce2eb3 | 1190 | keypad. One advantage of Keypad mode is that you don't need an |
d7b8e6c6 EZ |
1191 | explicit command to switch between editing and calculating. |
1192 | ||
58547c3e | 1193 | If you press @kbd{C-x * b} first, you get a full-screen Keypad mode |
d7b8e6c6 EZ |
1194 | (@code{full-calc-keypad}) with three windows: The keypad in the lower |
1195 | left, the stack in the lower right, and the trail on top. | |
1196 | ||
1197 | @c [fix-ref Keypad Mode] | |
1198 | @xref{Keypad Mode}, for further information. | |
1199 | ||
1200 | @node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc | |
1201 | @subsection Standalone Operation | |
1202 | ||
1203 | @noindent | |
1204 | @cindex Standalone Operation | |
1205 | If you are not in Emacs at the moment but you wish to use Calc, | |
1206 | you must start Emacs first. If all you want is to run Calc, you | |
1207 | can give the commands: | |
1208 | ||
1209 | @example | |
1210 | emacs -f full-calc | |
1211 | @end example | |
1212 | ||
1213 | @noindent | |
1214 | or | |
1215 | ||
1216 | @example | |
1217 | emacs -f full-calc-keypad | |
1218 | @end example | |
1219 | ||
1220 | @noindent | |
58547c3e JB |
1221 | which run a full-screen Calculator (as if by @kbd{C-x * b C-x * c}) or |
1222 | a full-screen X-based Calculator (as if by @kbd{C-x * b C-x * k}). | |
d7b8e6c6 EZ |
1223 | In standalone operation, quitting the Calculator (by pressing |
1224 | @kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs | |
1225 | itself. | |
1226 | ||
58547c3e | 1227 | @node Embedded Mode Overview, Other C-x * Commands, Standalone Operation, Using Calc |
d7b8e6c6 EZ |
1228 | @subsection Embedded Mode (Overview) |
1229 | ||
1230 | @noindent | |
07ce2eb3 | 1231 | @dfn{Embedded mode} is a way to use Calc directly from inside an |
d7b8e6c6 EZ |
1232 | editing buffer. Suppose you have a formula written as part of a |
1233 | document like this: | |
1234 | ||
d7b8e6c6 | 1235 | @smallexample |
5d67986c | 1236 | @group |
d7b8e6c6 EZ |
1237 | The derivative of |
1238 | ||
1239 | ln(ln(x)) | |
1240 | ||
1241 | is | |
d7b8e6c6 | 1242 | @end group |
5d67986c | 1243 | @end smallexample |
d7b8e6c6 EZ |
1244 | |
1245 | @noindent | |
1246 | and you wish to have Calc compute and format the derivative for | |
1247 | you and store this derivative in the buffer automatically. To | |
07ce2eb3 | 1248 | do this with Embedded mode, first copy the formula down to where |
d7b8e6c6 EZ |
1249 | you want the result to be: |
1250 | ||
d7b8e6c6 | 1251 | @smallexample |
5d67986c | 1252 | @group |
d7b8e6c6 EZ |
1253 | The derivative of |
1254 | ||
1255 | ln(ln(x)) | |
1256 | ||
1257 | is | |
1258 | ||
1259 | ln(ln(x)) | |
d7b8e6c6 | 1260 | @end group |
5d67986c | 1261 | @end smallexample |
d7b8e6c6 | 1262 | |
58547c3e | 1263 | Now, move the cursor onto this new formula and press @kbd{C-x * e}. |
d7b8e6c6 EZ |
1264 | Calc will read the formula (using the surrounding blank lines to |
1265 | tell how much text to read), then push this formula (invisibly) | |
1266 | onto the Calc stack. The cursor will stay on the formula in the | |
1267 | editing buffer, but the buffer's mode line will change to look | |
1268 | like the Calc mode line (with mode indicators like @samp{12 Deg} | |
1269 | and so on). Even though you are still in your editing buffer, | |
1270 | the keyboard now acts like the Calc keyboard, and any new result | |
1271 | you get is copied from the stack back into the buffer. To take | |
1272 | the derivative, you would type @kbd{a d x @key{RET}}. | |
1273 | ||
d7b8e6c6 | 1274 | @smallexample |
5d67986c | 1275 | @group |
d7b8e6c6 EZ |
1276 | The derivative of |
1277 | ||
1278 | ln(ln(x)) | |
1279 | ||
1280 | is | |
1281 | ||
1282 | 1 / ln(x) x | |
d7b8e6c6 | 1283 | @end group |
5d67986c | 1284 | @end smallexample |
d7b8e6c6 EZ |
1285 | |
1286 | To make this look nicer, you might want to press @kbd{d =} to center | |
07ce2eb3 | 1287 | the formula, and even @kbd{d B} to use Big display mode. |
d7b8e6c6 | 1288 | |
d7b8e6c6 | 1289 | @smallexample |
5d67986c | 1290 | @group |
d7b8e6c6 EZ |
1291 | The derivative of |
1292 | ||
1293 | ln(ln(x)) | |
1294 | ||
1295 | is | |
1296 | % [calc-mode: justify: center] | |
1297 | % [calc-mode: language: big] | |
1298 | ||
1299 | 1 | |
1300 | ------- | |
1301 | ln(x) x | |
d7b8e6c6 | 1302 | @end group |
5d67986c | 1303 | @end smallexample |
d7b8e6c6 EZ |
1304 | |
1305 | Calc has added annotations to the file to help it remember the modes | |
1306 | that were used for this formula. They are formatted like comments | |
8ed713c6 | 1307 | in the @TeX{} typesetting language, just in case you are using @TeX{} or |
053bc283 | 1308 | La@TeX{}. (In this example @TeX{} is not being used, so you might want |
8ed713c6 JB |
1309 | to move these comments up to the top of the file or otherwise put them |
1310 | out of the way.) | |
d7b8e6c6 EZ |
1311 | |
1312 | As an extra flourish, we can add an equation number using a | |
5d67986c | 1313 | righthand label: Type @kbd{d @} (1) @key{RET}}. |
d7b8e6c6 | 1314 | |
d7b8e6c6 | 1315 | @smallexample |
5d67986c | 1316 | @group |
d7b8e6c6 EZ |
1317 | % [calc-mode: justify: center] |
1318 | % [calc-mode: language: big] | |
1319 | % [calc-mode: right-label: " (1)"] | |
1320 | ||
1321 | 1 | |
1322 | ------- (1) | |
1323 | ln(x) x | |
d7b8e6c6 | 1324 | @end group |
5d67986c | 1325 | @end smallexample |
d7b8e6c6 | 1326 | |
58547c3e | 1327 | To leave Embedded mode, type @kbd{C-x * e} again. The mode line |
d7059a75 | 1328 | and keyboard will revert to the way they were before. |
d7b8e6c6 | 1329 | |
58547c3e | 1330 | The related command @kbd{C-x * w} operates on a single word, which |
d7b8e6c6 EZ |
1331 | generally means a single number, inside text. It uses any |
1332 | non-numeric characters rather than blank lines to delimit the | |
1333 | formula it reads. Here's an example of its use: | |
1334 | ||
1335 | @smallexample | |
1336 | A slope of one-third corresponds to an angle of 1 degrees. | |
1337 | @end smallexample | |
1338 | ||
58547c3e | 1339 | Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable |
07ce2eb3 | 1340 | Embedded mode on that number. Now type @kbd{3 /} (to get one-third), |
d7b8e6c6 | 1341 | and @kbd{I T} (the Inverse Tangent converts a slope into an angle), |
58547c3e | 1342 | then @w{@kbd{C-x * w}} again to exit Embedded mode. |
d7b8e6c6 EZ |
1343 | |
1344 | @smallexample | |
1345 | A slope of one-third corresponds to an angle of 18.4349488229 degrees. | |
1346 | @end smallexample | |
1347 | ||
1348 | @c [fix-ref Embedded Mode] | |
1349 | @xref{Embedded Mode}, for full details. | |
1350 | ||
58547c3e JB |
1351 | @node Other C-x * Commands, , Embedded Mode Overview, Using Calc |
1352 | @subsection Other @kbd{C-x *} Commands | |
d7b8e6c6 EZ |
1353 | |
1354 | @noindent | |
58547c3e | 1355 | Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r}, |
d7b8e6c6 EZ |
1356 | which ``grab'' data from a selected region of a buffer into the |
1357 | Calculator. The region is defined in the usual Emacs way, by | |
1358 | a ``mark'' placed at one end of the region, and the Emacs | |
1359 | cursor or ``point'' placed at the other. | |
1360 | ||
58547c3e | 1361 | The @kbd{C-x * g} command reads the region in the usual left-to-right, |
d7b8e6c6 EZ |
1362 | top-to-bottom order. The result is packaged into a Calc vector |
1363 | of numbers and placed on the stack. Calc (in its standard | |
1364 | user interface) is then started. Type @kbd{v u} if you want | |
1365 | to unpack this vector into separate numbers on the stack. Also, | |
58547c3e | 1366 | @kbd{C-u C-x * g} interprets the region as a single number or |
d7b8e6c6 EZ |
1367 | formula. |
1368 | ||
58547c3e | 1369 | The @kbd{C-x * r} command reads a rectangle, with the point and |
d7b8e6c6 EZ |
1370 | mark defining opposite corners of the rectangle. The result |
1371 | is a matrix of numbers on the Calculator stack. | |
1372 | ||
58547c3e | 1373 | Complementary to these is @kbd{C-x * y}, which ``yanks'' the |
d7b8e6c6 | 1374 | value at the top of the Calc stack back into an editing buffer. |
58547c3e JB |
1375 | If you type @w{@kbd{C-x * y}} while in such a buffer, the value is |
1376 | yanked at the current position. If you type @kbd{C-x * y} while | |
d7b8e6c6 EZ |
1377 | in the Calc buffer, Calc makes an educated guess as to which |
1378 | editing buffer you want to use. The Calc window does not have | |
1379 | to be visible in order to use this command, as long as there | |
1380 | is something on the Calc stack. | |
1381 | ||
58547c3e | 1382 | Here, for reference, is the complete list of @kbd{C-x *} commands. |
d7b8e6c6 | 1383 | The shift, control, and meta keys are ignored for the keystroke |
58547c3e | 1384 | following @kbd{C-x *}. |
d7b8e6c6 EZ |
1385 | |
1386 | @noindent | |
1387 | Commands for turning Calc on and off: | |
1388 | ||
1389 | @table @kbd | |
58547c3e | 1390 | @item * |
d7b8e6c6 EZ |
1391 | Turn Calc on or off, employing the same user interface as last time. |
1392 | ||
58547c3e JB |
1393 | @item =, +, -, /, \, &, # |
1394 | Alternatives for @kbd{*}. | |
1395 | ||
d7b8e6c6 EZ |
1396 | @item C |
1397 | Turn Calc on or off using its standard bottom-of-the-screen | |
1398 | interface. If Calc is already turned on but the cursor is not | |
1399 | in the Calc window, move the cursor into the window. | |
1400 | ||
1401 | @item O | |
1402 | Same as @kbd{C}, but don't select the new Calc window. If | |
1403 | Calc is already turned on and the cursor is in the Calc window, | |
1404 | move it out of that window. | |
1405 | ||
1406 | @item B | |
58547c3e | 1407 | Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen. |
d7b8e6c6 EZ |
1408 | |
1409 | @item Q | |
07ce2eb3 | 1410 | Use Quick mode for a single short calculation. |
d7b8e6c6 EZ |
1411 | |
1412 | @item K | |
1413 | Turn Calc Keypad mode on or off. | |
1414 | ||
1415 | @item E | |
1416 | Turn Calc Embedded mode on or off at the current formula. | |
1417 | ||
1418 | @item J | |
1419 | Turn Calc Embedded mode on or off, select the interesting part. | |
1420 | ||
1421 | @item W | |
1422 | Turn Calc Embedded mode on or off at the current word (number). | |
1423 | ||
1424 | @item Z | |
1425 | Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command. | |
1426 | ||
1427 | @item X | |
1428 | Quit Calc; turn off standard, Keypad, or Embedded mode if on. | |
1429 | (This is like @kbd{q} or @key{OFF} inside of Calc.) | |
1430 | @end table | |
1431 | @iftex | |
1432 | @sp 2 | |
1433 | @end iftex | |
1434 | ||
d7b8e6c6 EZ |
1435 | @noindent |
1436 | Commands for moving data into and out of the Calculator: | |
1437 | ||
1438 | @table @kbd | |
1439 | @item G | |
1440 | Grab the region into the Calculator as a vector. | |
1441 | ||
1442 | @item R | |
1443 | Grab the rectangular region into the Calculator as a matrix. | |
1444 | ||
1445 | @item : | |
1446 | Grab the rectangular region and compute the sums of its columns. | |
1447 | ||
1448 | @item _ | |
1449 | Grab the rectangular region and compute the sums of its rows. | |
1450 | ||
1451 | @item Y | |
1452 | Yank a value from the Calculator into the current editing buffer. | |
1453 | @end table | |
1454 | @iftex | |
1455 | @sp 2 | |
1456 | @end iftex | |
d7b8e6c6 | 1457 | |
d7b8e6c6 | 1458 | @noindent |
07ce2eb3 | 1459 | Commands for use with Embedded mode: |
d7b8e6c6 EZ |
1460 | |
1461 | @table @kbd | |
1462 | @item A | |
1463 | ``Activate'' the current buffer. Locate all formulas that | |
1464 | contain @samp{:=} or @samp{=>} symbols and record their locations | |
1465 | so that they can be updated automatically as variables are changed. | |
1466 | ||
1467 | @item D | |
1468 | Duplicate the current formula immediately below and select | |
1469 | the duplicate. | |
1470 | ||
1471 | @item F | |
1472 | Insert a new formula at the current point. | |
1473 | ||
1474 | @item N | |
1475 | Move the cursor to the next active formula in the buffer. | |
1476 | ||
1477 | @item P | |
1478 | Move the cursor to the previous active formula in the buffer. | |
1479 | ||
1480 | @item U | |
1481 | Update (i.e., as if by the @kbd{=} key) the formula at the current point. | |
1482 | ||
1483 | @item ` | |
1484 | Edit (as if by @code{calc-edit}) the formula at the current point. | |
1485 | @end table | |
1486 | @iftex | |
1487 | @sp 2 | |
1488 | @end iftex | |
d7b8e6c6 | 1489 | |
d7b8e6c6 EZ |
1490 | @noindent |
1491 | Miscellaneous commands: | |
1492 | ||
1493 | @table @kbd | |
1494 | @item I | |
1495 | Run the Emacs Info system to read the Calc manual. | |
1496 | (This is the same as @kbd{h i} inside of Calc.) | |
1497 | ||
1498 | @item T | |
1499 | Run the Emacs Info system to read the Calc Tutorial. | |
1500 | ||
1501 | @item S | |
1502 | Run the Emacs Info system to read the Calc Summary. | |
1503 | ||
1504 | @item L | |
1505 | Load Calc entirely into memory. (Normally the various parts | |
1506 | are loaded only as they are needed.) | |
1507 | ||
1508 | @item M | |
5d67986c | 1509 | Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}}) |
d7b8e6c6 EZ |
1510 | and record them as the current keyboard macro. |
1511 | ||
1512 | @item 0 | |
1513 | (This is the ``zero'' digit key.) Reset the Calculator to | |
d7059a75 | 1514 | its initial state: Empty stack, and initial mode settings. |
d7b8e6c6 | 1515 | @end table |
d7b8e6c6 EZ |
1516 | |
1517 | @node History and Acknowledgements, , Using Calc, Getting Started | |
1518 | @section History and Acknowledgements | |
1519 | ||
1520 | @noindent | |
1521 | Calc was originally started as a two-week project to occupy a lull | |
1522 | in the author's schedule. Basically, a friend asked if I remembered | |
a4231b04 | 1523 | the value of |
8e04863e | 1524 | @texline @math{2^{32}}. |
a4231b04 JB |
1525 | @infoline @expr{2^32}. |
1526 | I didn't offhand, but I said, ``that's easy, just call up an | |
1527 | @code{xcalc}.'' @code{Xcalc} duly reported that the answer to our | |
1528 | question was @samp{4.294967e+09}---with no way to see the full ten | |
1529 | digits even though we knew they were there in the program's memory! I | |
1530 | was so annoyed, I vowed to write a calculator of my own, once and for | |
1531 | all. | |
d7b8e6c6 EZ |
1532 | |
1533 | I chose Emacs Lisp, a) because I had always been curious about it | |
1534 | and b) because, being only a text editor extension language after | |
1535 | all, Emacs Lisp would surely reach its limits long before the project | |
1536 | got too far out of hand. | |
1537 | ||
1538 | To make a long story short, Emacs Lisp turned out to be a distressingly | |
1539 | solid implementation of Lisp, and the humble task of calculating | |
1540 | turned out to be more open-ended than one might have expected. | |
1541 | ||
d99ccfc8 RS |
1542 | Emacs Lisp didn't have built-in floating point math (now it does), so |
1543 | this had to be | |
d7b8e6c6 EZ |
1544 | simulated in software. In fact, Emacs integers will only comfortably |
1545 | fit six decimal digits or so---not enough for a decent calculator. So | |
1546 | I had to write my own high-precision integer code as well, and once I had | |
1547 | this I figured that arbitrary-size integers were just as easy as large | |
1548 | integers. Arbitrary floating-point precision was the logical next step. | |
1549 | Also, since the large integer arithmetic was there anyway it seemed only | |
1550 | fair to give the user direct access to it, which in turn made it practical | |
1551 | to support fractions as well as floats. All these features inspired me | |
1552 | to look around for other data types that might be worth having. | |
1553 | ||
1554 | Around this time, my friend Rick Koshi showed me his nifty new HP-28 | |
1555 | calculator. It allowed the user to manipulate formulas as well as | |
87101b33 RS |
1556 | numerical quantities, and it could also operate on matrices. I |
1557 | decided that these would be good for Calc to have, too. And once | |
1558 | things had gone this far, I figured I might as well take a look at | |
1559 | serious algebra systems for further ideas. Since these systems did | |
1560 | far more than I could ever hope to implement, I decided to focus on | |
1561 | rewrite rules and other programming features so that users could | |
1562 | implement what they needed for themselves. | |
d7b8e6c6 EZ |
1563 | |
1564 | Rick complained that matrices were hard to read, so I put in code to | |
1565 | format them in a 2D style. Once these routines were in place, Big mode | |
1566 | was obligatory. Gee, what other language modes would be useful? | |
1567 | ||
1568 | Scott Hemphill and Allen Knutson, two friends with a strong mathematical | |
1569 | bent, contributed ideas and algorithms for a number of Calc features | |
1570 | including modulo forms, primality testing, and float-to-fraction conversion. | |
1571 | ||
1572 | Units were added at the eager insistence of Mass Sivilotti. Later, | |
1573 | Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable | |
1574 | expert assistance with the units table. As far as I can remember, the | |
1575 | idea of using algebraic formulas and variables to represent units dates | |
1576 | back to an ancient article in Byte magazine about muMath, an early | |
1577 | algebra system for microcomputers. | |
1578 | ||
1579 | Many people have contributed to Calc by reporting bugs and suggesting | |
1580 | features, large and small. A few deserve special mention: Tim Peters, | |
1581 | who helped develop the ideas that led to the selection commands, rewrite | |
a4231b04 | 1582 | rules, and many other algebra features; |
d7059a75 | 1583 | @texline Fran\c{c}ois |
a4231b04 JB |
1584 | @infoline Francois |
1585 | Pinard, who contributed an early prototype of the Calc Summary appendix | |
1586 | as well as providing valuable suggestions in many other areas of Calc; | |
1587 | Carl Witty, whose eagle eyes discovered many typographical and factual | |
1588 | errors in the Calc manual; Tim Kay, who drove the development of | |
1589 | Embedded mode; Ove Ewerlid, who made many suggestions relating to the | |
1590 | algebra commands and contributed some code for polynomial operations; | |
1591 | Randal Schwartz, who suggested the @code{calc-eval} function; Robert | |
1592 | J. Chassell, who suggested the Calc Tutorial and exercises; and Juha | |
1593 | Sarlin, who first worked out how to split Calc into quickly-loading | |
1594 | parts. Bob Weiner helped immensely with the Lucid Emacs port. | |
d7b8e6c6 EZ |
1595 | |
1596 | @cindex Bibliography | |
1597 | @cindex Knuth, Art of Computer Programming | |
1598 | @cindex Numerical Recipes | |
1599 | @c Should these be expanded into more complete references? | |
1600 | Among the books used in the development of Calc were Knuth's @emph{Art | |
1601 | of Computer Programming} (especially volume II, @emph{Seminumerical | |
1602 | Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky, | |
87101b33 RS |
1603 | and Vetterling; Bevington's @emph{Data Reduction and Error Analysis |
1604 | for the Physical Sciences}; @emph{Concrete Mathematics} by Graham, | |
1605 | Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the | |
1606 | @emph{CRC Standard Math Tables} (William H. Beyer, ed.); and | |
1607 | Abramowitz and Stegun's venerable @emph{Handbook of Mathematical | |
1608 | Functions}. Also, of course, Calc could not have been written without | |
1609 | the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and | |
1610 | Dan LaLiberte. | |
d7b8e6c6 EZ |
1611 | |
1612 | Final thanks go to Richard Stallman, without whose fine implementations | |
1613 | of the Emacs editor, language, and environment, Calc would have been | |
1614 | finished in two weeks. | |
1615 | ||
1616 | @c [tutorial] | |
1617 | ||
1618 | @ifinfo | |
58547c3e | 1619 | @c This node is accessed by the `C-x * t' command. |
d7b8e6c6 EZ |
1620 | @node Interactive Tutorial, , , Top |
1621 | @chapter Tutorial | |
1622 | ||
1623 | @noindent | |
1624 | Some brief instructions on using the Emacs Info system for this tutorial: | |
1625 | ||
1626 | Press the space bar and Delete keys to go forward and backward in a | |
1627 | section by screenfuls (or use the regular Emacs scrolling commands | |
1628 | for this). | |
1629 | ||
1630 | Press @kbd{n} or @kbd{p} to go to the Next or Previous section. | |
1631 | If the section has a @dfn{menu}, press a digit key like @kbd{1} | |
1632 | or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to | |
1633 | go back up from a sub-section to the menu it is part of. | |
1634 | ||
1635 | Exercises in the tutorial all have cross-references to the | |
1636 | appropriate page of the ``answers'' section. Press @kbd{f}, then | |
1637 | the exercise number, to see the answer to an exercise. After | |
1638 | you have followed a cross-reference, you can press the letter | |
1639 | @kbd{l} to return to where you were before. | |
1640 | ||
1641 | You can press @kbd{?} at any time for a brief summary of Info commands. | |
1642 | ||
1643 | Press @kbd{1} now to enter the first section of the Tutorial. | |
1644 | ||
1645 | @menu | |
1646 | * Tutorial:: | |
1647 | @end menu | |
1648 | @end ifinfo | |
1649 | ||
1650 | @node Tutorial, Introduction, Getting Started, Top | |
1651 | @chapter Tutorial | |
1652 | ||
1653 | @noindent | |
1654 | This chapter explains how to use Calc and its many features, in | |
1655 | a step-by-step, tutorial way. You are encouraged to run Calc and | |
1656 | work along with the examples as you read (@pxref{Starting Calc}). | |
1657 | If you are already familiar with advanced calculators, you may wish | |
1658 | @c [not-split] | |
1659 | to skip on to the rest of this manual. | |
1660 | @c [when-split] | |
1661 | @c to skip on to volume II of this manual, the @dfn{Calc Reference}. | |
1662 | ||
1663 | @c [fix-ref Embedded Mode] | |
1664 | This tutorial describes the standard user interface of Calc only. | |
07ce2eb3 | 1665 | The Quick mode and Keypad mode interfaces are fairly |
d7b8e6c6 | 1666 | self-explanatory. @xref{Embedded Mode}, for a description of |
07ce2eb3 | 1667 | the Embedded mode interface. |
d7b8e6c6 EZ |
1668 | |
1669 | @ifinfo | |
1670 | The easiest way to read this tutorial on-line is to have two windows on | |
1671 | your Emacs screen, one with Calc and one with the Info system. (If you | |
1672 | have a printed copy of the manual you can use that instead.) Press | |
58547c3e JB |
1673 | @kbd{C-x * c} to turn Calc on or to switch into the Calc window, and |
1674 | press @kbd{C-x * i} to start the Info system or to switch into its window. | |
d7b8e6c6 EZ |
1675 | Or, you may prefer to use the tutorial in printed form. |
1676 | @end ifinfo | |
1677 | @iftex | |
1678 | The easiest way to read this tutorial on-line is to have two windows on | |
1679 | your Emacs screen, one with Calc and one with the Info system. (If you | |
1680 | have a printed copy of the manual you can use that instead.) Press | |
58547c3e JB |
1681 | @kbd{C-x * c} to turn Calc on or to switch into the Calc window, and |
1682 | press @kbd{C-x * i} to start the Info system or to switch into its window. | |
d7b8e6c6 EZ |
1683 | @end iftex |
1684 | ||
1685 | This tutorial is designed to be done in sequence. But the rest of this | |
1686 | manual does not assume you have gone through the tutorial. The tutorial | |
1687 | does not cover everything in the Calculator, but it touches on most | |
1688 | general areas. | |
1689 | ||
1690 | @ifinfo | |
1691 | You may wish to print out a copy of the Calc Summary and keep notes on | |
029b2a44 JB |
1692 | it as you learn Calc. @xref{About This Manual}, to see how to make a |
1693 | printed summary. @xref{Summary}. | |
d7b8e6c6 EZ |
1694 | @end ifinfo |
1695 | @iftex | |
1696 | The Calc Summary at the end of the reference manual includes some blank | |
1697 | space for your own use. You may wish to keep notes there as you learn | |
1698 | Calc. | |
1699 | @end iftex | |
1700 | ||
1701 | @menu | |
1702 | * Basic Tutorial:: | |
1703 | * Arithmetic Tutorial:: | |
1704 | * Vector/Matrix Tutorial:: | |
1705 | * Types Tutorial:: | |
1706 | * Algebra Tutorial:: | |
1707 | * Programming Tutorial:: | |
1708 | ||
1709 | * Answers to Exercises:: | |
1710 | @end menu | |
1711 | ||
1712 | @node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial | |
1713 | @section Basic Tutorial | |
1714 | ||
1715 | @noindent | |
1716 | In this section, we learn how RPN and algebraic-style calculations | |
1717 | work, how to undo and redo an operation done by mistake, and how | |
1718 | to control various modes of the Calculator. | |
1719 | ||
1720 | @menu | |
1721 | * RPN Tutorial:: Basic operations with the stack. | |
1722 | * Algebraic Tutorial:: Algebraic entry; variables. | |
1723 | * Undo Tutorial:: If you make a mistake: Undo and the trail. | |
1724 | * Modes Tutorial:: Common mode-setting commands. | |
1725 | @end menu | |
1726 | ||
1727 | @node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial | |
1728 | @subsection RPN Calculations and the Stack | |
1729 | ||
1730 | @cindex RPN notation | |
1731 | @ifinfo | |
1732 | @noindent | |
1733 | Calc normally uses RPN notation. You may be familiar with the RPN | |
1734 | system from Hewlett-Packard calculators, FORTH, or PostScript. | |
1735 | (Reverse Polish Notation, RPN, is named after the Polish mathematician | |
1736 | Jan Lukasiewicz.) | |
1737 | @end ifinfo | |
1738 | @tex | |
1739 | \noindent | |
1740 | Calc normally uses RPN notation. You may be familiar with the RPN | |
1741 | system from Hewlett-Packard calculators, FORTH, or PostScript. | |
1742 | (Reverse Polish Notation, RPN, is named after the Polish mathematician | |
1743 | Jan \L ukasiewicz.) | |
1744 | @end tex | |
1745 | ||
1746 | The central component of an RPN calculator is the @dfn{stack}. A | |
1747 | calculator stack is like a stack of dishes. New dishes (numbers) are | |
1748 | added at the top of the stack, and numbers are normally only removed | |
1749 | from the top of the stack. | |
1750 | ||
1751 | @cindex Operators | |
1752 | @cindex Operands | |
a4231b04 JB |
1753 | In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands} |
1754 | and the @expr{+} is the @dfn{operator}. In an RPN calculator you always | |
d7b8e6c6 EZ |
1755 | enter the operands first, then the operator. Each time you type a |
1756 | number, Calc adds or @dfn{pushes} it onto the top of the Stack. | |
1757 | When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate | |
1758 | number of operands from the stack and pushes back the result. | |
1759 | ||
1760 | Thus we could add the numbers 2 and 3 in an RPN calculator by typing: | |
1761 | @kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to | |
1762 | the @key{ENTER} key on traditional RPN calculators.) Try this now if | |
58547c3e JB |
1763 | you wish; type @kbd{C-x * c} to switch into the Calc window (you can type |
1764 | @kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window). | |
d7b8e6c6 EZ |
1765 | The first four keystrokes ``push'' the numbers 2 and 3 onto the stack. |
1766 | The @kbd{+} key ``pops'' the top two numbers from the stack, adds them, | |
1767 | and pushes the result (5) back onto the stack. Here's how the stack | |
a4231b04 | 1768 | will look at various points throughout the calculation: |
d7b8e6c6 | 1769 | |
d7b8e6c6 | 1770 | @smallexample |
5d67986c | 1771 | @group |
d7b8e6c6 EZ |
1772 | . 1: 2 2: 2 1: 5 . |
1773 | . 1: 3 . | |
1774 | . | |
1775 | ||
58547c3e | 1776 | C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL} |
d7b8e6c6 | 1777 | @end group |
5d67986c | 1778 | @end smallexample |
d7b8e6c6 EZ |
1779 | |
1780 | The @samp{.} symbol is a marker that represents the top of the stack. | |
1781 | Note that the ``top'' of the stack is really shown at the bottom of | |
1782 | the Stack window. This may seem backwards, but it turns out to be | |
1783 | less distracting in regular use. | |
1784 | ||
1785 | @cindex Stack levels | |
1786 | @cindex Levels of stack | |
1787 | The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level | |
1788 | numbers}. Old RPN calculators always had four stack levels called | |
a4231b04 | 1789 | @expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow |
d7b8e6c6 EZ |
1790 | as large as you like, so it uses numbers instead of letters. Some |
1791 | stack-manipulation commands accept a numeric argument that says | |
1792 | which stack level to work on. Normal commands like @kbd{+} always | |
a4231b04 | 1793 | work on the top few levels of the stack. |
d7b8e6c6 EZ |
1794 | |
1795 | @c [fix-ref Truncating the Stack] | |
1796 | The Stack buffer is just an Emacs buffer, and you can move around in | |
1797 | it using the regular Emacs motion commands. But no matter where the | |
1798 | cursor is, even if you have scrolled the @samp{.} marker out of | |
1799 | view, most Calc commands always move the cursor back down to level 1 | |
1800 | before doing anything. It is possible to move the @samp{.} marker | |
1801 | upwards through the stack, temporarily ``hiding'' some numbers from | |
1802 | commands like @kbd{+}. This is called @dfn{stack truncation} and | |
1803 | we will not cover it in this tutorial; @pxref{Truncating the Stack}, | |
1804 | if you are interested. | |
1805 | ||
1806 | You don't really need the second @key{RET} in @kbd{2 @key{RET} 3 | |
1807 | @key{RET} +}. That's because if you type any operator name or | |
1808 | other non-numeric key when you are entering a number, the Calculator | |
1809 | automatically enters that number and then does the requested command. | |
a4231b04 | 1810 | Thus @kbd{2 @key{RET} 3 +} will work just as well. |
d7b8e6c6 EZ |
1811 | |
1812 | Examples in this tutorial will often omit @key{RET} even when the | |
1813 | stack displays shown would only happen if you did press @key{RET}: | |
1814 | ||
d7b8e6c6 | 1815 | @smallexample |
5d67986c | 1816 | @group |
d7b8e6c6 EZ |
1817 | 1: 2 2: 2 1: 5 |
1818 | . 1: 3 . | |
1819 | . | |
1820 | ||
5d67986c | 1821 | 2 @key{RET} 3 + |
d7b8e6c6 | 1822 | @end group |
5d67986c | 1823 | @end smallexample |
d7b8e6c6 EZ |
1824 | |
1825 | @noindent | |
1826 | Here, after pressing @kbd{3} the stack would really show @samp{1: 2} | |
1827 | with @samp{Calc:@: 3} in the minibuffer. In these situations, you can | |
1828 | press the optional @key{RET} to see the stack as the figure shows. | |
1829 | ||
1830 | (@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises | |
1831 | at various points. Try them if you wish. Answers to all the exercises | |
1832 | are located at the end of the Tutorial chapter. Each exercise will | |
1833 | include a cross-reference to its particular answer. If you are | |
1834 | reading with the Emacs Info system, press @kbd{f} and the | |
1835 | exercise number to go to the answer, then the letter @kbd{l} to | |
1836 | return to where you were.) | |
1837 | ||
1838 | @noindent | |
1839 | Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2 | |
1840 | @key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for | |
1841 | multiplication.) Figure it out by hand, then try it with Calc to see | |
1842 | if you're right. @xref{RPN Answer 1, 1}. (@bullet{}) | |
1843 | ||
a4231b04 | 1844 | (@bullet{}) @strong{Exercise 2.} Compute |
8e04863e | 1845 | @texline @math{(2\times4) + (7\times9.4) + {5\over4}} |
a4231b04 JB |
1846 | @infoline @expr{2*4 + 7*9.5 + 5/4} |
1847 | using the stack. @xref{RPN Answer 2, 2}. (@bullet{}) | |
d7b8e6c6 EZ |
1848 | |
1849 | The @key{DEL} key is called Backspace on some keyboards. It is | |
1850 | whatever key you would use to correct a simple typing error when | |
1851 | regularly using Emacs. The @key{DEL} key pops and throws away the | |
1852 | top value on the stack. (You can still get that value back from | |
1853 | the Trail if you should need it later on.) There are many places | |
1854 | in this tutorial where we assume you have used @key{DEL} to erase the | |
1855 | results of the previous example at the beginning of a new example. | |
1856 | In the few places where it is really important to use @key{DEL} to | |
1857 | clear away old results, the text will remind you to do so. | |
1858 | ||
1859 | (It won't hurt to let things accumulate on the stack, except that | |
1860 | whenever you give a display-mode-changing command Calc will have to | |
1861 | spend a long time reformatting such a large stack.) | |
1862 | ||
1863 | Since the @kbd{-} key is also an operator (it subtracts the top two | |
1864 | stack elements), how does one enter a negative number? Calc uses | |
1865 | the @kbd{_} (underscore) key to act like the minus sign in a number. | |
1866 | So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key | |
1867 | will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine. | |
1868 | ||
1869 | You can also press @kbd{n}, which means ``change sign.'' It changes | |
1870 | the number at the top of the stack (or the number being entered) | |
1871 | from positive to negative or vice-versa: @kbd{5 n @key{RET}}. | |
1872 | ||
1873 | @cindex Duplicating a stack entry | |
1874 | If you press @key{RET} when you're not entering a number, the effect | |
1875 | is to duplicate the top number on the stack. Consider this calculation: | |
1876 | ||
d7b8e6c6 | 1877 | @smallexample |
5d67986c | 1878 | @group |
d7b8e6c6 EZ |
1879 | 1: 3 2: 3 1: 9 2: 9 1: 81 |
1880 | . 1: 3 . 1: 9 . | |
1881 | . . | |
1882 | ||
5d67986c | 1883 | 3 @key{RET} @key{RET} * @key{RET} * |
d7b8e6c6 | 1884 | @end group |
5d67986c | 1885 | @end smallexample |
d7b8e6c6 EZ |
1886 | |
1887 | @noindent | |
1888 | (Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^}, | |
1889 | to raise 3 to the fourth power.) | |
1890 | ||
1891 | The space-bar key (denoted @key{SPC} here) performs the same function | |
1892 | as @key{RET}; you could replace all three occurrences of @key{RET} in | |
1893 | the above example with @key{SPC} and the effect would be the same. | |
1894 | ||
1895 | @cindex Exchanging stack entries | |
1896 | Another stack manipulation key is @key{TAB}. This exchanges the top | |
1897 | two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +} | |
1898 | to get 5, and then you realize what you really wanted to compute | |
a4231b04 | 1899 | was @expr{20 / (2+3)}. |
d7b8e6c6 | 1900 | |
d7b8e6c6 | 1901 | @smallexample |
5d67986c | 1902 | @group |
d7b8e6c6 EZ |
1903 | 1: 5 2: 5 2: 20 1: 4 |
1904 | . 1: 20 1: 5 . | |
1905 | . . | |
1906 | ||
5d67986c | 1907 | 2 @key{RET} 3 + 20 @key{TAB} / |
d7b8e6c6 | 1908 | @end group |
5d67986c | 1909 | @end smallexample |
d7b8e6c6 EZ |
1910 | |
1911 | @noindent | |
1912 | Planning ahead, the calculation would have gone like this: | |
1913 | ||
d7b8e6c6 | 1914 | @smallexample |
5d67986c | 1915 | @group |
d7b8e6c6 EZ |
1916 | 1: 20 2: 20 3: 20 2: 20 1: 4 |
1917 | . 1: 2 2: 2 1: 5 . | |
1918 | . 1: 3 . | |
1919 | . | |
1920 | ||
5d67986c | 1921 | 20 @key{RET} 2 @key{RET} 3 + / |
d7b8e6c6 | 1922 | @end group |
5d67986c | 1923 | @end smallexample |
d7b8e6c6 EZ |
1924 | |
1925 | A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type | |
1926 | @key{TAB}). It rotates the top three elements of the stack upward, | |
1927 | bringing the object in level 3 to the top. | |
1928 | ||
d7b8e6c6 | 1929 | @smallexample |
5d67986c | 1930 | @group |
d7b8e6c6 EZ |
1931 | 1: 10 2: 10 3: 10 3: 20 3: 30 |
1932 | . 1: 20 2: 20 2: 30 2: 10 | |
1933 | . 1: 30 1: 10 1: 20 | |
1934 | . . . | |
1935 | ||
5d67986c | 1936 | 10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB} |
d7b8e6c6 | 1937 | @end group |
5d67986c | 1938 | @end smallexample |
d7b8e6c6 EZ |
1939 | |
1940 | (@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are | |
1941 | on the stack. Figure out how to add one to the number in level 2 | |
1942 | without affecting the rest of the stack. Also figure out how to add | |
1943 | one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{}) | |
1944 | ||
1945 | Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two | |
1946 | arguments from the stack and push a result. Operations like @kbd{n} and | |
1947 | @kbd{Q} (square root) pop a single number and push the result. You can | |
1948 | think of them as simply operating on the top element of the stack. | |
1949 | ||
d7b8e6c6 | 1950 | @smallexample |
5d67986c | 1951 | @group |
d7b8e6c6 EZ |
1952 | 1: 3 1: 9 2: 9 1: 25 1: 5 |
1953 | . . 1: 16 . . | |
1954 | . | |
1955 | ||
5d67986c | 1956 | 3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q |
d7b8e6c6 | 1957 | @end group |
5d67986c | 1958 | @end smallexample |
d7b8e6c6 EZ |
1959 | |
1960 | @noindent | |
1961 | (Note that capital @kbd{Q} means to hold down the Shift key while | |
1962 | typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.) | |
1963 | ||
1964 | @cindex Pythagorean Theorem | |
1965 | Here we've used the Pythagorean Theorem to determine the hypotenuse of a | |
1966 | right triangle. Calc actually has a built-in command for that called | |
1967 | @kbd{f h}, but let's suppose we can't remember the necessary keystrokes. | |
1968 | We can still enter it by its full name using @kbd{M-x} notation: | |
1969 | ||
d7b8e6c6 | 1970 | @smallexample |
5d67986c | 1971 | @group |
d7b8e6c6 EZ |
1972 | 1: 3 2: 3 1: 5 |
1973 | . 1: 4 . | |
1974 | . | |
1975 | ||
5d67986c | 1976 | 3 @key{RET} 4 @key{RET} M-x calc-hypot |
d7b8e6c6 | 1977 | @end group |
5d67986c | 1978 | @end smallexample |
d7b8e6c6 EZ |
1979 | |
1980 | All Calculator commands begin with the word @samp{calc-}. Since it | |
1981 | gets tiring to type this, Calc provides an @kbd{x} key which is just | |
1982 | like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-} | |
1983 | prefix for you: | |
1984 | ||
d7b8e6c6 | 1985 | @smallexample |
5d67986c | 1986 | @group |
d7b8e6c6 EZ |
1987 | 1: 3 2: 3 1: 5 |
1988 | . 1: 4 . | |
1989 | . | |
1990 | ||
5d67986c | 1991 | 3 @key{RET} 4 @key{RET} x hypot |
d7b8e6c6 | 1992 | @end group |
5d67986c | 1993 | @end smallexample |
d7b8e6c6 EZ |
1994 | |
1995 | What happens if you take the square root of a negative number? | |
1996 | ||
d7b8e6c6 | 1997 | @smallexample |
5d67986c | 1998 | @group |
d7b8e6c6 EZ |
1999 | 1: 4 1: -4 1: (0, 2) |
2000 | . . . | |
2001 | ||
5d67986c | 2002 | 4 @key{RET} n Q |
d7b8e6c6 | 2003 | @end group |
5d67986c | 2004 | @end smallexample |
d7b8e6c6 EZ |
2005 | |
2006 | @noindent | |
a4231b04 JB |
2007 | The notation @expr{(a, b)} represents a complex number. |
2008 | Complex numbers are more traditionally written @expr{a + b i}; | |
d7b8e6c6 | 2009 | Calc can display in this format, too, but for now we'll stick to the |
a4231b04 | 2010 | @expr{(a, b)} notation. |
d7b8e6c6 EZ |
2011 | |
2012 | If you don't know how complex numbers work, you can safely ignore this | |
2013 | feature. Complex numbers only arise from operations that would be | |
2014 | errors in a calculator that didn't have complex numbers. (For example, | |
2015 | taking the square root or logarithm of a negative number produces a | |
2016 | complex result.) | |
2017 | ||
2018 | Complex numbers are entered in the notation shown. The @kbd{(} and | |
2019 | @kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.'' | |
2020 | ||
d7b8e6c6 | 2021 | @smallexample |
5d67986c | 2022 | @group |
d7b8e6c6 EZ |
2023 | 1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3) |
2024 | . 1: 2 . 3 . | |
2025 | . . | |
2026 | ||
2027 | ( 2 , 3 ) | |
d7b8e6c6 | 2028 | @end group |
5d67986c | 2029 | @end smallexample |
d7b8e6c6 EZ |
2030 | |
2031 | You can perform calculations while entering parts of incomplete objects. | |
2032 | However, an incomplete object cannot actually participate in a calculation: | |
2033 | ||
d7b8e6c6 | 2034 | @smallexample |
5d67986c | 2035 | @group |
d7b8e6c6 EZ |
2036 | 1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ... |
2037 | . 1: 2 2: 2 5 5 | |
2038 | . 1: 3 . . | |
2039 | . | |
2040 | (error) | |
5d67986c | 2041 | ( 2 @key{RET} 3 + + |
d7b8e6c6 | 2042 | @end group |
5d67986c | 2043 | @end smallexample |
d7b8e6c6 EZ |
2044 | |
2045 | @noindent | |
2046 | Adding 5 to an incomplete object makes no sense, so the last command | |
2047 | produces an error message and leaves the stack the same. | |
2048 | ||
2049 | Incomplete objects can't participate in arithmetic, but they can be | |
2050 | moved around by the regular stack commands. | |
2051 | ||
d7b8e6c6 | 2052 | @smallexample |
5d67986c | 2053 | @group |
d7b8e6c6 EZ |
2054 | 2: 2 3: 2 3: 3 1: ( ... 1: (2, 3) |
2055 | 1: 3 2: 3 2: ( ... 2 . | |
2056 | . 1: ( ... 1: 2 3 | |
2057 | . . . | |
2058 | ||
5d67986c | 2059 | 2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} ) |
d7b8e6c6 | 2060 | @end group |
5d67986c | 2061 | @end smallexample |
d7b8e6c6 EZ |
2062 | |
2063 | @noindent | |
2064 | Note that the @kbd{,} (comma) key did not have to be used here. | |
2065 | When you press @kbd{)} all the stack entries between the incomplete | |
2066 | entry and the top are collected, so there's never really a reason | |
2067 | to use the comma. It's up to you. | |
2068 | ||
a4231b04 | 2069 | (@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)}, |
d7b8e6c6 EZ |
2070 | your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened? |
2071 | (Joe thought of a clever way to correct his mistake in only two | |
2072 | keystrokes, but it didn't quite work. Try it to find out why.) | |
2073 | @xref{RPN Answer 4, 4}. (@bullet{}) | |
2074 | ||
2075 | Vectors are entered the same way as complex numbers, but with square | |
2076 | brackets in place of parentheses. We'll meet vectors again later in | |
2077 | the tutorial. | |
2078 | ||
2079 | Any Emacs command can be given a @dfn{numeric prefix argument} by | |
2080 | typing a series of @key{META}-digits beforehand. If @key{META} is | |
2081 | awkward for you, you can instead type @kbd{C-u} followed by the | |
2082 | necessary digits. Numeric prefix arguments can be negative, as in | |
2083 | @kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric | |
2084 | prefix arguments in a variety of ways. For example, a numeric prefix | |
2085 | on the @kbd{+} operator adds any number of stack entries at once: | |
2086 | ||
d7b8e6c6 | 2087 | @smallexample |
5d67986c | 2088 | @group |
d7b8e6c6 EZ |
2089 | 1: 10 2: 10 3: 10 3: 10 1: 60 |
2090 | . 1: 20 2: 20 2: 20 . | |
2091 | . 1: 30 1: 30 | |
2092 | . . | |
2093 | ||
5d67986c | 2094 | 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 + |
d7b8e6c6 | 2095 | @end group |
5d67986c | 2096 | @end smallexample |
d7b8e6c6 EZ |
2097 | |
2098 | For stack manipulation commands like @key{RET}, a positive numeric | |
2099 | prefix argument operates on the top @var{n} stack entries at once. A | |
2100 | negative argument operates on the entry in level @var{n} only. An | |
2101 | argument of zero operates on the entire stack. In this example, we copy | |
2102 | the second-to-top element of the stack: | |
2103 | ||
d7b8e6c6 | 2104 | @smallexample |
5d67986c | 2105 | @group |
d7b8e6c6 EZ |
2106 | 1: 10 2: 10 3: 10 3: 10 4: 10 |
2107 | . 1: 20 2: 20 2: 20 3: 20 | |
2108 | . 1: 30 1: 30 2: 30 | |
2109 | . . 1: 20 | |
2110 | . | |
2111 | ||
5d67986c | 2112 | 10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET} |
d7b8e6c6 | 2113 | @end group |
5d67986c | 2114 | @end smallexample |
d7b8e6c6 EZ |
2115 | |
2116 | @cindex Clearing the stack | |
2117 | @cindex Emptying the stack | |
5d67986c | 2118 | Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack. |
d7b8e6c6 EZ |
2119 | (The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the |
2120 | entire stack.) | |
2121 | ||
2122 | @node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial | |
2123 | @subsection Algebraic-Style Calculations | |
2124 | ||
2125 | @noindent | |
2126 | If you are not used to RPN notation, you may prefer to operate the | |
07ce2eb3 JB |
2127 | Calculator in Algebraic mode, which is closer to the way |
2128 | non-RPN calculators work. In Algebraic mode, you enter formulas | |
a4231b04 | 2129 | in traditional @expr{2+3} notation. |
d7b8e6c6 EZ |
2130 | |
2131 | You don't really need any special ``mode'' to enter algebraic formulas. | |
2132 | You can enter a formula at any time by pressing the apostrophe (@kbd{'}) | |
2133 | key. Answer the prompt with the desired formula, then press @key{RET}. | |
2134 | The formula is evaluated and the result is pushed onto the RPN stack. | |
2135 | If you don't want to think in RPN at all, you can enter your whole | |
2136 | computation as a formula, read the result from the stack, then press | |
2137 | @key{DEL} to delete it from the stack. | |
2138 | ||
2139 | Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}. | |
2140 | The result should be the number 9. | |
2141 | ||
2142 | Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*}, | |
2143 | @samp{/}, and @samp{^}. You can use parentheses to make the order | |
2144 | of evaluation clear. In the absence of parentheses, @samp{^} is | |
2145 | evaluated first, then @samp{*}, then @samp{/}, then finally | |
2146 | @samp{+} and @samp{-}. For example, the expression | |
2147 | ||
2148 | @example | |
2149 | 2 + 3*4*5 / 6*7^8 - 9 | |
2150 | @end example | |
2151 | ||
2152 | @noindent | |
2153 | is equivalent to | |
2154 | ||
2155 | @example | |
2156 | 2 + ((3*4*5) / (6*(7^8)) - 9 | |
2157 | @end example | |
2158 | ||
2159 | @noindent | |
2160 | or, in large mathematical notation, | |
2161 | ||
2162 | @ifinfo | |
d7b8e6c6 | 2163 | @example |
5d67986c | 2164 | @group |
d7b8e6c6 EZ |
2165 | 3 * 4 * 5 |
2166 | 2 + --------- - 9 | |
2167 | 8 | |
2168 | 6 * 7 | |
d7b8e6c6 | 2169 | @end group |
5d67986c | 2170 | @end example |
d7b8e6c6 EZ |
2171 | @end ifinfo |
2172 | @tex | |
2173 | \turnoffactive | |
2174 | \beforedisplay | |
2175 | $$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$ | |
2176 | \afterdisplay | |
2177 | @end tex | |
2178 | ||
2179 | @noindent | |
8e04863e | 2180 | The result of this expression will be the number @mathit{-6.99999826533}. |
d7b8e6c6 EZ |
2181 | |
2182 | Calc's order of evaluation is the same as for most computer languages, | |
2183 | except that @samp{*} binds more strongly than @samp{/}, as the above | |
2184 | example shows. As in normal mathematical notation, the @samp{*} symbol | |
2185 | can often be omitted: @samp{2 a} is the same as @samp{2*a}. | |
2186 | ||
2187 | Operators at the same level are evaluated from left to right, except | |
2188 | that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is | |
8e04863e | 2189 | equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent |
d7b8e6c6 EZ |
2190 | to @samp{2^(3^4)} (a very large integer; try it!). |
2191 | ||
07ce2eb3 JB |
2192 | If you tire of typing the apostrophe all the time, there is |
2193 | Algebraic mode, where Calc automatically senses | |
d7b8e6c6 EZ |
2194 | when you are about to type an algebraic expression. To enter this |
2195 | mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator | |
2196 | should appear in the Calc window's mode line.) | |
2197 | ||
2198 | Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}. | |
2199 | ||
07ce2eb3 | 2200 | In Algebraic mode, when you press any key that would normally begin |
d7b8e6c6 EZ |
2201 | entering a number (such as a digit, a decimal point, or the @kbd{_} |
2202 | key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins | |
2203 | an algebraic entry. | |
2204 | ||
2205 | Functions which do not have operator symbols like @samp{+} and @samp{*} | |
2206 | must be entered in formulas using function-call notation. For example, | |
2207 | the function name corresponding to the square-root key @kbd{Q} is | |
2208 | @code{sqrt}. To compute a square root in a formula, you would use | |
2209 | the notation @samp{sqrt(@var{x})}. | |
2210 | ||
2211 | Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should | |
a4231b04 | 2212 | be @expr{0.16227766017}. |
d7b8e6c6 EZ |
2213 | |
2214 | Note that if the formula begins with a function name, you need to use | |
07ce2eb3 | 2215 | the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin} |
d7b8e6c6 EZ |
2216 | out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite |
2217 | command, and the @kbd{csin} will be taken as the name of the rewrite | |
2218 | rule to use! | |
2219 | ||
2220 | Some people prefer to enter complex numbers and vectors in algebraic | |
2221 | form because they find RPN entry with incomplete objects to be too | |
2222 | distracting, even though they otherwise use Calc as an RPN calculator. | |
2223 | ||
07ce2eb3 | 2224 | Still in Algebraic mode, type: |
d7b8e6c6 | 2225 | |
d7b8e6c6 | 2226 | @smallexample |
5d67986c | 2227 | @group |
d7b8e6c6 EZ |
2228 | 1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1) |
2229 | . 1: (1, -2) . 1: 1 . | |
2230 | . . | |
2231 | ||
5d67986c | 2232 | (2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} + |
d7b8e6c6 | 2233 | @end group |
5d67986c | 2234 | @end smallexample |
d7b8e6c6 EZ |
2235 | |
2236 | Algebraic mode allows us to enter complex numbers without pressing | |
2237 | an apostrophe first, but it also means we need to press @key{RET} | |
a4231b04 | 2238 | after every entry, even for a simple number like @expr{1}. |
d7b8e6c6 | 2239 | |
07ce2eb3 JB |
2240 | (You can type @kbd{C-u m a} to enable a special Incomplete Algebraic |
2241 | mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even | |
d7b8e6c6 | 2242 | though regular numeric keys still use RPN numeric entry. There is also |
07ce2eb3 | 2243 | Total Algebraic mode, started by typing @kbd{m t}, in which all |
d7b8e6c6 | 2244 | normal keys begin algebraic entry. You must then use the @key{META} key |
07ce2eb3 | 2245 | to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic |
bdfe3dc0 | 2246 | mode, @kbd{M-q} to quit, etc.) |
d7b8e6c6 | 2247 | |
07ce2eb3 | 2248 | If you're still in Algebraic mode, press @kbd{m a} again to turn it off. |
d7b8e6c6 EZ |
2249 | |
2250 | Actual non-RPN calculators use a mixture of algebraic and RPN styles. | |
2251 | In general, operators of two numbers (like @kbd{+} and @kbd{*}) | |
2252 | use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q}) | |
2253 | use RPN form. Also, a non-RPN calculator allows you to see the | |
2254 | intermediate results of a calculation as you go along. You can | |
2255 | accomplish this in Calc by performing your calculation as a series | |
2256 | of algebraic entries, using the @kbd{$} sign to tie them together. | |
2257 | In an algebraic formula, @kbd{$} represents the number on the top | |
a4231b04 | 2258 | of the stack. Here, we perform the calculation |
8e04863e | 2259 | @texline @math{\sqrt{2\times4+1}}, |
a4231b04 | 2260 | @infoline @expr{sqrt(2*4+1)}, |
d7b8e6c6 EZ |
2261 | which on a traditional calculator would be done by pressing |
2262 | @kbd{2 * 4 + 1 =} and then the square-root key. | |
2263 | ||
d7b8e6c6 | 2264 | @smallexample |
5d67986c | 2265 | @group |
d7b8e6c6 EZ |
2266 | 1: 8 1: 9 1: 3 |
2267 | . . . | |
2268 | ||
5d67986c | 2269 | ' 2*4 @key{RET} $+1 @key{RET} Q |
d7b8e6c6 | 2270 | @end group |
5d67986c | 2271 | @end smallexample |
d7b8e6c6 EZ |
2272 | |
2273 | @noindent | |
2274 | Notice that we didn't need to press an apostrophe for the @kbd{$+1}, | |
2275 | because the dollar sign always begins an algebraic entry. | |
2276 | ||
2277 | (@bullet{}) @strong{Exercise 1.} How could you get the same effect as | |
2278 | pressing @kbd{Q} but using an algebraic entry instead? How about | |
2279 | if the @kbd{Q} key on your keyboard were broken? | |
2280 | @xref{Algebraic Answer 1, 1}. (@bullet{}) | |
2281 | ||
2282 | The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack | |
5d67986c | 2283 | entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}. |
d7b8e6c6 EZ |
2284 | |
2285 | Algebraic formulas can include @dfn{variables}. To store in a | |
2286 | variable, press @kbd{s s}, then type the variable name, then press | |
2287 | @key{RET}. (There are actually two flavors of store command: | |
2288 | @kbd{s s} stores a number in a variable but also leaves the number | |
2289 | on the stack, while @w{@kbd{s t}} removes a number from the stack and | |
2290 | stores it in the variable.) A variable name should consist of one | |
2291 | or more letters or digits, beginning with a letter. | |
2292 | ||
d7b8e6c6 | 2293 | @smallexample |
5d67986c | 2294 | @group |
d7b8e6c6 EZ |
2295 | 1: 17 . 1: a + a^2 1: 306 |
2296 | . . . | |
2297 | ||
5d67986c | 2298 | 17 s t a @key{RET} ' a+a^2 @key{RET} = |
d7b8e6c6 | 2299 | @end group |
5d67986c | 2300 | @end smallexample |
d7b8e6c6 EZ |
2301 | |
2302 | @noindent | |
2303 | The @kbd{=} key @dfn{evaluates} a formula by replacing all its | |
2304 | variables by the values that were stored in them. | |
2305 | ||
2306 | For RPN calculations, you can recall a variable's value on the | |
2307 | stack either by entering its name as a formula and pressing @kbd{=}, | |
2308 | or by using the @kbd{s r} command. | |
2309 | ||
d7b8e6c6 | 2310 | @smallexample |
5d67986c | 2311 | @group |
d7b8e6c6 EZ |
2312 | 1: 17 2: 17 3: 17 2: 17 1: 306 |
2313 | . 1: 17 2: 17 1: 289 . | |
2314 | . 1: 2 . | |
2315 | . | |
2316 | ||
5d67986c | 2317 | s r a @key{RET} ' a @key{RET} = 2 ^ + |
d7b8e6c6 | 2318 | @end group |
5d67986c | 2319 | @end smallexample |
d7b8e6c6 EZ |
2320 | |
2321 | If you press a single digit for a variable name (as in @kbd{s t 3}, you | |
2322 | get one of ten @dfn{quick variables} @code{q0} through @code{q9}. | |
2323 | They are ``quick'' simply because you don't have to type the letter | |
2324 | @code{q} or the @key{RET} after their names. In fact, you can type | |
2325 | simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for | |
2326 | @kbd{t 3} and @w{@kbd{r 3}}. | |
2327 | ||
2328 | Any variables in an algebraic formula for which you have not stored | |
2329 | values are left alone, even when you evaluate the formula. | |
2330 | ||
d7b8e6c6 | 2331 | @smallexample |
5d67986c | 2332 | @group |
d7b8e6c6 EZ |
2333 | 1: 2 a + 2 b 1: 34 + 2 b |
2334 | . . | |
2335 | ||
5d67986c | 2336 | ' 2a+2b @key{RET} = |
d7b8e6c6 | 2337 | @end group |
5d67986c | 2338 | @end smallexample |
d7b8e6c6 EZ |
2339 | |
2340 | Calls to function names which are undefined in Calc are also left | |
2341 | alone, as are calls for which the value is undefined. | |
2342 | ||
d7b8e6c6 | 2343 | @smallexample |
5d67986c | 2344 | @group |
d7b8e6c6 EZ |
2345 | 1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3) |
2346 | . | |
2347 | ||
5d67986c | 2348 | ' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET} |
d7b8e6c6 | 2349 | @end group |
5d67986c | 2350 | @end smallexample |
d7b8e6c6 EZ |
2351 | |
2352 | @noindent | |
2353 | In this example, the first call to @code{log10} works, but the other | |
2354 | calls are not evaluated. In the second call, the logarithm is | |
2355 | undefined for that value of the argument; in the third, the argument | |
2356 | is symbolic, and in the fourth, there are too many arguments. In the | |
2357 | fifth case, there is no function called @code{foo}. You will see a | |
2358 | ``Wrong number of arguments'' message referring to @samp{log10(5,6)}. | |
2359 | Press the @kbd{w} (``why'') key to see any other messages that may | |
2360 | have arisen from the last calculation. In this case you will get | |
2361 | ``logarithm of zero,'' then ``number expected: @code{x}''. Calc | |
2362 | automatically displays the first message only if the message is | |
2363 | sufficiently important; for example, Calc considers ``wrong number | |
2364 | of arguments'' and ``logarithm of zero'' to be important enough to | |
2365 | report automatically, while a message like ``number expected: @code{x}'' | |
2366 | will only show up if you explicitly press the @kbd{w} key. | |
2367 | ||
2368 | (@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y}, | |
2369 | stored 5 in @code{x}, pressed @kbd{=}, and got the expected result, | |
2370 | @samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)}, | |
2371 | expecting @samp{10 (1+y)}, but it didn't work. Why not? | |
2372 | @xref{Algebraic Answer 2, 2}. (@bullet{}) | |
2373 | ||
2374 | (@bullet{}) @strong{Exercise 3.} What result would you expect | |
2375 | @kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}? | |
2376 | @xref{Algebraic Answer 3, 3}. (@bullet{}) | |
2377 | ||
2378 | One interesting way to work with variables is to use the | |
2379 | @dfn{evaluates-to} (@samp{=>}) operator. It works like this: | |
2380 | Enter a formula algebraically in the usual way, but follow | |
2381 | the formula with an @samp{=>} symbol. (There is also an @kbd{s =} | |
2382 | command which builds an @samp{=>} formula using the stack.) On | |
2383 | the stack, you will see two copies of the formula with an @samp{=>} | |
2384 | between them. The lefthand formula is exactly like you typed it; | |
2385 | the righthand formula has been evaluated as if by typing @kbd{=}. | |
2386 | ||
d7b8e6c6 | 2387 | @smallexample |
5d67986c | 2388 | @group |
d7b8e6c6 EZ |
2389 | 2: 2 + 3 => 5 2: 2 + 3 => 5 |
2390 | 1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b | |
2391 | . . | |
2392 | ||
5d67986c | 2393 | ' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET} |
d7b8e6c6 | 2394 | @end group |
5d67986c | 2395 | @end smallexample |
d7b8e6c6 EZ |
2396 | |
2397 | @noindent | |
2398 | Notice that the instant we stored a new value in @code{a}, all | |
a4231b04 | 2399 | @samp{=>} operators already on the stack that referred to @expr{a} |
d7b8e6c6 EZ |
2400 | were updated to use the new value. With @samp{=>}, you can push a |
2401 | set of formulas on the stack, then change the variables experimentally | |
2402 | to see the effects on the formulas' values. | |
2403 | ||
2404 | You can also ``unstore'' a variable when you are through with it: | |
2405 | ||
d7b8e6c6 | 2406 | @smallexample |
5d67986c | 2407 | @group |
d7b8e6c6 EZ |
2408 | 2: 2 + 5 => 5 |
2409 | 1: 2 a + 2 b => 2 a + 2 b | |
2410 | . | |
2411 | ||
5d67986c | 2412 | s u a @key{RET} |
d7b8e6c6 | 2413 | @end group |
5d67986c | 2414 | @end smallexample |
d7b8e6c6 EZ |
2415 | |
2416 | We will encounter formulas involving variables and functions again | |
2417 | when we discuss the algebra and calculus features of the Calculator. | |
2418 | ||
2419 | @node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial | |
2420 | @subsection Undo and Redo | |
2421 | ||
2422 | @noindent | |
2423 | If you make a mistake, you can usually correct it by pressing shift-@kbd{U}, | |
5d67986c | 2424 | the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit |
58547c3e | 2425 | and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off |
d7b8e6c6 EZ |
2426 | with a clean slate. Now: |
2427 | ||
d7b8e6c6 | 2428 | @smallexample |
5d67986c | 2429 | @group |
d7b8e6c6 EZ |
2430 | 1: 2 2: 2 1: 8 2: 2 1: 6 |
2431 | . 1: 3 . 1: 3 . | |
2432 | . . | |
2433 | ||
5d67986c | 2434 | 2 @key{RET} 3 ^ U * |
d7b8e6c6 | 2435 | @end group |
5d67986c | 2436 | @end smallexample |
d7b8e6c6 EZ |
2437 | |
2438 | You can undo any number of times. Calc keeps a complete record of | |
2439 | all you have done since you last opened the Calc window. After the | |
2440 | above example, you could type: | |
2441 | ||
d7b8e6c6 | 2442 | @smallexample |
5d67986c | 2443 | @group |
d7b8e6c6 EZ |
2444 | 1: 6 2: 2 1: 2 . . |
2445 | . 1: 3 . | |
2446 | . | |
2447 | (error) | |
2448 | U U U U | |
d7b8e6c6 | 2449 | @end group |
5d67986c | 2450 | @end smallexample |
d7b8e6c6 EZ |
2451 | |
2452 | You can also type @kbd{D} to ``redo'' a command that you have undone | |
2453 | mistakenly. | |
2454 | ||
d7b8e6c6 | 2455 | @smallexample |
5d67986c | 2456 | @group |
d7b8e6c6 EZ |
2457 | . 1: 2 2: 2 1: 6 1: 6 |
2458 | . 1: 3 . . | |
2459 | . | |
2460 | (error) | |
2461 | D D D D | |
d7b8e6c6 | 2462 | @end group |
5d67986c | 2463 | @end smallexample |
d7b8e6c6 EZ |
2464 | |
2465 | @noindent | |
a4231b04 | 2466 | It was not possible to redo past the @expr{6}, since that was placed there |
d7b8e6c6 EZ |
2467 | by something other than an undo command. |
2468 | ||
2469 | @cindex Time travel | |
2470 | You can think of undo and redo as a sort of ``time machine.'' Press | |
2471 | @kbd{U} to go backward in time, @kbd{D} to go forward. If you go | |
2472 | backward and do something (like @kbd{*}) then, as any science fiction | |
2473 | reader knows, you have changed your future and you cannot go forward | |
a4231b04 | 2474 | again. Thus, the inability to redo past the @expr{6} even though there |
d7b8e6c6 EZ |
2475 | was an earlier undo command. |
2476 | ||
2477 | You can always recall an earlier result using the Trail. We've ignored | |
2478 | the trail so far, but it has been faithfully recording everything we | |
2479 | did since we loaded the Calculator. If the Trail is not displayed, | |
2480 | press @kbd{t d} now to turn it on. | |
2481 | ||
a4231b04 | 2482 | Let's try grabbing an earlier result. The @expr{8} we computed was |
d7b8e6c6 EZ |
2483 | undone by a @kbd{U} command, and was lost even to Redo when we pressed |
2484 | @kbd{*}, but it's still there in the trail. There should be a little | |
2485 | @samp{>} arrow (the @dfn{trail pointer}) resting on the last trail | |
2486 | entry. If there isn't, press @kbd{t ]} to reset the trail pointer. | |
2487 | Now, press @w{@kbd{t p}} to move the arrow onto the line containing | |
a4231b04 | 2488 | @expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the |
d7b8e6c6 EZ |
2489 | stack. |
2490 | ||
2491 | If you press @kbd{t ]} again, you will see that even our Yank command | |
2492 | went into the trail. | |
2493 | ||
2494 | Let's go further back in time. Earlier in the tutorial we computed | |
2495 | a huge integer using the formula @samp{2^3^4}. We don't remember | |
2496 | what it was, but the first digits were ``241''. Press @kbd{t r} | |
2497 | (which stands for trail-search-reverse), then type @kbd{241}. | |
2498 | The trail cursor will jump back to the next previous occurrence of | |
2499 | the string ``241'' in the trail. This is just a regular Emacs | |
2500 | incremental search; you can now press @kbd{C-s} or @kbd{C-r} to | |
2501 | continue the search forwards or backwards as you like. | |
2502 | ||
2503 | To finish the search, press @key{RET}. This halts the incremental | |
2504 | search and leaves the trail pointer at the thing we found. Now we | |
2505 | can type @kbd{t y} to yank that number onto the stack. If we hadn't | |
2506 | remembered the ``241'', we could simply have searched for @kbd{2^3^4}, | |
2507 | then pressed @kbd{@key{RET} t n} to halt and then move to the next item. | |
2508 | ||
2509 | You may have noticed that all the trail-related commands begin with | |
2510 | the letter @kbd{t}. (The store-and-recall commands, on the other hand, | |
2511 | all began with @kbd{s}.) Calc has so many commands that there aren't | |
2512 | enough keys for all of them, so various commands are grouped into | |
2513 | two-letter sequences where the first letter is called the @dfn{prefix} | |
2514 | key. If you type a prefix key by accident, you can press @kbd{C-g} | |
2515 | to cancel it. (In fact, you can press @kbd{C-g} to cancel almost | |
2516 | anything in Emacs.) To get help on a prefix key, press that key | |
2517 | followed by @kbd{?}. Some prefixes have several lines of help, | |
a4338f51 JB |
2518 | so you need to press @kbd{?} repeatedly to see them all. |
2519 | You can also type @kbd{h h} to see all the help at once. | |
d7b8e6c6 EZ |
2520 | |
2521 | Try pressing @kbd{t ?} now. You will see a line of the form, | |
2522 | ||
2523 | @smallexample | |
2524 | trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t- | |
2525 | @end smallexample | |
2526 | ||
2527 | @noindent | |
2528 | The word ``trail'' indicates that the @kbd{t} prefix key contains | |
2529 | trail-related commands. Each entry on the line shows one command, | |
2530 | with a single capital letter showing which letter you press to get | |
2531 | that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and | |
2532 | @kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?} | |
28665d46 | 2533 | again to see more @kbd{t}-prefix commands. Notice that the commands |
d7b8e6c6 EZ |
2534 | are roughly divided (by semicolons) into related groups. |
2535 | ||
2536 | When you are in the help display for a prefix key, the prefix is | |
2537 | still active. If you press another key, like @kbd{y} for example, | |
2538 | it will be interpreted as a @kbd{t y} command. If all you wanted | |
2539 | was to look at the help messages, press @kbd{C-g} afterwards to cancel | |
2540 | the prefix. | |
2541 | ||
2542 | One more way to correct an error is by editing the stack entries. | |
2543 | The actual Stack buffer is marked read-only and must not be edited | |
2544 | directly, but you can press @kbd{`} (the backquote or accent grave) | |
2545 | to edit a stack entry. | |
2546 | ||
2547 | Try entering @samp{3.141439} now. If this is supposed to represent | |
a4231b04 | 2548 | @cpi{}, it's got several errors. Press @kbd{`} to edit this number. |
d7b8e6c6 EZ |
2549 | Now use the normal Emacs cursor motion and editing keys to change |
2550 | the second 4 to a 5, and to transpose the 3 and the 9. When you | |
2551 | press @key{RET}, the number on the stack will be replaced by your | |
2552 | new number. This works for formulas, vectors, and all other types | |
2553 | of values you can put on the stack. The @kbd{`} key also works | |
2554 | during entry of a number or algebraic formula. | |
2555 | ||
2556 | @node Modes Tutorial, , Undo Tutorial, Basic Tutorial | |
2557 | @subsection Mode-Setting Commands | |
2558 | ||
2559 | @noindent | |
2560 | Calc has many types of @dfn{modes} that affect the way it interprets | |
2561 | your commands or the way it displays data. We have already seen one | |
07ce2eb3 | 2562 | mode, namely Algebraic mode. There are many others, too; we'll |
d7b8e6c6 EZ |
2563 | try some of the most common ones here. |
2564 | ||
2565 | Perhaps the most fundamental mode in Calc is the current @dfn{precision}. | |
2566 | Notice the @samp{12} on the Calc window's mode line: | |
2567 | ||
2568 | @smallexample | |
2569 | --%%-Calc: 12 Deg (Calculator)----All------ | |
2570 | @end smallexample | |
2571 | ||
2572 | @noindent | |
2573 | Most of the symbols there are Emacs things you don't need to worry | |
2574 | about, but the @samp{12} and the @samp{Deg} are mode indicators. | |
2575 | The @samp{12} means that calculations should always be carried to | |
2576 | 12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /}, | |
a4231b04 | 2577 | we get @expr{0.142857142857} with exactly 12 digits, not counting |
d7b8e6c6 EZ |
2578 | leading and trailing zeros. |
2579 | ||
2580 | You can set the precision to anything you like by pressing @kbd{p}, | |
2581 | then entering a suitable number. Try pressing @kbd{p 30 @key{RET}}, | |
2582 | then doing @kbd{1 @key{RET} 7 /} again: | |
2583 | ||
d7b8e6c6 | 2584 | @smallexample |
5d67986c | 2585 | @group |
d7b8e6c6 EZ |
2586 | 1: 0.142857142857 |
2587 | 2: 0.142857142857142857142857142857 | |
2588 | . | |
d7b8e6c6 | 2589 | @end group |
5d67986c | 2590 | @end smallexample |
d7b8e6c6 EZ |
2591 | |
2592 | Although the precision can be set arbitrarily high, Calc always | |
2593 | has to have @emph{some} value for the current precision. After | |
a4231b04 | 2594 | all, the true value @expr{1/7} is an infinitely repeating decimal; |
d7b8e6c6 EZ |
2595 | Calc has to stop somewhere. |
2596 | ||
2597 | Of course, calculations are slower the more digits you request. | |
2598 | Press @w{@kbd{p 12}} now to set the precision back down to the default. | |
2599 | ||
2600 | Calculations always use the current precision. For example, even | |
a4231b04 | 2601 | though we have a 30-digit value for @expr{1/7} on the stack, if |
d7b8e6c6 EZ |
2602 | we use it in a calculation in 12-digit mode it will be rounded |
2603 | down to 12 digits before it is used. Try it; press @key{RET} to | |
2604 | duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET} | |
2605 | key didn't round the number, because it doesn't do any calculation. | |
2606 | But the instant we pressed @kbd{+}, the number was rounded down. | |
2607 | ||
d7b8e6c6 | 2608 | @smallexample |
5d67986c | 2609 | @group |
d7b8e6c6 EZ |
2610 | 1: 0.142857142857 |
2611 | 2: 0.142857142857142857142857142857 | |
2612 | 3: 1.14285714286 | |
2613 | . | |
d7b8e6c6 | 2614 | @end group |
5d67986c | 2615 | @end smallexample |
d7b8e6c6 EZ |
2616 | |
2617 | @noindent | |
2618 | In fact, since we added a digit on the left, we had to lose one | |
a4231b04 | 2619 | digit on the right from even the 12-digit value of @expr{1/7}. |
d7b8e6c6 EZ |
2620 | |
2621 | How did we get more than 12 digits when we computed @samp{2^3^4}? The | |
2622 | answer is that Calc makes a distinction between @dfn{integers} and | |
2623 | @dfn{floating-point} numbers, or @dfn{floats}. An integer is a number | |
2624 | that does not contain a decimal point. There is no such thing as an | |
2625 | ``infinitely repeating fraction integer,'' so Calc doesn't have to limit | |
2626 | itself. If you asked for @samp{2^10000} (don't try this!), you would | |
2627 | have to wait a long time but you would eventually get an exact answer. | |
2628 | If you ask for @samp{2.^10000}, you will quickly get an answer which is | |
2629 | correct only to 12 places. The decimal point tells Calc that it should | |
2630 | use floating-point arithmetic to get the answer, not exact integer | |
2631 | arithmetic. | |
2632 | ||
2633 | You can use the @kbd{F} (@code{calc-floor}) command to convert a | |
2634 | floating-point value to an integer, and @kbd{c f} (@code{calc-float}) | |
2635 | to convert an integer to floating-point form. | |
2636 | ||
2637 | Let's try entering that last calculation: | |
2638 | ||
d7b8e6c6 | 2639 | @smallexample |
5d67986c | 2640 | @group |
d7b8e6c6 EZ |
2641 | 1: 2. 2: 2. 1: 1.99506311689e3010 |
2642 | . 1: 10000 . | |
2643 | . | |
2644 | ||
5d67986c | 2645 | 2.0 @key{RET} 10000 @key{RET} ^ |
d7b8e6c6 | 2646 | @end group |
5d67986c | 2647 | @end smallexample |
d7b8e6c6 EZ |
2648 | |
2649 | @noindent | |
2650 | @cindex Scientific notation, entry of | |
2651 | Notice the letter @samp{e} in there. It represents ``times ten to the | |
2652 | power of,'' and is used by Calc automatically whenever writing the | |
2653 | number out fully would introduce more extra zeros than you probably | |
2654 | want to see. You can enter numbers in this notation, too. | |
2655 | ||
d7b8e6c6 | 2656 | @smallexample |
5d67986c | 2657 | @group |
d7b8e6c6 EZ |
2658 | 1: 2. 2: 2. 1: 1.99506311678e3010 |
2659 | . 1: 10000. . | |
2660 | . | |
2661 | ||
5d67986c | 2662 | 2.0 @key{RET} 1e4 @key{RET} ^ |
d7b8e6c6 | 2663 | @end group |
5d67986c | 2664 | @end smallexample |
d7b8e6c6 EZ |
2665 | |
2666 | @cindex Round-off errors | |
2667 | @noindent | |
2668 | Hey, the answer is different! Look closely at the middle columns | |
2669 | of the two examples. In the first, the stack contained the | |
a4231b04 | 2670 | exact integer @expr{10000}, but in the second it contained |
d7b8e6c6 EZ |
2671 | a floating-point value with a decimal point. When you raise a |
2672 | number to an integer power, Calc uses repeated squaring and | |
2673 | multiplication to get the answer. When you use a floating-point | |
2674 | power, Calc uses logarithms and exponentials. As you can see, | |
2675 | a slight error crept in during one of these methods. Which | |
2676 | one should we trust? Let's raise the precision a bit and find | |
2677 | out: | |
2678 | ||
d7b8e6c6 | 2679 | @smallexample |
5d67986c | 2680 | @group |
d7b8e6c6 EZ |
2681 | . 1: 2. 2: 2. 1: 1.995063116880828e3010 |
2682 | . 1: 10000. . | |
2683 | . | |
2684 | ||
5d67986c | 2685 | p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET} |
d7b8e6c6 | 2686 | @end group |
5d67986c | 2687 | @end smallexample |
d7b8e6c6 EZ |
2688 | |
2689 | @noindent | |
2690 | @cindex Guard digits | |
2691 | Presumably, it doesn't matter whether we do this higher-precision | |
2692 | calculation using an integer or floating-point power, since we | |
2693 | have added enough ``guard digits'' to trust the first 12 digits | |
2694 | no matter what. And the verdict is@dots{} Integer powers were more | |
2695 | accurate; in fact, the result was only off by one unit in the | |
2696 | last place. | |
2697 | ||
2698 | @cindex Guard digits | |
2699 | Calc does many of its internal calculations to a slightly higher | |
2700 | precision, but it doesn't always bump the precision up enough. | |
2701 | In each case, Calc added about two digits of precision during | |
2702 | its calculation and then rounded back down to 12 digits | |
269b7745 | 2703 | afterward. In one case, it was enough; in the other, it |
d7b8e6c6 EZ |
2704 | wasn't. If you really need @var{x} digits of precision, it |
2705 | never hurts to do the calculation with a few extra guard digits. | |
2706 | ||
2707 | What if we want guard digits but don't want to look at them? | |
2708 | We can set the @dfn{float format}. Calc supports four major | |
2709 | formats for floating-point numbers, called @dfn{normal}, | |
2710 | @dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering | |
2711 | notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f}, | |
2712 | @kbd{d s}, and @kbd{d e}, respectively. In each case, you can | |
2713 | supply a numeric prefix argument which says how many digits | |
2714 | should be displayed. As an example, let's put a few numbers | |
2715 | onto the stack and try some different display modes. First, | |
5d67986c | 2716 | use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four |
d7b8e6c6 EZ |
2717 | numbers shown here: |
2718 | ||
d7b8e6c6 | 2719 | @smallexample |
5d67986c | 2720 | @group |
d7b8e6c6 EZ |
2721 | 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345 |
2722 | 3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000 | |
2723 | 2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450 | |
2724 | 1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345 | |
2725 | . . . . . | |
2726 | ||
2727 | d n M-3 d n d s M-3 d s M-3 d f | |
d7b8e6c6 | 2728 | @end group |
5d67986c | 2729 | @end smallexample |
d7b8e6c6 EZ |
2730 | |
2731 | @noindent | |
2732 | Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down | |
2733 | to three significant digits, but then when we typed @kbd{d s} all | |
2734 | five significant figures reappeared. The float format does not | |
2735 | affect how numbers are stored, it only affects how they are | |
2736 | displayed. Only the current precision governs the actual rounding | |
2737 | of numbers in the Calculator's memory. | |
2738 | ||
2739 | Engineering notation, not shown here, is like scientific notation | |
2740 | except the exponent (the power-of-ten part) is always adjusted to be | |
2741 | a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result | |
2742 | there will be one, two, or three digits before the decimal point. | |
2743 | ||
2744 | Whenever you change a display-related mode, Calc redraws everything | |
2745 | in the stack. This may be slow if there are many things on the stack, | |
2746 | so Calc allows you to type shift-@kbd{H} before any mode command to | |
2747 | prevent it from updating the stack. Anything Calc displays after the | |
2748 | mode-changing command will appear in the new format. | |
2749 | ||
d7b8e6c6 | 2750 | @smallexample |
5d67986c | 2751 | @group |
d7b8e6c6 EZ |
2752 | 4: 12345 4: 12345 4: 12345 4: 12345 4: 12345 |
2753 | 3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345. | |
2754 | 2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45 | |
2755 | 1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345 | |
2756 | . . . . . | |
2757 | ||
5d67986c | 2758 | H d s @key{DEL} U @key{TAB} d @key{SPC} d n |
d7b8e6c6 | 2759 | @end group |
5d67986c | 2760 | @end smallexample |
d7b8e6c6 EZ |
2761 | |
2762 | @noindent | |
2763 | Here the @kbd{H d s} command changes to scientific notation but without | |
2764 | updating the screen. Deleting the top stack entry and undoing it back | |
2765 | causes it to show up in the new format; swapping the top two stack | |
5d67986c | 2766 | entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the |
d7b8e6c6 EZ |
2767 | whole stack. The @kbd{d n} command changes back to the normal float |
2768 | format; since it doesn't have an @kbd{H} prefix, it also updates all | |
2769 | the stack entries to be in @kbd{d n} format. | |
2770 | ||
a4231b04 | 2771 | Notice that the integer @expr{12345} was not affected by any |
d7b8e6c6 EZ |
2772 | of the float formats. Integers are integers, and are always |
2773 | displayed exactly. | |
2774 | ||
2775 | @cindex Large numbers, readability | |
2776 | Large integers have their own problems. Let's look back at | |
2777 | the result of @kbd{2^3^4}. | |
2778 | ||
2779 | @example | |
2780 | 2417851639229258349412352 | |
2781 | @end example | |
2782 | ||
2783 | @noindent | |
2784 | Quick---how many digits does this have? Try typing @kbd{d g}: | |
2785 | ||
2786 | @example | |
2787 | 2,417,851,639,229,258,349,412,352 | |
2788 | @end example | |
2789 | ||
2790 | @noindent | |
2791 | Now how many digits does this have? It's much easier to tell! | |
2792 | We can actually group digits into clumps of any size. Some | |
2793 | people prefer @kbd{M-5 d g}: | |
2794 | ||
2795 | @example | |
2796 | 24178,51639,22925,83494,12352 | |
2797 | @end example | |
2798 | ||
2799 | Let's see what happens to floating-point numbers when they are grouped. | |
2800 | First, type @kbd{p 25 @key{RET}} to make sure we have enough precision | |
2801 | to get ourselves into trouble. Now, type @kbd{1e13 /}: | |
2802 | ||
2803 | @example | |
2804 | 24,17851,63922.9258349412352 | |
2805 | @end example | |
2806 | ||
2807 | @noindent | |
2808 | The integer part is grouped but the fractional part isn't. Now try | |
2809 | @kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five): | |
2810 | ||
2811 | @example | |
2812 | 24,17851,63922.92583,49412,352 | |
2813 | @end example | |
2814 | ||
2815 | If you find it hard to tell the decimal point from the commas, try | |
2816 | changing the grouping character to a space with @kbd{d , @key{SPC}}: | |
2817 | ||
2818 | @example | |
2819 | 24 17851 63922.92583 49412 352 | |
2820 | @end example | |
2821 | ||
2822 | Type @kbd{d , ,} to restore the normal grouping character, then | |
2823 | @kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to | |
2824 | restore the default precision. | |
2825 | ||
2826 | Press @kbd{U} enough times to get the original big integer back. | |
2827 | (Notice that @kbd{U} does not undo each mode-setting command; if | |
2828 | you want to undo a mode-setting command, you have to do it yourself.) | |
2829 | Now, type @kbd{d r 16 @key{RET}}: | |
2830 | ||
2831 | @example | |
2832 | 16#200000000000000000000 | |
2833 | @end example | |
2834 | ||
2835 | @noindent | |
2836 | The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form. | |
2837 | Suddenly it looks pretty simple; this should be no surprise, since we | |
2838 | got this number by computing a power of two, and 16 is a power of 2. | |
2839 | In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary | |
2840 | form: | |
2841 | ||
2842 | @example | |
2843 | 2#1000000000000000000000000000000000000000000000000000000 @dots{} | |
2844 | @end example | |
2845 | ||
2846 | @noindent | |
2847 | We don't have enough space here to show all the zeros! They won't | |
2848 | fit on a typical screen, either, so you will have to use horizontal | |
2849 | scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the | |
2850 | stack window left and right by half its width. Another way to view | |
2851 | something large is to press @kbd{`} (back-quote) to edit the top of | |
33108698 | 2852 | stack in a separate window. (Press @kbd{C-c C-c} when you are done.) |
d7b8e6c6 EZ |
2853 | |
2854 | You can enter non-decimal numbers using the @kbd{#} symbol, too. | |
2855 | Let's see what the hexadecimal number @samp{5FE} looks like in | |
2856 | binary. Type @kbd{16#5FE} (the letters can be typed in upper or | |
2857 | lower case; they will always appear in upper case). It will also | |
2858 | help to turn grouping on with @kbd{d g}: | |
2859 | ||
2860 | @example | |
2861 | 2#101,1111,1110 | |
2862 | @end example | |
2863 | ||
2864 | Notice that @kbd{d g} groups by fours by default if the display radix | |
2865 | is binary or hexadecimal, but by threes if it is decimal, octal, or any | |
2866 | other radix. | |
2867 | ||
2868 | Now let's see that number in decimal; type @kbd{d r 10}: | |
2869 | ||
2870 | @example | |
2871 | 1,534 | |
2872 | @end example | |
2873 | ||
2874 | Numbers are not @emph{stored} with any particular radix attached. They're | |
2875 | just numbers; they can be entered in any radix, and are always displayed | |
2876 | in whatever radix you've chosen with @kbd{d r}. The current radix applies | |
2877 | to integers, fractions, and floats. | |
2878 | ||
2879 | @cindex Roundoff errors, in non-decimal numbers | |
2880 | (@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third | |
2881 | as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got | |
2882 | @samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied | |
2883 | that by three, he got @samp{3#0.222222...} instead of the expected | |
2884 | @samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief, | |
2885 | saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got | |
2886 | @samp{3#0.10000001} (some zeros omitted). What's going on here? | |
2887 | @xref{Modes Answer 1, 1}. (@bullet{}) | |
2888 | ||
2889 | @cindex Scientific notation, in non-decimal numbers | |
2890 | (@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal | |
2891 | modes in the natural way (the exponent is a power of the radix instead of | |
2892 | a power of ten, although the exponent itself is always written in decimal). | |
2893 | Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number | |
2894 | @samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}. | |
2895 | What is wrong with this picture? What could we write instead that would | |
2896 | work better? @xref{Modes Answer 2, 2}. (@bullet{}) | |
2897 | ||
2898 | The @kbd{m} prefix key has another set of modes, relating to the way | |
2899 | Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix | |
2900 | modes generally affect the way things look, @kbd{m}-prefix modes affect | |
2901 | the way they are actually computed. | |
2902 | ||
2903 | The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice | |
2904 | the @samp{Deg} indicator in the mode line. This means that if you use | |
2905 | a command that interprets a number as an angle, it will assume the | |
2906 | angle is measured in degrees. For example, | |
2907 | ||
d7b8e6c6 | 2908 | @smallexample |
5d67986c | 2909 | @group |
d7b8e6c6 EZ |
2910 | 1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5 |
2911 | . . . . | |
2912 | ||
2913 | 45 S 2 ^ c 1 | |
d7b8e6c6 | 2914 | @end group |
5d67986c | 2915 | @end smallexample |
d7b8e6c6 EZ |
2916 | |
2917 | @noindent | |
2918 | The shift-@kbd{S} command computes the sine of an angle. The sine | |
a4231b04 | 2919 | of 45 degrees is |
8e04863e | 2920 | @texline @math{\sqrt{2}/2}; |
a4231b04 JB |
2921 | @infoline @expr{sqrt(2)/2}; |
2922 | squaring this yields @expr{2/4 = 0.5}. However, there has been a slight | |
2923 | roundoff error because the representation of | |
8e04863e | 2924 | @texline @math{\sqrt{2}/2} |
a4231b04 JB |
2925 | @infoline @expr{sqrt(2)/2} |
2926 | wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers | |
2927 | in this case; it temporarily reduces the precision by one digit while it | |
d7b8e6c6 EZ |
2928 | re-rounds the number on the top of the stack. |
2929 | ||
2930 | @cindex Roundoff errors, examples | |
2931 | (@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine | |
2932 | of 45 degrees as shown above, then, hoping to avoid an inexact | |
2933 | result, he increased the precision to 16 digits before squaring. | |
2934 | What happened? @xref{Modes Answer 3, 3}. (@bullet{}) | |
2935 | ||
2936 | To do this calculation in radians, we would type @kbd{m r} first. | |
2937 | (The indicator changes to @samp{Rad}.) 45 degrees corresponds to | |
a4231b04 | 2938 | @cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once |
d7b8e6c6 EZ |
2939 | again, this is a shifted capital @kbd{P}. Remember, unshifted |
2940 | @kbd{p} sets the precision.) | |
2941 | ||
d7b8e6c6 | 2942 | @smallexample |
5d67986c | 2943 | @group |
d7b8e6c6 EZ |
2944 | 1: 3.14159265359 1: 0.785398163398 1: 0.707106781187 |
2945 | . . . | |
2946 | ||
2947 | P 4 / m r S | |
d7b8e6c6 | 2948 | @end group |
5d67986c | 2949 | @end smallexample |
d7b8e6c6 EZ |
2950 | |
2951 | Likewise, inverse trigonometric functions generate results in | |
2952 | either radians or degrees, depending on the current angular mode. | |
2953 | ||
d7b8e6c6 | 2954 | @smallexample |
5d67986c | 2955 | @group |
d7b8e6c6 EZ |
2956 | 1: 0.707106781187 1: 0.785398163398 1: 45. |
2957 | . . . | |
2958 | ||
2959 | .5 Q m r I S m d U I S | |
d7b8e6c6 | 2960 | @end group |
5d67986c | 2961 | @end smallexample |
d7b8e6c6 EZ |
2962 | |
2963 | @noindent | |
a4231b04 | 2964 | Here we compute the Inverse Sine of |
8e04863e | 2965 | @texline @math{\sqrt{0.5}}, |
a4231b04 JB |
2966 | @infoline @expr{sqrt(0.5)}, |
2967 | first in radians, then in degrees. | |
d7b8e6c6 EZ |
2968 | |
2969 | Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees | |
2970 | and vice-versa. | |
2971 | ||
d7b8e6c6 | 2972 | @smallexample |
5d67986c | 2973 | @group |
d7b8e6c6 EZ |
2974 | 1: 45 1: 0.785398163397 1: 45. |
2975 | . . . | |
2976 | ||
2977 | 45 c r c d | |
d7b8e6c6 | 2978 | @end group |
5d67986c | 2979 | @end smallexample |
d7b8e6c6 | 2980 | |
07ce2eb3 | 2981 | Another interesting mode is @dfn{Fraction mode}. Normally, |
d7b8e6c6 EZ |
2982 | dividing two integers produces a floating-point result if the |
2983 | quotient can't be expressed as an exact integer. Fraction mode | |
2984 | causes integer division to produce a fraction, i.e., a rational | |
2985 | number, instead. | |
2986 | ||
d7b8e6c6 | 2987 | @smallexample |
5d67986c | 2988 | @group |
d7b8e6c6 EZ |
2989 | 2: 12 1: 1.33333333333 1: 4:3 |
2990 | 1: 9 . . | |
2991 | . | |
2992 | ||
5d67986c | 2993 | 12 @key{RET} 9 / m f U / m f |
d7b8e6c6 | 2994 | @end group |
5d67986c | 2995 | @end smallexample |
d7b8e6c6 EZ |
2996 | |
2997 | @noindent | |
2998 | In the first case, we get an approximate floating-point result. | |
2999 | In the second case, we get an exact fractional result (four-thirds). | |
3000 | ||
3001 | You can enter a fraction at any time using @kbd{:} notation. | |
3002 | (Calc uses @kbd{:} instead of @kbd{/} as the fraction separator | |
3003 | because @kbd{/} is already used to divide the top two stack | |
3004 | elements.) Calculations involving fractions will always | |
07ce2eb3 | 3005 | produce exact fractional results; Fraction mode only says |
d7b8e6c6 EZ |
3006 | what to do when dividing two integers. |
3007 | ||
3008 | @cindex Fractions vs. floats | |
3009 | @cindex Floats vs. fractions | |
3010 | (@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact, | |
3011 | why would you ever use floating-point numbers instead? | |
3012 | @xref{Modes Answer 4, 4}. (@bullet{}) | |
3013 | ||
3014 | Typing @kbd{m f} doesn't change any existing values in the stack. | |
3015 | In the above example, we had to Undo the division and do it over | |
07ce2eb3 | 3016 | again when we changed to Fraction mode. But if you use the |
d7b8e6c6 EZ |
3017 | evaluates-to operator you can get commands like @kbd{m f} to |
3018 | recompute for you. | |
3019 | ||
d7b8e6c6 | 3020 | @smallexample |
5d67986c | 3021 | @group |
d7b8e6c6 EZ |
3022 | 1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3 |
3023 | . . . | |
3024 | ||
5d67986c | 3025 | ' 12/9 => @key{RET} p 4 @key{RET} m f |
d7b8e6c6 | 3026 | @end group |
5d67986c | 3027 | @end smallexample |
d7b8e6c6 EZ |
3028 | |
3029 | @noindent | |
3030 | In this example, the righthand side of the @samp{=>} operator | |
3031 | on the stack is recomputed when we change the precision, then | |
07ce2eb3 | 3032 | again when we change to Fraction mode. All @samp{=>} expressions |
d7b8e6c6 EZ |
3033 | on the stack are recomputed every time you change any mode that |
3034 | might affect their values. | |
3035 | ||
3036 | @node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial | |
3037 | @section Arithmetic Tutorial | |
3038 | ||
3039 | @noindent | |
3040 | In this section, we explore the arithmetic and scientific functions | |
3041 | available in the Calculator. | |
3042 | ||
3043 | The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, | |
3044 | and @kbd{^}. Each normally takes two numbers from the top of the stack | |
3045 | and pushes back a result. The @kbd{n} and @kbd{&} keys perform | |
3046 | change-sign and reciprocal operations, respectively. | |
3047 | ||
d7b8e6c6 | 3048 | @smallexample |
5d67986c | 3049 | @group |
d7b8e6c6 EZ |
3050 | 1: 5 1: 0.2 1: 5. 1: -5. 1: 5. |
3051 | . . . . . | |
3052 | ||
3053 | 5 & & n n | |
d7b8e6c6 | 3054 | @end group |
5d67986c | 3055 | @end smallexample |
d7b8e6c6 EZ |
3056 | |
3057 | @cindex Binary operators | |
3058 | You can apply a ``binary operator'' like @kbd{+} across any number of | |
3059 | stack entries by giving it a numeric prefix. You can also apply it | |
3060 | pairwise to several stack elements along with the top one if you use | |
3061 | a negative prefix. | |
3062 | ||
d7b8e6c6 | 3063 | @smallexample |
5d67986c | 3064 | @group |
d7b8e6c6 EZ |
3065 | 3: 2 1: 9 3: 2 4: 2 3: 12 |
3066 | 2: 3 . 2: 3 3: 3 2: 13 | |
3067 | 1: 4 1: 4 2: 4 1: 14 | |
3068 | . . 1: 10 . | |
3069 | . | |
3070 | ||
5d67986c | 3071 | 2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 + |
d7b8e6c6 | 3072 | @end group |
5d67986c | 3073 | @end smallexample |
d7b8e6c6 EZ |
3074 | |
3075 | @cindex Unary operators | |
3076 | You can apply a ``unary operator'' like @kbd{&} to the top @var{n} | |
3077 | stack entries with a numeric prefix, too. | |
3078 | ||
d7b8e6c6 | 3079 | @smallexample |
5d67986c | 3080 | @group |
d7b8e6c6 EZ |
3081 | 3: 2 3: 0.5 3: 0.5 |
3082 | 2: 3 2: 0.333333333333 2: 3. | |
3083 | 1: 4 1: 0.25 1: 4. | |
3084 | . . . | |
3085 | ||
5d67986c | 3086 | 2 @key{RET} 3 @key{RET} 4 M-3 & M-2 & |
d7b8e6c6 | 3087 | @end group |
5d67986c | 3088 | @end smallexample |
d7b8e6c6 EZ |
3089 | |
3090 | Notice that the results here are left in floating-point form. | |
3091 | We can convert them back to integers by pressing @kbd{F}, the | |
3092 | ``floor'' function. This function rounds down to the next lower | |
3093 | integer. There is also @kbd{R}, which rounds to the nearest | |
3094 | integer. | |
3095 | ||
d7b8e6c6 | 3096 | @smallexample |
5d67986c | 3097 | @group |
d7b8e6c6 EZ |
3098 | 7: 2. 7: 2 7: 2 |
3099 | 6: 2.4 6: 2 6: 2 | |
3100 | 5: 2.5 5: 2 5: 3 | |
3101 | 4: 2.6 4: 2 4: 3 | |
3102 | 3: -2. 3: -2 3: -2 | |
3103 | 2: -2.4 2: -3 2: -2 | |
3104 | 1: -2.6 1: -3 1: -3 | |
3105 | . . . | |
3106 | ||
3107 | M-7 F U M-7 R | |
d7b8e6c6 | 3108 | @end group |
5d67986c | 3109 | @end smallexample |
d7b8e6c6 EZ |
3110 | |
3111 | Since dividing-and-flooring (i.e., ``integer quotient'') is such a | |
3112 | common operation, Calc provides a special command for that purpose, the | |
3113 | backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which | |
3114 | computes the remainder that would arise from a @kbd{\} operation, i.e., | |
3115 | the ``modulo'' of two numbers. For example, | |
3116 | ||
d7b8e6c6 | 3117 | @smallexample |
5d67986c | 3118 | @group |
d7b8e6c6 EZ |
3119 | 2: 1234 1: 12 2: 1234 1: 34 |
3120 | 1: 100 . 1: 100 . | |
3121 | . . | |
3122 | ||
5d67986c | 3123 | 1234 @key{RET} 100 \ U % |
d7b8e6c6 | 3124 | @end group |
5d67986c | 3125 | @end smallexample |
d7b8e6c6 EZ |
3126 | |
3127 | These commands actually work for any real numbers, not just integers. | |
3128 | ||
d7b8e6c6 | 3129 | @smallexample |
5d67986c | 3130 | @group |
d7b8e6c6 EZ |
3131 | 2: 3.1415 1: 3 2: 3.1415 1: 0.1415 |
3132 | 1: 1 . 1: 1 . | |
3133 | . . | |
3134 | ||
5d67986c | 3135 | 3.1415 @key{RET} 1 \ U % |
d7b8e6c6 | 3136 | @end group |
5d67986c | 3137 | @end smallexample |
d7b8e6c6 EZ |
3138 | |
3139 | (@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a | |
3140 | frill, since you could always do the same thing with @kbd{/ F}. Think | |
3141 | of a situation where this is not true---@kbd{/ F} would be inadequate. | |
3142 | Now think of a way you could get around the problem if Calc didn't | |
3143 | provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{}) | |
3144 | ||
3145 | We've already seen the @kbd{Q} (square root) and @kbd{S} (sine) | |
3146 | commands. Other commands along those lines are @kbd{C} (cosine), | |
a4231b04 | 3147 | @kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural |
d7b8e6c6 EZ |
3148 | logarithm). These can be modified by the @kbd{I} (inverse) and |
3149 | @kbd{H} (hyperbolic) prefix keys. | |
3150 | ||
3151 | Let's compute the sine and cosine of an angle, and verify the | |
a4231b04 | 3152 | identity |
8e04863e | 3153 | @texline @math{\sin^2x + \cos^2x = 1}. |
a4231b04 | 3154 | @infoline @expr{sin(x)^2 + cos(x)^2 = 1}. |
8e04863e | 3155 | We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}. |
a4231b04 | 3156 | With the angular mode set to degrees (type @w{@kbd{m d}}), do: |
d7b8e6c6 | 3157 | |
d7b8e6c6 | 3158 | @smallexample |
5d67986c | 3159 | @group |
d7b8e6c6 EZ |
3160 | 2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1. |
3161 | 1: -64 1: -0.89879 1: -64 1: 0.43837 . | |
3162 | . . . . | |
3163 | ||
5d67986c | 3164 | 64 n @key{RET} @key{RET} S @key{TAB} C f h |
d7b8e6c6 | 3165 | @end group |
5d67986c | 3166 | @end smallexample |
d7b8e6c6 EZ |
3167 | |
3168 | @noindent | |
3169 | (For brevity, we're showing only five digits of the results here. | |
3170 | You can of course do these calculations to any precision you like.) | |
3171 | ||
3172 | Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum | |
3173 | of squares, command. | |
3174 | ||
a4231b04 | 3175 | Another identity is |
8e04863e | 3176 | @texline @math{\displaystyle\tan x = {\sin x \over \cos x}}. |
a4231b04 | 3177 | @infoline @expr{tan(x) = sin(x) / cos(x)}. |
d7b8e6c6 | 3178 | @smallexample |
5d67986c | 3179 | @group |
d7b8e6c6 EZ |
3180 | |
3181 | 2: -0.89879 1: -2.0503 1: -64. | |
3182 | 1: 0.43837 . . | |
3183 | . | |
3184 | ||
3185 | U / I T | |
d7b8e6c6 | 3186 | @end group |
5d67986c | 3187 | @end smallexample |
d7b8e6c6 EZ |
3188 | |
3189 | A physical interpretation of this calculation is that if you move | |
a4231b04 | 3190 | @expr{0.89879} units downward and @expr{0.43837} units to the right, |
8e04863e | 3191 | your direction of motion is @mathit{-64} degrees from horizontal. Suppose |
d7b8e6c6 EZ |
3192 | we move in the opposite direction, up and to the left: |
3193 | ||
d7b8e6c6 | 3194 | @smallexample |
5d67986c | 3195 | @group |
d7b8e6c6 EZ |
3196 | 2: -0.89879 2: 0.89879 1: -2.0503 1: -64. |
3197 | 1: 0.43837 1: -0.43837 . . | |
3198 | . . | |
3199 | ||
3200 | U U M-2 n / I T | |
d7b8e6c6 | 3201 | @end group |
5d67986c | 3202 | @end smallexample |
d7b8e6c6 EZ |
3203 | |
3204 | @noindent | |
3205 | How can the angle be the same? The answer is that the @kbd{/} operation | |
3206 | loses information about the signs of its inputs. Because the quotient | |
3207 | is negative, we know exactly one of the inputs was negative, but we | |
3208 | can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which | |
3209 | computes the inverse tangent of the quotient of a pair of numbers. | |
3210 | Since you feed it the two original numbers, it has enough information | |
3211 | to give you a full 360-degree answer. | |
3212 | ||
d7b8e6c6 | 3213 | @smallexample |
5d67986c | 3214 | @group |
d7b8e6c6 EZ |
3215 | 2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180. |
3216 | 1: -0.43837 . 2: -0.89879 1: -64. . | |
3217 | . 1: 0.43837 . | |
3218 | . | |
3219 | ||
5d67986c | 3220 | U U f T M-@key{RET} M-2 n f T - |
d7b8e6c6 | 3221 | @end group |
5d67986c | 3222 | @end smallexample |
d7b8e6c6 EZ |
3223 | |
3224 | @noindent | |
3225 | The resulting angles differ by 180 degrees; in other words, they | |
3226 | point in opposite directions, just as we would expect. | |
3227 | ||
3228 | The @key{META}-@key{RET} we used in the third step is the | |
3229 | ``last-arguments'' command. It is sort of like Undo, except that it | |
3230 | restores the arguments of the last command to the stack without removing | |
3231 | the command's result. It is useful in situations like this one, | |
3232 | where we need to do several operations on the same inputs. We could | |
3233 | have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate | |
3234 | the top two stack elements right after the @kbd{U U}, then a pair of | |
3235 | @kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates. | |
3236 | ||
3237 | A similar identity is supposed to hold for hyperbolic sines and cosines, | |
3238 | except that it is the @emph{difference} | |
8e04863e | 3239 | @texline @math{\cosh^2x - \sinh^2x} |
a4231b04 JB |
3240 | @infoline @expr{cosh(x)^2 - sinh(x)^2} |
3241 | that always equals one. Let's try to verify this identity. | |
d7b8e6c6 | 3242 | |
d7b8e6c6 | 3243 | @smallexample |
5d67986c | 3244 | @group |
d7b8e6c6 EZ |
3245 | 2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54 |
3246 | 1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54 | |
3247 | . . . . . | |
3248 | ||
5d67986c | 3249 | 64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^ |
d7b8e6c6 | 3250 | @end group |
5d67986c | 3251 | @end smallexample |
d7b8e6c6 EZ |
3252 | |
3253 | @noindent | |
3254 | @cindex Roundoff errors, examples | |
3255 | Something's obviously wrong, because when we subtract these numbers | |
3256 | the answer will clearly be zero! But if you think about it, if these | |
3257 | numbers @emph{did} differ by one, it would be in the 55th decimal | |
3258 | place. The difference we seek has been lost entirely to roundoff | |
3259 | error. | |
3260 | ||
3261 | We could verify this hypothesis by doing the actual calculation with, | |
3262 | say, 60 decimal places of precision. This will be slow, but not | |
3263 | enormously so. Try it if you wish; sure enough, the answer is | |
3264 | 0.99999, reasonably close to 1. | |
3265 | ||
3266 | Of course, a more reasonable way to verify the identity is to use | |
a4231b04 | 3267 | a more reasonable value for @expr{x}! |
d7b8e6c6 EZ |
3268 | |
3269 | @cindex Common logarithm | |
3270 | Some Calculator commands use the Hyperbolic prefix for other purposes. | |
3271 | The logarithm and exponential functions, for example, work to the base | |
a4231b04 | 3272 | @expr{e} normally but use base-10 instead if you use the Hyperbolic |
d7b8e6c6 EZ |
3273 | prefix. |
3274 | ||
d7b8e6c6 | 3275 | @smallexample |
5d67986c | 3276 | @group |
d7b8e6c6 EZ |
3277 | 1: 1000 1: 6.9077 1: 1000 1: 3 |
3278 | . . . . | |
3279 | ||
3280 | 1000 L U H L | |
d7b8e6c6 | 3281 | @end group |
5d67986c | 3282 | @end smallexample |
d7b8e6c6 EZ |
3283 | |
3284 | @noindent | |
3285 | First, we mistakenly compute a natural logarithm. Then we undo | |
3286 | and compute a common logarithm instead. | |
3287 | ||
3288 | The @kbd{B} key computes a general base-@var{b} logarithm for any | |
3289 | value of @var{b}. | |
3290 | ||
d7b8e6c6 | 3291 | @smallexample |
5d67986c | 3292 | @group |
d7b8e6c6 EZ |
3293 | 2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077 |
3294 | 1: 10 . . 1: 2.71828 . | |
3295 | . . | |
3296 | ||
5d67986c | 3297 | 1000 @key{RET} 10 B H E H P B |
d7b8e6c6 | 3298 | @end group |
5d67986c | 3299 | @end smallexample |
d7b8e6c6 EZ |
3300 | |
3301 | @noindent | |
3302 | Here we first use @kbd{B} to compute the base-10 logarithm, then use | |
3303 | the ``hyperbolic'' exponential as a cheap hack to recover the number | |
3304 | 1000, then use @kbd{B} again to compute the natural logarithm. Note | |
a4231b04 | 3305 | that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e} |
d7b8e6c6 EZ |
3306 | onto the stack. |
3307 | ||
3308 | You may have noticed that both times we took the base-10 logarithm | |
3309 | of 1000, we got an exact integer result. Calc always tries to give | |
3310 | an exact rational result for calculations involving rational numbers | |
3311 | where possible. But when we used @kbd{H E}, the result was a | |
3312 | floating-point number for no apparent reason. In fact, if we had | |
3313 | computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an | |
3314 | exact integer 1000. But the @kbd{H E} command is rigged to generate | |
3315 | a floating-point result all of the time so that @kbd{1000 H E} will | |
3316 | not waste time computing a thousand-digit integer when all you | |
3317 | probably wanted was @samp{1e1000}. | |
3318 | ||
3319 | (@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to | |
3320 | the @kbd{B} command for which Calc could find an exact rational | |
3321 | result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{}) | |
3322 | ||
3323 | The Calculator also has a set of functions relating to combinatorics | |
3324 | and statistics. You may be familiar with the @dfn{factorial} function, | |
3325 | which computes the product of all the integers up to a given number. | |
3326 | ||
d7b8e6c6 | 3327 | @smallexample |
5d67986c | 3328 | @group |
d7b8e6c6 EZ |
3329 | 1: 100 1: 93326215443... 1: 100. 1: 9.3326e157 |
3330 | . . . . | |
3331 | ||
3332 | 100 ! U c f ! | |
d7b8e6c6 | 3333 | @end group |
5d67986c | 3334 | @end smallexample |
d7b8e6c6 EZ |
3335 | |
3336 | @noindent | |
3337 | Recall, the @kbd{c f} command converts the integer or fraction at the | |
3338 | top of the stack to floating-point format. If you take the factorial | |
3339 | of a floating-point number, you get a floating-point result | |
3340 | accurate to the current precision. But if you give @kbd{!} an | |
3341 | exact integer, you get an exact integer result (158 digits long | |
3342 | in this case). | |
3343 | ||
3344 | If you take the factorial of a non-integer, Calc uses a generalized | |
3345 | factorial function defined in terms of Euler's Gamma function | |
8e04863e | 3346 | @texline @math{\Gamma(n)} |
a4231b04 | 3347 | @infoline @expr{gamma(n)} |
d7b8e6c6 EZ |
3348 | (which is itself available as the @kbd{f g} command). |
3349 | ||
d7b8e6c6 | 3350 | @smallexample |
5d67986c | 3351 | @group |
d7b8e6c6 EZ |
3352 | 3: 4. 3: 24. 1: 5.5 1: 52.342777847 |
3353 | 2: 4.5 2: 52.3427777847 . . | |
3354 | 1: 5. 1: 120. | |
3355 | . . | |
3356 | ||
5d67986c | 3357 | M-3 ! M-0 @key{DEL} 5.5 f g |
d7b8e6c6 | 3358 | @end group |
5d67986c | 3359 | @end smallexample |
d7b8e6c6 EZ |
3360 | |
3361 | @noindent | |
a4231b04 | 3362 | Here we verify the identity |
8e04863e | 3363 | @texline @math{n! = \Gamma(n+1)}. |
a4231b04 | 3364 | @infoline @expr{@var{n}!@: = gamma(@var{n}+1)}. |
d7b8e6c6 | 3365 | |
a4231b04 | 3366 | The binomial coefficient @var{n}-choose-@var{m} |
8e04863e | 3367 | @texline or @math{\displaystyle {n \choose m}} |
a4231b04 | 3368 | is defined by |
8e04863e | 3369 | @texline @math{\displaystyle {n! \over m! \, (n-m)!}} |
a4231b04 JB |
3370 | @infoline @expr{n!@: / m!@: (n-m)!} |
3371 | for all reals @expr{n} and @expr{m}. The intermediate results in this | |
3372 | formula can become quite large even if the final result is small; the | |
3373 | @kbd{k c} command computes a binomial coefficient in a way that avoids | |
3374 | large intermediate values. | |
d7b8e6c6 EZ |
3375 | |
3376 | The @kbd{k} prefix key defines several common functions out of | |
3377 | combinatorics and number theory. Here we compute the binomial | |
3378 | coefficient 30-choose-20, then determine its prime factorization. | |
3379 | ||
d7b8e6c6 | 3380 | @smallexample |
5d67986c | 3381 | @group |
d7b8e6c6 EZ |
3382 | 2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29] |
3383 | 1: 20 . . | |
3384 | . | |
3385 | ||
5d67986c | 3386 | 30 @key{RET} 20 k c k f |
d7b8e6c6 | 3387 | @end group |
5d67986c | 3388 | @end smallexample |
d7b8e6c6 EZ |
3389 | |
3390 | @noindent | |
3391 | You can verify these prime factors by using @kbd{v u} to ``unpack'' | |
3392 | this vector into 8 separate stack entries, then @kbd{M-8 *} to | |
3393 | multiply them back together. The result is the original number, | |
3394 | 30045015. | |
3395 | ||
3396 | @cindex Hash tables | |
3397 | Suppose a program you are writing needs a hash table with at least | |
3398 | 10000 entries. It's best to use a prime number as the actual size | |
3399 | of a hash table. Calc can compute the next prime number after 10000: | |
3400 | ||
d7b8e6c6 | 3401 | @smallexample |
5d67986c | 3402 | @group |
d7b8e6c6 EZ |
3403 | 1: 10000 1: 10007 1: 9973 |
3404 | . . . | |
3405 | ||
3406 | 10000 k n I k n | |
d7b8e6c6 | 3407 | @end group |
5d67986c | 3408 | @end smallexample |
d7b8e6c6 EZ |
3409 | |
3410 | @noindent | |
3411 | Just for kicks we've also computed the next prime @emph{less} than | |
3412 | 10000. | |
3413 | ||
3414 | @c [fix-ref Financial Functions] | |
3415 | @xref{Financial Functions}, for a description of the Calculator | |
3416 | commands that deal with business and financial calculations (functions | |
3417 | like @code{pv}, @code{rate}, and @code{sln}). | |
3418 | ||
3419 | @c [fix-ref Binary Number Functions] | |
3420 | @xref{Binary Functions}, to read about the commands for operating | |
3421 | on binary numbers (like @code{and}, @code{xor}, and @code{lsh}). | |
3422 | ||
3423 | @node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial | |
3424 | @section Vector/Matrix Tutorial | |
3425 | ||
3426 | @noindent | |
3427 | A @dfn{vector} is a list of numbers or other Calc data objects. | |
3428 | Calc provides a large set of commands that operate on vectors. Some | |
3429 | are familiar operations from vector analysis. Others simply treat | |
3430 | a vector as a list of objects. | |
3431 | ||
3432 | @menu | |
3433 | * Vector Analysis Tutorial:: | |
3434 | * Matrix Tutorial:: | |
3435 | * List Tutorial:: | |
3436 | @end menu | |
3437 | ||
3438 | @node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial | |
3439 | @subsection Vector Analysis | |
3440 | ||
3441 | @noindent | |
3442 | If you add two vectors, the result is a vector of the sums of the | |
3443 | elements, taken pairwise. | |
3444 | ||
d7b8e6c6 | 3445 | @smallexample |
5d67986c | 3446 | @group |
d7b8e6c6 EZ |
3447 | 1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3] |
3448 | . 1: [7, 6, 0] . | |
3449 | . | |
3450 | ||
3451 | [1,2,3] s 1 [7 6 0] s 2 + | |
d7b8e6c6 | 3452 | @end group |
5d67986c | 3453 | @end smallexample |
d7b8e6c6 EZ |
3454 | |
3455 | @noindent | |
3456 | Note that we can separate the vector elements with either commas or | |
3457 | spaces. This is true whether we are using incomplete vectors or | |
3458 | algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these | |
3459 | vectors so we can easily reuse them later. | |
3460 | ||
3461 | If you multiply two vectors, the result is the sum of the products | |
3462 | of the elements taken pairwise. This is called the @dfn{dot product} | |
3463 | of the vectors. | |
3464 | ||
d7b8e6c6 | 3465 | @smallexample |
5d67986c | 3466 | @group |
d7b8e6c6 EZ |
3467 | 2: [1, 2, 3] 1: 19 |
3468 | 1: [7, 6, 0] . | |
3469 | . | |
3470 | ||
3471 | r 1 r 2 * | |
d7b8e6c6 | 3472 | @end group |
5d67986c | 3473 | @end smallexample |
d7b8e6c6 EZ |
3474 | |
3475 | @cindex Dot product | |
3476 | The dot product of two vectors is equal to the product of their | |
3477 | lengths times the cosine of the angle between them. (Here the vector | |
a4231b04 | 3478 | is interpreted as a line from the origin @expr{(0,0,0)} to the |
d7b8e6c6 EZ |
3479 | specified point in three-dimensional space.) The @kbd{A} |
3480 | (absolute value) command can be used to compute the length of a | |
3481 | vector. | |
3482 | ||
d7b8e6c6 | 3483 | @smallexample |
5d67986c | 3484 | @group |
d7b8e6c6 EZ |
3485 | 3: 19 3: 19 1: 0.550782 1: 56.579 |
3486 | 2: [1, 2, 3] 2: 3.741657 . . | |
3487 | 1: [7, 6, 0] 1: 9.219544 | |
3488 | . . | |
3489 | ||
5d67986c | 3490 | M-@key{RET} M-2 A * / I C |
d7b8e6c6 | 3491 | @end group |
5d67986c | 3492 | @end smallexample |
d7b8e6c6 EZ |
3493 | |
3494 | @noindent | |
3495 | First we recall the arguments to the dot product command, then | |
3496 | we compute the absolute values of the top two stack entries to | |
3497 | obtain the lengths of the vectors, then we divide the dot product | |
3498 | by the product of the lengths to get the cosine of the angle. | |
3499 | The inverse cosine finds that the angle between the vectors | |
3500 | is about 56 degrees. | |
3501 | ||
3502 | @cindex Cross product | |
3503 | @cindex Perpendicular vectors | |
3504 | The @dfn{cross product} of two vectors is a vector whose length | |
3505 | is the product of the lengths of the inputs times the sine of the | |
3506 | angle between them, and whose direction is perpendicular to both | |
3507 | input vectors. Unlike the dot product, the cross product is | |
3508 | defined only for three-dimensional vectors. Let's double-check | |
3509 | our computation of the angle using the cross product. | |
3510 | ||
d7b8e6c6 | 3511 | @smallexample |
5d67986c | 3512 | @group |
d7b8e6c6 EZ |
3513 | 2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579 |
3514 | 1: [7, 6, 0] 2: [1, 2, 3] . . | |
3515 | . 1: [7, 6, 0] | |
3516 | . | |
3517 | ||
5d67986c | 3518 | r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S |
d7b8e6c6 | 3519 | @end group |
5d67986c | 3520 | @end smallexample |
d7b8e6c6 EZ |
3521 | |
3522 | @noindent | |
3523 | First we recall the original vectors and compute their cross product, | |
3524 | which we also store for later reference. Now we divide the vector | |
3525 | by the product of the lengths of the original vectors. The length of | |
3526 | this vector should be the sine of the angle; sure enough, it is! | |
3527 | ||
3528 | @c [fix-ref General Mode Commands] | |
3529 | Vector-related commands generally begin with the @kbd{v} prefix key. | |
3530 | Some are uppercase letters and some are lowercase. To make it easier | |
3531 | to type these commands, the shift-@kbd{V} prefix key acts the same as | |
3532 | the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all | |
3533 | prefix keys have this property.) | |
3534 | ||
3535 | If we take the dot product of two perpendicular vectors we expect | |
3536 | to get zero, since the cosine of 90 degrees is zero. Let's check | |
3537 | that the cross product is indeed perpendicular to both inputs: | |
3538 | ||
d7b8e6c6 | 3539 | @smallexample |
5d67986c | 3540 | @group |
d7b8e6c6 EZ |
3541 | 2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0 |
3542 | 1: [-18, 21, -8] . 1: [-18, 21, -8] . | |
3543 | . . | |
3544 | ||
5d67986c | 3545 | r 1 r 3 * @key{DEL} r 2 r 3 * |
d7b8e6c6 | 3546 | @end group |
5d67986c | 3547 | @end smallexample |
d7b8e6c6 EZ |
3548 | |
3549 | @cindex Normalizing a vector | |
3550 | @cindex Unit vectors | |
3551 | (@bullet{}) @strong{Exercise 1.} Given a vector on the top of the | |
3552 | stack, what keystrokes would you use to @dfn{normalize} the | |
3553 | vector, i.e., to reduce its length to one without changing its | |
3554 | direction? @xref{Vector Answer 1, 1}. (@bullet{}) | |
3555 | ||
3556 | (@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be | |
3557 | at any of several positions along a ruler. You have a list of | |
3558 | those positions in the form of a vector, and another list of the | |
3559 | probabilities for the particle to be at the corresponding positions. | |
3560 | Find the average position of the particle. | |
3561 | @xref{Vector Answer 2, 2}. (@bullet{}) | |
3562 | ||
3563 | @node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial | |
3564 | @subsection Matrices | |
3565 | ||
3566 | @noindent | |
3567 | A @dfn{matrix} is just a vector of vectors, all the same length. | |
3568 | This means you can enter a matrix using nested brackets. You can | |
3569 | also use the semicolon character to enter a matrix. We'll show | |
3570 | both methods here: | |
3571 | ||
d7b8e6c6 | 3572 | @smallexample |
5d67986c | 3573 | @group |
d7b8e6c6 EZ |
3574 | 1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] |
3575 | [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] | |
3576 | . . | |
3577 | ||
5d67986c | 3578 | [[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET} |
d7b8e6c6 | 3579 | @end group |
5d67986c | 3580 | @end smallexample |
d7b8e6c6 EZ |
3581 | |
3582 | @noindent | |
3583 | We'll be using this matrix again, so type @kbd{s 4} to save it now. | |
3584 | ||
3585 | Note that semicolons work with incomplete vectors, but they work | |
3586 | better in algebraic entry. That's why we use the apostrophe in | |
3587 | the second example. | |
3588 | ||
3589 | When two matrices are multiplied, the lefthand matrix must have | |
3590 | the same number of columns as the righthand matrix has rows. | |
a4231b04 JB |
3591 | Row @expr{i}, column @expr{j} of the result is effectively the |
3592 | dot product of row @expr{i} of the left matrix by column @expr{j} | |
d7b8e6c6 EZ |
3593 | of the right matrix. |
3594 | ||
3595 | If we try to duplicate this matrix and multiply it by itself, | |
3596 | the dimensions are wrong and the multiplication cannot take place: | |
3597 | ||
d7b8e6c6 | 3598 | @smallexample |
5d67986c | 3599 | @group |
d7b8e6c6 EZ |
3600 | 1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ] |
3601 | [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] | |
3602 | . | |
3603 | ||
5d67986c | 3604 | @key{RET} * |
d7b8e6c6 | 3605 | @end group |
5d67986c | 3606 | @end smallexample |
d7b8e6c6 EZ |
3607 | |
3608 | @noindent | |
3609 | Though rather hard to read, this is a formula which shows the product | |
3610 | of two matrices. The @samp{*} function, having invalid arguments, has | |
3611 | been left in symbolic form. | |
3612 | ||
3613 | We can multiply the matrices if we @dfn{transpose} one of them first. | |
3614 | ||
d7b8e6c6 | 3615 | @smallexample |
5d67986c | 3616 | @group |
d7b8e6c6 EZ |
3617 | 2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ] |
3618 | [ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ] | |
3619 | 1: [ [ 1, 4 ] . [ 27, 36, 45 ] ] | |
3620 | [ 2, 5 ] . | |
3621 | [ 3, 6 ] ] | |
3622 | . | |
3623 | ||
5d67986c | 3624 | U v t * U @key{TAB} * |
d7b8e6c6 | 3625 | @end group |
5d67986c | 3626 | @end smallexample |
d7b8e6c6 EZ |
3627 | |
3628 | Matrix multiplication is not commutative; indeed, switching the | |
3629 | order of the operands can even change the dimensions of the result | |
3630 | matrix, as happened here! | |
3631 | ||
3632 | If you multiply a plain vector by a matrix, it is treated as a | |
3633 | single row or column depending on which side of the matrix it is | |
3634 | on. The result is a plain vector which should also be interpreted | |
3635 | as a row or column as appropriate. | |
3636 | ||
d7b8e6c6 | 3637 | @smallexample |
5d67986c | 3638 | @group |
d7b8e6c6 EZ |
3639 | 2: [ [ 1, 2, 3 ] 1: [14, 32] |
3640 | [ 4, 5, 6 ] ] . | |
3641 | 1: [1, 2, 3] | |
3642 | . | |
3643 | ||
3644 | r 4 r 1 * | |
d7b8e6c6 | 3645 | @end group |
5d67986c | 3646 | @end smallexample |
d7b8e6c6 EZ |
3647 | |
3648 | Multiplying in the other order wouldn't work because the number of | |
3649 | rows in the matrix is different from the number of elements in the | |
3650 | vector. | |
3651 | ||
3652 | (@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows | |
a4231b04 | 3653 | of the above |
8e04863e | 3654 | @texline @math{2\times3} |
a4231b04 JB |
3655 | @infoline 2x3 |
3656 | matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns | |
3657 | to get @expr{[5, 7, 9]}. | |
d7b8e6c6 EZ |
3658 | @xref{Matrix Answer 1, 1}. (@bullet{}) |
3659 | ||
3660 | @cindex Identity matrix | |
3661 | An @dfn{identity matrix} is a square matrix with ones along the | |
3662 | diagonal and zeros elsewhere. It has the property that multiplication | |
3663 | by an identity matrix, on the left or on the right, always produces | |
3664 | the original matrix. | |
3665 | ||
d7b8e6c6 | 3666 | @smallexample |
5d67986c | 3667 | @group |
d7b8e6c6 EZ |
3668 | 1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ] |
3669 | [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ] | |
3670 | . 1: [ [ 1, 0, 0 ] . | |
3671 | [ 0, 1, 0 ] | |
3672 | [ 0, 0, 1 ] ] | |
3673 | . | |
3674 | ||
5d67986c | 3675 | r 4 v i 3 @key{RET} * |
d7b8e6c6 | 3676 | @end group |
5d67986c | 3677 | @end smallexample |
d7b8e6c6 EZ |
3678 | |
3679 | If a matrix is square, it is often possible to find its @dfn{inverse}, | |
3680 | that is, a matrix which, when multiplied by the original matrix, yields | |
3681 | an identity matrix. The @kbd{&} (reciprocal) key also computes the | |
3682 | inverse of a matrix. | |
3683 | ||
d7b8e6c6 | 3684 | @smallexample |
5d67986c | 3685 | @group |
d7b8e6c6 EZ |
3686 | 1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ] |
3687 | [ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ] | |
3688 | [ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ] | |
3689 | . . | |
3690 | ||
3691 | r 4 r 2 | s 5 & | |
d7b8e6c6 | 3692 | @end group |
5d67986c | 3693 | @end smallexample |
d7b8e6c6 EZ |
3694 | |
3695 | @noindent | |
3696 | The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and | |
3697 | matrices together. Here we have used it to add a new row onto | |
3698 | our matrix to make it square. | |
3699 | ||
3700 | We can multiply these two matrices in either order to get an identity. | |
3701 | ||
d7b8e6c6 | 3702 | @smallexample |
5d67986c | 3703 | @group |
d7b8e6c6 EZ |
3704 | 1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ] |
3705 | [ 0., 1., 0. ] [ 0., 1., 0. ] | |
3706 | [ 0., 0., 1. ] ] [ 0., 0., 1. ] ] | |
3707 | . . | |
3708 | ||
5d67986c | 3709 | M-@key{RET} * U @key{TAB} * |
d7b8e6c6 | 3710 | @end group |
5d67986c | 3711 | @end smallexample |
d7b8e6c6 EZ |
3712 | |
3713 | @cindex Systems of linear equations | |
3714 | @cindex Linear equations, systems of | |
3715 | Matrix inverses are related to systems of linear equations in algebra. | |
3716 | Suppose we had the following set of equations: | |
3717 | ||
3718 | @ifinfo | |
3719 | @group | |
3720 | @example | |
3721 | a + 2b + 3c = 6 | |
3722 | 4a + 5b + 6c = 2 | |
3723 | 7a + 6b = 3 | |
3724 | @end example | |
3725 | @end group | |
3726 | @end ifinfo | |
3727 | @tex | |
3728 | \turnoffactive | |
3729 | \beforedisplayh | |
3730 | $$ \openup1\jot \tabskip=0pt plus1fil | |
3731 | \halign to\displaywidth{\tabskip=0pt | |
3732 | $\hfil#$&$\hfil{}#{}$& | |
3733 | $\hfil#$&$\hfil{}#{}$& | |
3734 | $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr | |
3735 | a&+&2b&+&3c&=6 \cr | |
3736 | 4a&+&5b&+&6c&=2 \cr | |
3737 | 7a&+&6b& & &=3 \cr} | |
3738 | $$ | |
3739 | \afterdisplayh | |
3740 | @end tex | |
3741 | ||
3742 | @noindent | |
3743 | This can be cast into the matrix equation, | |
3744 | ||
3745 | @ifinfo | |
3746 | @group | |
3747 | @example | |
3748 | [ [ 1, 2, 3 ] [ [ a ] [ [ 6 ] | |
3749 | [ 4, 5, 6 ] * [ b ] = [ 2 ] | |
3750 | [ 7, 6, 0 ] ] [ c ] ] [ 3 ] ] | |
3751 | @end example | |
3752 | @end group | |
3753 | @end ifinfo | |
3754 | @tex | |
3755 | \turnoffactive | |
3756 | \beforedisplay | |
3757 | $$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 } | |
3758 | \times | |
3759 | \pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 } | |
3760 | $$ | |
3761 | \afterdisplay | |
3762 | @end tex | |
3763 | ||
3764 | We can solve this system of equations by multiplying both sides by the | |
3765 | inverse of the matrix. Calc can do this all in one step: | |
3766 | ||
d7b8e6c6 | 3767 | @smallexample |
5d67986c | 3768 | @group |
d7b8e6c6 EZ |
3769 | 2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333] |
3770 | 1: [ [ 1, 2, 3 ] . | |
3771 | [ 4, 5, 6 ] | |
3772 | [ 7, 6, 0 ] ] | |
3773 | . | |
3774 | ||
3775 | [6,2,3] r 5 / | |
d7b8e6c6 | 3776 | @end group |
5d67986c | 3777 | @end smallexample |
d7b8e6c6 EZ |
3778 | |
3779 | @noindent | |
a4231b04 | 3780 | The result is the @expr{[a, b, c]} vector that solves the equations. |
d7b8e6c6 EZ |
3781 | (Dividing by a square matrix is equivalent to multiplying by its |
3782 | inverse.) | |
3783 | ||
3784 | Let's verify this solution: | |
3785 | ||
d7b8e6c6 | 3786 | @smallexample |
5d67986c | 3787 | @group |
d7b8e6c6 EZ |
3788 | 2: [ [ 1, 2, 3 ] 1: [6., 2., 3.] |
3789 | [ 4, 5, 6 ] . | |
3790 | [ 7, 6, 0 ] ] | |
3791 | 1: [-12.6, 15.2, -3.93333] | |
3792 | . | |
3793 | ||
5d67986c | 3794 | r 5 @key{TAB} * |
d7b8e6c6 | 3795 | @end group |
5d67986c | 3796 | @end smallexample |
d7b8e6c6 EZ |
3797 | |
3798 | @noindent | |
3799 | Note that we had to be careful about the order in which we multiplied | |
3800 | the matrix and vector. If we multiplied in the other order, Calc would | |
3801 | assume the vector was a row vector in order to make the dimensions | |
3802 | come out right, and the answer would be incorrect. If you | |
3803 | don't feel safe letting Calc take either interpretation of your | |
a4231b04 | 3804 | vectors, use explicit |
8e04863e | 3805 | @texline @math{N\times1} |
a4231b04 JB |
3806 | @infoline Nx1 |
3807 | or | |
8e04863e | 3808 | @texline @math{1\times N} |
a4231b04 JB |
3809 | @infoline 1xN |
3810 | matrices instead. In this case, you would enter the original column | |
3811 | vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}. | |
d7b8e6c6 EZ |
3812 | |
3813 | (@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make | |
3814 | vectors and matrices that include variables. Solve the following | |
a4231b04 JB |
3815 | system of equations to get expressions for @expr{x} and @expr{y} |
3816 | in terms of @expr{a} and @expr{b}. | |
d7b8e6c6 EZ |
3817 | |
3818 | @ifinfo | |
3819 | @group | |
3820 | @example | |
3821 | x + a y = 6 | |
3822 | x + b y = 10 | |
3823 | @end example | |
3824 | @end group | |
3825 | @end ifinfo | |
3826 | @tex | |
3827 | \turnoffactive | |
3828 | \beforedisplay | |
3829 | $$ \eqalign{ x &+ a y = 6 \cr | |
3830 | x &+ b y = 10} | |
3831 | $$ | |
3832 | \afterdisplay | |
3833 | @end tex | |
3834 | ||
3835 | @noindent | |
3836 | @xref{Matrix Answer 2, 2}. (@bullet{}) | |
3837 | ||
3838 | @cindex Least-squares for over-determined systems | |
3839 | @cindex Over-determined systems of equations | |
3840 | (@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined'' | |
3841 | if it has more equations than variables. It is often the case that | |
3842 | there are no values for the variables that will satisfy all the | |
3843 | equations at once, but it is still useful to find a set of values | |
3844 | which ``nearly'' satisfy all the equations. In terms of matrix equations, | |
a4231b04 | 3845 | you can't solve @expr{A X = B} directly because the matrix @expr{A} |
d7b8e6c6 EZ |
3846 | is not square for an over-determined system. Matrix inversion works |
3847 | only for square matrices. One common trick is to multiply both sides | |
a4231b04 | 3848 | on the left by the transpose of @expr{A}: |
d7b8e6c6 EZ |
3849 | @ifinfo |
3850 | @samp{trn(A)*A*X = trn(A)*B}. | |
3851 | @end ifinfo | |
3852 | @tex | |
3853 | \turnoffactive | |
3854 | $A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}. | |
3855 | @end tex | |
a4231b04 | 3856 | Now |
8e04863e | 3857 | @texline @math{A^T A} |
a4231b04 JB |
3858 | @infoline @expr{trn(A)*A} |
3859 | is a square matrix so a solution is possible. It turns out that the | |
3860 | @expr{X} vector you compute in this way will be a ``least-squares'' | |
3861 | solution, which can be regarded as the ``closest'' solution to the set | |
3862 | of equations. Use Calc to solve the following over-determined | |
3863 | system: | |
d7b8e6c6 EZ |
3864 | |
3865 | @ifinfo | |
3866 | @group | |
3867 | @example | |
3868 | a + 2b + 3c = 6 | |
3869 | 4a + 5b + 6c = 2 | |
3870 | 7a + 6b = 3 | |
3871 | 2a + 4b + 6c = 11 | |
3872 | @end example | |
3873 | @end group | |
3874 | @end ifinfo | |
3875 | @tex | |
3876 | \turnoffactive | |
3877 | \beforedisplayh | |
3878 | $$ \openup1\jot \tabskip=0pt plus1fil | |
3879 | \halign to\displaywidth{\tabskip=0pt | |
3880 | $\hfil#$&$\hfil{}#{}$& | |
3881 | $\hfil#$&$\hfil{}#{}$& | |
3882 | $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr | |
3883 | a&+&2b&+&3c&=6 \cr | |
3884 | 4a&+&5b&+&6c&=2 \cr | |
3885 | 7a&+&6b& & &=3 \cr | |
3886 | 2a&+&4b&+&6c&=11 \cr} | |
3887 | $$ | |
3888 | \afterdisplayh | |
3889 | @end tex | |
3890 | ||
3891 | @noindent | |
3892 | @xref{Matrix Answer 3, 3}. (@bullet{}) | |
3893 | ||
3894 | @node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial | |
3895 | @subsection Vectors as Lists | |
3896 | ||
3897 | @noindent | |
3898 | @cindex Lists | |
3899 | Although Calc has a number of features for manipulating vectors and | |
3900 | matrices as mathematical objects, you can also treat vectors as | |
3901 | simple lists of values. For example, we saw that the @kbd{k f} | |
3902 | command returns a vector which is a list of the prime factors of a | |
3903 | number. | |
3904 | ||
3905 | You can pack and unpack stack entries into vectors: | |
3906 | ||
d7b8e6c6 | 3907 | @smallexample |
5d67986c | 3908 | @group |
d7b8e6c6 EZ |
3909 | 3: 10 1: [10, 20, 30] 3: 10 |
3910 | 2: 20 . 2: 20 | |
3911 | 1: 30 1: 30 | |
3912 | . . | |
3913 | ||
3914 | M-3 v p v u | |
d7b8e6c6 | 3915 | @end group |
5d67986c | 3916 | @end smallexample |
d7b8e6c6 EZ |
3917 | |
3918 | You can also build vectors out of consecutive integers, or out | |
3919 | of many copies of a given value: | |
3920 | ||
d7b8e6c6 | 3921 | @smallexample |
5d67986c | 3922 | @group |
d7b8e6c6 EZ |
3923 | 1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4] |
3924 | . 1: 17 1: [17, 17, 17, 17] | |
3925 | . . | |
3926 | ||
5d67986c | 3927 | v x 4 @key{RET} 17 v b 4 @key{RET} |
d7b8e6c6 | 3928 | @end group |
5d67986c | 3929 | @end smallexample |
d7b8e6c6 EZ |
3930 | |
3931 | You can apply an operator to every element of a vector using the | |
3932 | @dfn{map} command. | |
3933 | ||
d7b8e6c6 | 3934 | @smallexample |
5d67986c | 3935 | @group |
d7b8e6c6 EZ |
3936 | 1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68] |
3937 | . . . | |
3938 | ||
3939 | V M * 2 V M ^ V M Q | |
d7b8e6c6 | 3940 | @end group |
5d67986c | 3941 | @end smallexample |
d7b8e6c6 EZ |
3942 | |
3943 | @noindent | |
3944 | In the first step, we multiply the vector of integers by the vector | |
3945 | of 17's elementwise. In the second step, we raise each element to | |
3946 | the power two. (The general rule is that both operands must be | |
3947 | vectors of the same length, or else one must be a vector and the | |
3948 | other a plain number.) In the final step, we take the square root | |
3949 | of each element. | |
3950 | ||
3951 | (@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two | |
a4231b04 | 3952 | from |
8e04863e | 3953 | @texline @math{2^{-4}} |
a4231b04 JB |
3954 | @infoline @expr{2^-4} |
3955 | to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{}) | |
d7b8e6c6 EZ |
3956 | |
3957 | You can also @dfn{reduce} a binary operator across a vector. | |
3958 | For example, reducing @samp{*} computes the product of all the | |
3959 | elements in the vector: | |
3960 | ||
d7b8e6c6 | 3961 | @smallexample |
5d67986c | 3962 | @group |
d7b8e6c6 EZ |
3963 | 1: 123123 1: [3, 7, 11, 13, 41] 1: 123123 |
3964 | . . . | |
3965 | ||
3966 | 123123 k f V R * | |
d7b8e6c6 | 3967 | @end group |
5d67986c | 3968 | @end smallexample |
d7b8e6c6 EZ |
3969 | |
3970 | @noindent | |
3971 | In this example, we decompose 123123 into its prime factors, then | |
3972 | multiply those factors together again to yield the original number. | |
3973 | ||
3974 | We could compute a dot product ``by hand'' using mapping and | |
3975 | reduction: | |
3976 | ||
d7b8e6c6 | 3977 | @smallexample |
5d67986c | 3978 | @group |
d7b8e6c6 EZ |
3979 | 2: [1, 2, 3] 1: [7, 12, 0] 1: 19 |
3980 | 1: [7, 6, 0] . . | |
3981 | . | |
3982 | ||
3983 | r 1 r 2 V M * V R + | |
d7b8e6c6 | 3984 | @end group |
5d67986c | 3985 | @end smallexample |
d7b8e6c6 EZ |
3986 | |
3987 | @noindent | |
3988 | Recalling two vectors from the previous section, we compute the | |
3989 | sum of pairwise products of the elements to get the same answer | |
3990 | for the dot product as before. | |
3991 | ||
3992 | A slight variant of vector reduction is the @dfn{accumulate} operation, | |
3993 | @kbd{V U}. This produces a vector of the intermediate results from | |
3994 | a corresponding reduction. Here we compute a table of factorials: | |
3995 | ||
d7b8e6c6 | 3996 | @smallexample |
5d67986c | 3997 | @group |
d7b8e6c6 EZ |
3998 | 1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720] |
3999 | . . | |
4000 | ||
5d67986c | 4001 | v x 6 @key{RET} V U * |
d7b8e6c6 | 4002 | @end group |
5d67986c | 4003 | @end smallexample |
d7b8e6c6 EZ |
4004 | |
4005 | Calc allows vectors to grow as large as you like, although it gets | |
4006 | rather slow if vectors have more than about a hundred elements. | |
4007 | Actually, most of the time is spent formatting these large vectors | |
4008 | for display, not calculating on them. Try the following experiment | |
4009 | (if your computer is very fast you may need to substitute a larger | |
4010 | vector size). | |
4011 | ||
d7b8e6c6 | 4012 | @smallexample |
5d67986c | 4013 | @group |
d7b8e6c6 EZ |
4014 | 1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ... |
4015 | . . | |
4016 | ||
5d67986c | 4017 | v x 500 @key{RET} 1 V M + |
d7b8e6c6 | 4018 | @end group |
5d67986c | 4019 | @end smallexample |
d7b8e6c6 EZ |
4020 | |
4021 | Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the | |
4022 | experiment again. In @kbd{v .} mode, long vectors are displayed | |
4023 | ``abbreviated'' like this: | |
4024 | ||
d7b8e6c6 | 4025 | @smallexample |
5d67986c | 4026 | @group |
d7b8e6c6 EZ |
4027 | 1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501] |
4028 | . . | |
4029 | ||
5d67986c | 4030 | v x 500 @key{RET} 1 V M + |
d7b8e6c6 | 4031 | @end group |
5d67986c | 4032 | @end smallexample |
d7b8e6c6 EZ |
4033 | |
4034 | @noindent | |
4035 | (where now the @samp{...} is actually part of the Calc display). | |
4036 | You will find both operations are now much faster. But notice that | |
4037 | even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail. | |
4038 | Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the | |
4039 | experiment one more time. Operations on long vectors are now quite | |
4040 | fast! (But of course if you use @kbd{t .} you will lose the ability | |
4041 | to get old vectors back using the @kbd{t y} command.) | |
4042 | ||
4043 | An easy way to view a full vector when @kbd{v .} mode is active is | |
4044 | to press @kbd{`} (back-quote) to edit the vector; editing always works | |
4045 | with the full, unabbreviated value. | |
4046 | ||
4047 | @cindex Least-squares for fitting a straight line | |
4048 | @cindex Fitting data to a line | |
4049 | @cindex Line, fitting data to | |
4050 | @cindex Data, extracting from buffers | |
4051 | @cindex Columns of data, extracting | |
4052 | As a larger example, let's try to fit a straight line to some data, | |
4053 | using the method of least squares. (Calc has a built-in command for | |
4054 | least-squares curve fitting, but we'll do it by hand here just to | |
4055 | practice working with vectors.) Suppose we have the following list | |
4056 | of values in a file we have loaded into Emacs: | |
4057 | ||
4058 | @smallexample | |
4059 | x y | |
4060 | --- --- | |
4061 | 1.34 0.234 | |
4062 | 1.41 0.298 | |
4063 | 1.49 0.402 | |
4064 | 1.56 0.412 | |
4065 | 1.64 0.466 | |
4066 | 1.73 0.473 | |
4067 | 1.82 0.601 | |
4068 | 1.91 0.519 | |
4069 | 2.01 0.603 | |
4070 | 2.11 0.637 | |
4071 | 2.22 0.645 | |
4072 | 2.33 0.705 | |
4073 | 2.45 0.917 | |
4074 | 2.58 1.009 | |
4075 | 2.71 0.971 | |
4076 | 2.85 1.062 | |
4077 | 3.00 1.148 | |
4078 | 3.15 1.157 | |
4079 | 3.32 1.354 | |
4080 | @end smallexample | |
4081 | ||
4082 | @noindent | |
4083 | If you are reading this tutorial in printed form, you will find it | |
58547c3e | 4084 | easiest to press @kbd{C-x * i} to enter the on-line Info version of |
d7b8e6c6 EZ |
4085 | the manual and find this table there. (Press @kbd{g}, then type |
4086 | @kbd{List Tutorial}, to jump straight to this section.) | |
4087 | ||
4088 | Position the cursor at the upper-left corner of this table, just | |
a4231b04 | 4089 | to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark. |
5d67986c | 4090 | (On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.) |
a4231b04 | 4091 | Now position the cursor to the lower-right, just after the @expr{1.354}. |
d7b8e6c6 | 4092 | You have now defined this region as an Emacs ``rectangle.'' Still |
58547c3e | 4093 | in the Info buffer, type @kbd{C-x * r}. This command |
d7b8e6c6 | 4094 | (@code{calc-grab-rectangle}) will pop you back into the Calculator, with |
a4231b04 | 4095 | the contents of the rectangle you specified in the form of a matrix. |
d7b8e6c6 | 4096 | |
d7b8e6c6 | 4097 | @smallexample |
5d67986c | 4098 | @group |
d7b8e6c6 EZ |
4099 | 1: [ [ 1.34, 0.234 ] |
4100 | [ 1.41, 0.298 ] | |
4101 | @dots{} | |
d7b8e6c6 | 4102 | @end group |
5d67986c | 4103 | @end smallexample |
d7b8e6c6 EZ |
4104 | |
4105 | @noindent | |
4106 | (You may wish to use @kbd{v .} mode to abbreviate the display of this | |
4107 | large matrix.) | |
4108 | ||
4109 | We want to treat this as a pair of lists. The first step is to | |
4110 | transpose this matrix into a pair of rows. Remember, a matrix is | |
4111 | just a vector of vectors. So we can unpack the matrix into a pair | |
4112 | of row vectors on the stack. | |
4113 | ||
d7b8e6c6 | 4114 | @smallexample |
5d67986c | 4115 | @group |
d7b8e6c6 EZ |
4116 | 1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ] |
4117 | [ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ] | |
4118 | . . | |
4119 | ||
4120 | v t v u | |
d7b8e6c6 | 4121 | @end group |
5d67986c | 4122 | @end smallexample |
d7b8e6c6 EZ |
4123 | |
4124 | @noindent | |
4125 | Let's store these in quick variables 1 and 2, respectively. | |
4126 | ||
d7b8e6c6 | 4127 | @smallexample |
5d67986c | 4128 | @group |
d7b8e6c6 EZ |
4129 | 1: [1.34, 1.41, 1.49, ... ] . |
4130 | . | |
4131 | ||
4132 | t 2 t 1 | |
d7b8e6c6 | 4133 | @end group |
5d67986c | 4134 | @end smallexample |
d7b8e6c6 EZ |
4135 | |
4136 | @noindent | |
4137 | (Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the | |
4138 | stored value from the stack.) | |
4139 | ||
a4231b04 | 4140 | In a least squares fit, the slope @expr{m} is given by the formula |
d7b8e6c6 EZ |
4141 | |
4142 | @ifinfo | |
4143 | @example | |
4144 | m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2) | |
4145 | @end example | |
4146 | @end ifinfo | |
4147 | @tex | |
4148 | \turnoffactive | |
4149 | \beforedisplay | |
4150 | $$ m = {N \sum x y - \sum x \sum y \over | |
4151 | N \sum x^2 - \left( \sum x \right)^2} $$ | |
4152 | \afterdisplay | |
4153 | @end tex | |
4154 | ||
4155 | @noindent | |
a4231b04 | 4156 | where |
8e04863e | 4157 | @texline @math{\sum x} |
a4231b04 JB |
4158 | @infoline @expr{sum(x)} |
4159 | represents the sum of all the values of @expr{x}. While there is an | |
4160 | actual @code{sum} function in Calc, it's easier to sum a vector using a | |
4161 | simple reduction. First, let's compute the four different sums that | |
4162 | this formula uses. | |
d7b8e6c6 | 4163 | |
d7b8e6c6 | 4164 | @smallexample |
5d67986c | 4165 | @group |
d7b8e6c6 EZ |
4166 | 1: 41.63 1: 98.0003 |
4167 | . . | |
4168 | ||
4169 | r 1 V R + t 3 r 1 2 V M ^ V R + t 4 | |
4170 | ||
d7b8e6c6 | 4171 | @end group |
5d67986c | 4172 | @end smallexample |
d7b8e6c6 | 4173 | @noindent |
d7b8e6c6 | 4174 | @smallexample |
5d67986c | 4175 | @group |
d7b8e6c6 EZ |
4176 | 1: 13.613 1: 33.36554 |
4177 | . . | |
4178 | ||
4179 | r 2 V R + t 5 r 1 r 2 V M * V R + t 6 | |
d7b8e6c6 | 4180 | @end group |
5d67986c | 4181 | @end smallexample |
d7b8e6c6 EZ |
4182 | |
4183 | @ifinfo | |
4184 | @noindent | |
4185 | These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)}, | |
4186 | respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and | |
4187 | @samp{sum(x y)}.) | |
4188 | @end ifinfo | |
4189 | @tex | |
4190 | \turnoffactive | |
4191 | These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$, | |
4192 | respectively. (We could have used \kbd{*} to compute $\sum x^2$ and | |
4193 | $\sum x y$.) | |
4194 | @end tex | |
4195 | ||
a4231b04 | 4196 | Finally, we also need @expr{N}, the number of data points. This is just |
d7b8e6c6 EZ |
4197 | the length of either of our lists. |
4198 | ||
d7b8e6c6 | 4199 | @smallexample |
5d67986c | 4200 | @group |
d7b8e6c6 EZ |
4201 | 1: 19 |
4202 | . | |
4203 | ||
4204 | r 1 v l t 7 | |
d7b8e6c6 | 4205 | @end group |
5d67986c | 4206 | @end smallexample |
d7b8e6c6 EZ |
4207 | |
4208 | @noindent | |
4209 | (That's @kbd{v} followed by a lower-case @kbd{l}.) | |
4210 | ||
4211 | Now we grind through the formula: | |
4212 | ||
d7b8e6c6 | 4213 | @smallexample |
5d67986c | 4214 | @group |
d7b8e6c6 EZ |
4215 | 1: 633.94526 2: 633.94526 1: 67.23607 |
4216 | . 1: 566.70919 . | |
4217 | . | |
4218 | ||
4219 | r 7 r 6 * r 3 r 5 * - | |
4220 | ||
d7b8e6c6 | 4221 | @end group |
5d67986c | 4222 | @end smallexample |
d7b8e6c6 | 4223 | @noindent |
d7b8e6c6 | 4224 | @smallexample |
5d67986c | 4225 | @group |
d7b8e6c6 EZ |
4226 | 2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679 |
4227 | 1: 1862.0057 2: 1862.0057 1: 128.9488 . | |
4228 | . 1: 1733.0569 . | |
4229 | . | |
4230 | ||
4231 | r 7 r 4 * r 3 2 ^ - / t 8 | |
d7b8e6c6 | 4232 | @end group |
5d67986c | 4233 | @end smallexample |
d7b8e6c6 | 4234 | |
a4231b04 | 4235 | That gives us the slope @expr{m}. The y-intercept @expr{b} can now |
d7b8e6c6 EZ |
4236 | be found with the simple formula, |
4237 | ||
4238 | @ifinfo | |
4239 | @example | |
4240 | b = (sum(y) - m sum(x)) / N | |
4241 | @end example | |
4242 | @end ifinfo | |
4243 | @tex | |
4244 | \turnoffactive | |
4245 | \beforedisplay | |
4246 | $$ b = {\sum y - m \sum x \over N} $$ | |
4247 | \afterdisplay | |
4248 | \vskip10pt | |
4249 | @end tex | |
4250 | ||
d7b8e6c6 | 4251 | @smallexample |
5d67986c | 4252 | @group |
d7b8e6c6 EZ |
4253 | 1: 13.613 2: 13.613 1: -8.09358 1: -0.425978 |
4254 | . 1: 21.70658 . . | |
4255 | . | |
4256 | ||
4257 | r 5 r 8 r 3 * - r 7 / t 9 | |
d7b8e6c6 | 4258 | @end group |
5d67986c | 4259 | @end smallexample |
d7b8e6c6 | 4260 | |
a4231b04 | 4261 | Let's ``plot'' this straight line approximation, |
8e04863e | 4262 | @texline @math{y \approx m x + b}, |
a4231b04 JB |
4263 | @infoline @expr{m x + b}, |
4264 | and compare it with the original data. | |
d7b8e6c6 | 4265 | |
d7b8e6c6 | 4266 | @smallexample |
5d67986c | 4267 | @group |
d7b8e6c6 EZ |
4268 | 1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ] |
4269 | . . | |
4270 | ||
4271 | r 1 r 8 * r 9 + s 0 | |
d7b8e6c6 | 4272 | @end group |
5d67986c | 4273 | @end smallexample |
d7b8e6c6 EZ |
4274 | |
4275 | @noindent | |
4276 | Notice that multiplying a vector by a constant, and adding a constant | |
4277 | to a vector, can be done without mapping commands since these are | |
4278 | common operations from vector algebra. As far as Calc is concerned, | |
4279 | we've just been doing geometry in 19-dimensional space! | |
4280 | ||
a4231b04 | 4281 | We can subtract this vector from our original @expr{y} vector to get |
d7b8e6c6 EZ |
4282 | a feel for the error of our fit. Let's find the maximum error: |
4283 | ||
d7b8e6c6 | 4284 | @smallexample |
5d67986c | 4285 | @group |
d7b8e6c6 EZ |
4286 | 1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897 |
4287 | . . . | |
4288 | ||
4289 | r 2 - V M A V R X | |
d7b8e6c6 | 4290 | @end group |
5d67986c | 4291 | @end smallexample |
d7b8e6c6 EZ |
4292 | |
4293 | @noindent | |
4294 | First we compute a vector of differences, then we take the absolute | |
4295 | values of these differences, then we reduce the @code{max} function | |
4296 | across the vector. (The @code{max} function is on the two-key sequence | |
4297 | @kbd{f x}; because it is so common to use @code{max} in a vector | |
4298 | operation, the letters @kbd{X} and @kbd{N} are also accepted for | |
4299 | @code{max} and @code{min} in this context. In general, you answer | |
4300 | the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that | |
4301 | invokes the function you want. You could have typed @kbd{V R f x} or | |
4302 | even @kbd{V R x max @key{RET}} if you had preferred.) | |
4303 | ||
4304 | If your system has the GNUPLOT program, you can see graphs of your | |
4305 | data and your straight line to see how well they match. (If you have | |
5127c216 JB |
4306 | GNUPLOT 3.0 or higher, the following instructions will work regardless |
4307 | of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems | |
d7b8e6c6 EZ |
4308 | may require additional steps to view the graphs.) |
4309 | ||
5d67986c | 4310 | Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}'' |
d7b8e6c6 EZ |
4311 | vectors onto the stack and press @kbd{g f}. This ``fast'' graphing |
4312 | command does everything you need to do for simple, straightforward | |
4313 | plotting of data. | |
4314 | ||
d7b8e6c6 | 4315 | @smallexample |
5d67986c | 4316 | @group |
d7b8e6c6 EZ |
4317 | 2: [1.34, 1.41, 1.49, ... ] |
4318 | 1: [0.234, 0.298, 0.402, ... ] | |
4319 | . | |
4320 | ||
4321 | r 1 r 2 g f | |
d7b8e6c6 | 4322 | @end group |
5d67986c | 4323 | @end smallexample |
d7b8e6c6 EZ |
4324 | |
4325 | If all goes well, you will shortly get a new window containing a graph | |
4326 | of the data. (If not, contact your GNUPLOT or Calc installer to find | |
4327 | out what went wrong.) In the X window system, this will be a separate | |
4328 | graphics window. For other kinds of displays, the default is to | |
4329 | display the graph in Emacs itself using rough character graphics. | |
4330 | Press @kbd{q} when you are done viewing the character graphics. | |
4331 | ||
2fcdfa83 JB |
4332 | Next, let's add the line we got from our least-squares fit. |
4333 | @ifinfo | |
4334 | (If you are reading this tutorial on-line while running Calc, typing | |
4335 | @kbd{g a} may cause the tutorial to disappear from its window and be | |
4336 | replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial | |
4337 | will reappear when you terminate GNUPLOT by typing @kbd{g q}.) | |
4338 | @end ifinfo | |
d7b8e6c6 | 4339 | |
d7b8e6c6 | 4340 | @smallexample |
5d67986c | 4341 | @group |
d7b8e6c6 EZ |
4342 | 2: [1.34, 1.41, 1.49, ... ] |
4343 | 1: [0.273, 0.309, 0.351, ... ] | |
4344 | . | |
4345 | ||
5d67986c | 4346 | @key{DEL} r 0 g a g p |
d7b8e6c6 | 4347 | @end group |
5d67986c | 4348 | @end smallexample |
d7b8e6c6 EZ |
4349 | |
4350 | It's not very useful to get symbols to mark the data points on this | |
4351 | second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q} | |
4352 | when you are done to remove the X graphics window and terminate GNUPLOT. | |
4353 | ||
4354 | (@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do | |
4355 | least squares fitting to a general system of equations. Our 19 data | |
a4231b04 JB |
4356 | points are really 19 equations of the form @expr{y_i = m x_i + b} for |
4357 | different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method | |
4358 | to solve for @expr{m} and @expr{b}, duplicating the above result. | |
d7b8e6c6 EZ |
4359 | @xref{List Answer 2, 2}. (@bullet{}) |
4360 | ||
4361 | @cindex Geometric mean | |
4362 | (@bullet{}) @strong{Exercise 3.} If the input data do not form a | |
58547c3e | 4363 | rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region}) |
d7b8e6c6 EZ |
4364 | to grab the data the way Emacs normally works with regions---it reads |
4365 | left-to-right, top-to-bottom, treating line breaks the same as spaces. | |
4366 | Use this command to find the geometric mean of the following numbers. | |
4367 | (The geometric mean is the @var{n}th root of the product of @var{n} numbers.) | |
4368 | ||
4369 | @example | |
4370 | 2.3 6 22 15.1 7 | |
4371 | 15 14 7.5 | |
4372 | 2.5 | |
4373 | @end example | |
4374 | ||
4375 | @noindent | |
58547c3e | 4376 | The @kbd{C-x * g} command accepts numbers separated by spaces or commas, |
d7b8e6c6 EZ |
4377 | with or without surrounding vector brackets. |
4378 | @xref{List Answer 3, 3}. (@bullet{}) | |
4379 | ||
4380 | @ifinfo | |
4381 | As another example, a theorem about binomial coefficients tells | |
4382 | us that the alternating sum of binomial coefficients | |
4383 | @var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so | |
4384 | on up to @var{n}-choose-@var{n}, | |
4385 | always comes out to zero. Let's verify this | |
a4231b04 | 4386 | for @expr{n=6}. |
d7b8e6c6 EZ |
4387 | @end ifinfo |
4388 | @tex | |
4389 | As another example, a theorem about binomial coefficients tells | |
4390 | us that the alternating sum of binomial coefficients | |
4391 | ${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$ | |
4392 | always comes out to zero. Let's verify this | |
4393 | for \cite{n=6}. | |
4394 | @end tex | |
4395 | ||
d7b8e6c6 | 4396 | @smallexample |
5d67986c | 4397 | @group |
d7b8e6c6 EZ |
4398 | 1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6] |
4399 | . . | |
4400 | ||
5d67986c | 4401 | v x 7 @key{RET} 1 - |
d7b8e6c6 | 4402 | |
d7b8e6c6 | 4403 | @end group |
5d67986c | 4404 | @end smallexample |
d7b8e6c6 | 4405 | @noindent |
d7b8e6c6 | 4406 | @smallexample |
5d67986c | 4407 | @group |
d7b8e6c6 EZ |
4408 | 1: [1, -6, 15, -20, 15, -6, 1] 1: 0 |
4409 | . . | |
4410 | ||
5d67986c | 4411 | V M ' (-1)^$ choose(6,$) @key{RET} V R + |
d7b8e6c6 | 4412 | @end group |
5d67986c | 4413 | @end smallexample |
d7b8e6c6 EZ |
4414 | |
4415 | The @kbd{V M '} command prompts you to enter any algebraic expression | |
4416 | to define the function to map over the vector. The symbol @samp{$} | |
4417 | inside this expression represents the argument to the function. | |
4418 | The Calculator applies this formula to each element of the vector, | |
4419 | substituting each element's value for the @samp{$} sign(s) in turn. | |
4420 | ||
4421 | To define a two-argument function, use @samp{$$} for the first | |
5d67986c | 4422 | argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is |
d7b8e6c6 EZ |
4423 | equivalent to @kbd{V M -}. This is analogous to regular algebraic |
4424 | entry, where @samp{$$} would refer to the next-to-top stack entry | |
5d67986c | 4425 | and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}} |
d7b8e6c6 EZ |
4426 | would act exactly like @kbd{-}. |
4427 | ||
4428 | Notice that the @kbd{V M '} command has recorded two things in the | |
4429 | trail: The result, as usual, and also a funny-looking thing marked | |
4430 | @samp{oper} that represents the operator function you typed in. | |
4431 | The function is enclosed in @samp{< >} brackets, and the argument is | |
4432 | denoted by a @samp{#} sign. If there were several arguments, they | |
4433 | would be shown as @samp{#1}, @samp{#2}, and so on. (For example, | |
4434 | @kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the | |
4435 | trail.) This object is a ``nameless function''; you can use nameless | |
4436 | @w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like. | |
4437 | Nameless function notation has the interesting, occasionally useful | |
4438 | property that a nameless function is not actually evaluated until | |
4439 | it is used. For example, @kbd{V M ' $+random(2.0)} evaluates | |
4440 | @samp{random(2.0)} once and adds that random number to all elements | |
4441 | of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the | |
4442 | @samp{random(2.0)} separately for each vector element. | |
4443 | ||
4444 | Another group of operators that are often useful with @kbd{V M} are | |
4445 | the relational operators: @kbd{a =}, for example, compares two numbers | |
4446 | and gives the result 1 if they are equal, or 0 if not. Similarly, | |
4447 | @w{@kbd{a <}} checks for one number being less than another. | |
4448 | ||
4449 | Other useful vector operations include @kbd{v v}, to reverse a | |
4450 | vector end-for-end; @kbd{V S}, to sort the elements of a vector | |
4451 | into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract | |
4452 | one row or column of a matrix, or (in both cases) to extract one | |
4453 | element of a plain vector. With a negative argument, @kbd{v r} | |
4454 | and @kbd{v c} instead delete one row, column, or vector element. | |
4455 | ||
4456 | @cindex Divisor functions | |
a4231b04 | 4457 | (@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function} |
d7b8e6c6 EZ |
4458 | @tex |
4459 | $\sigma_k(n)$ | |
4460 | @end tex | |
a4231b04 JB |
4461 | is the sum of the @expr{k}th powers of all the divisors of an |
4462 | integer @expr{n}. Figure out a method for computing the divisor | |
4463 | function for reasonably small values of @expr{n}. As a test, | |
d7b8e6c6 EZ |
4464 | the 0th and 1st divisor functions of 30 are 8 and 72, respectively. |
4465 | @xref{List Answer 4, 4}. (@bullet{}) | |
4466 | ||
4467 | @cindex Square-free numbers | |
4468 | @cindex Duplicate values in a list | |
4469 | (@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a | |
4470 | list of prime factors for a number. Sometimes it is important to | |
4471 | know that a number is @dfn{square-free}, i.e., that no prime occurs | |
4472 | more than once in its list of prime factors. Find a sequence of | |
4473 | keystrokes to tell if a number is square-free; your method should | |
4474 | leave 1 on the stack if it is, or 0 if it isn't. | |
4475 | @xref{List Answer 5, 5}. (@bullet{}) | |
4476 | ||
4477 | @cindex Triangular lists | |
4478 | (@bullet{}) @strong{Exercise 6.} Build a list of lists that looks | |
4479 | like the following diagram. (You may wish to use the @kbd{v /} | |
4480 | command to enable multi-line display of vectors.) | |
4481 | ||
d7b8e6c6 | 4482 | @smallexample |
5d67986c | 4483 | @group |
d7b8e6c6 EZ |
4484 | 1: [ [1], |
4485 | [1, 2], | |
4486 | [1, 2, 3], | |
4487 | [1, 2, 3, 4], | |
4488 | [1, 2, 3, 4, 5], | |
4489 | [1, 2, 3, 4, 5, 6] ] | |
d7b8e6c6 | 4490 | @end group |
5d67986c | 4491 | @end smallexample |
d7b8e6c6 EZ |
4492 | |
4493 | @noindent | |
4494 | @xref{List Answer 6, 6}. (@bullet{}) | |
4495 | ||
4496 | (@bullet{}) @strong{Exercise 7.} Build the following list of lists. | |
4497 | ||
d7b8e6c6 | 4498 | @smallexample |
5d67986c | 4499 | @group |
d7b8e6c6 EZ |
4500 | 1: [ [0], |
4501 | [1, 2], | |
4502 | [3, 4, 5], | |
4503 | [6, 7, 8, 9], | |
4504 | [10, 11, 12, 13, 14], | |
4505 | [15, 16, 17, 18, 19, 20] ] | |
d7b8e6c6 | 4506 | @end group |
5d67986c | 4507 | @end smallexample |
d7b8e6c6 EZ |
4508 | |
4509 | @noindent | |
4510 | @xref{List Answer 7, 7}. (@bullet{}) | |
4511 | ||
4512 | @cindex Maximizing a function over a list of values | |
4513 | @c [fix-ref Numerical Solutions] | |
4514 | (@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's | |
8e04863e | 4515 | @texline @math{J_1(x)} |
a4231b04 JB |
4516 | @infoline @expr{J1} |
4517 | function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25. | |
4518 | Find the value of @expr{x} (from among the above set of values) for | |
d7b8e6c6 EZ |
4519 | which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method, |
4520 | i.e., just reading along the list by hand to find the largest value | |
4521 | is not allowed! (There is an @kbd{a X} command which does this kind | |
4522 | of thing automatically; @pxref{Numerical Solutions}.) | |
a4231b04 | 4523 | @xref{List Answer 8, 8}. (@bullet{}) |
d7b8e6c6 EZ |
4524 | |
4525 | @cindex Digits, vectors of | |
4526 | (@bullet{}) @strong{Exercise 9.} You are given an integer in the range | |
8e04863e | 4527 | @texline @math{0 \le N < 10^m} |
a4231b04 JB |
4528 | @infoline @expr{0 <= N < 10^m} |
4529 | for @expr{m=12} (i.e., an integer of less than | |
4530 | twelve digits). Convert this integer into a vector of @expr{m} | |
d7b8e6c6 | 4531 | digits, each in the range from 0 to 9. In vector-of-digits notation, |
a4231b04 | 4532 | add one to this integer to produce a vector of @expr{m+1} digits |
d7b8e6c6 EZ |
4533 | (since there could be a carry out of the most significant digit). |
4534 | Convert this vector back into a regular integer. A good integer | |
4535 | to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{}) | |
4536 | ||
4537 | (@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use | |
4538 | @kbd{V R a =} to test if all numbers in a list were equal. What | |
4539 | happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{}) | |
4540 | ||
4541 | (@bullet{}) @strong{Exercise 11.} The area of a circle of radius one | |
a4231b04 | 4542 | is @cpi{}. The area of the |
8e04863e | 4543 | @texline @math{2\times2} |
a4231b04 JB |
4544 | @infoline 2x2 |
4545 | square that encloses that circle is 4. So if we throw @var{n} darts at | |
4546 | random points in the square, about @cpiover{4} of them will land inside | |
4547 | the circle. This gives us an entertaining way to estimate the value of | |
4548 | @cpi{}. The @w{@kbd{k r}} | |
d7b8e6c6 | 4549 | command picks a random number between zero and the value on the stack. |
8e04863e | 4550 | We could get a random floating-point number between @mathit{-1} and 1 by typing |
a4231b04 | 4551 | @w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in |
d7b8e6c6 EZ |
4552 | this square, then use vector mapping and reduction to count how many |
4553 | points lie inside the unit circle. Hint: Use the @kbd{v b} command. | |
4554 | @xref{List Answer 11, 11}. (@bullet{}) | |
4555 | ||
4556 | @cindex Matchstick problem | |
4557 | (@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides | |
a4231b04 | 4558 | another way to calculate @cpi{}. Say you have an infinite field |
d7b8e6c6 EZ |
4559 | of vertical lines with a spacing of one inch. Toss a one-inch matchstick |
4560 | onto the field. The probability that the matchstick will land crossing | |
a4231b04 | 4561 | a line turns out to be |
8e04863e | 4562 | @texline @math{2/\pi}. |
a4231b04 JB |
4563 | @infoline @expr{2/pi}. |
4564 | Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun, | |
4565 | the probability that the GCD (@w{@kbd{k g}}) of two large integers is | |
4566 | one turns out to be | |
8e04863e | 4567 | @texline @math{6/\pi^2}. |
a4231b04 JB |
4568 | @infoline @expr{6/pi^2}. |
4569 | That provides yet another way to estimate @cpi{}.) | |
d7b8e6c6 EZ |
4570 | @xref{List Answer 12, 12}. (@bullet{}) |
4571 | ||
4572 | (@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in | |
4573 | double-quote marks, @samp{"hello"}, creates a vector of the numerical | |
a4231b04 | 4574 | (ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}). |
d7b8e6c6 EZ |
4575 | Sometimes it is convenient to compute a @dfn{hash code} of a string, |
4576 | which is just an integer that represents the value of that string. | |
4577 | Two equal strings have the same hash code; two different strings | |
4578 | @dfn{probably} have different hash codes. (For example, Calc has | |
4579 | over 400 function names, but Emacs can quickly find the definition for | |
4580 | any given name because it has sorted the functions into ``buckets'' by | |
4581 | their hash codes. Sometimes a few names will hash into the same bucket, | |
4582 | but it is easier to search among a few names than among all the names.) | |
a4231b04 JB |
4583 | One popular hash function is computed as follows: First set @expr{h = 0}. |
4584 | Then, for each character from the string in turn, set @expr{h = 3h + c_i} | |
4585 | where @expr{c_i} is the character's ASCII code. If we have 511 buckets, | |
d7b8e6c6 EZ |
4586 | we then take the hash code modulo 511 to get the bucket number. Develop a |
4587 | simple command or commands for converting string vectors into hash codes. | |
4588 | The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo | |
4589 | 511 is 121. @xref{List Answer 13, 13}. (@bullet{}) | |
4590 | ||
4591 | (@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U} | |
4592 | commands do nested function evaluations. @kbd{H V U} takes a starting | |
4593 | value and a number of steps @var{n} from the stack; it then applies the | |
4594 | function you give to the starting value 0, 1, 2, up to @var{n} times | |
4595 | and returns a vector of the results. Use this command to create a | |
4596 | ``random walk'' of 50 steps. Start with the two-dimensional point | |
8e04863e | 4597 | @expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1 |
a4231b04 | 4598 | in both @expr{x} and @expr{y}; then take another step, and so on. Use the |
d7b8e6c6 EZ |
4599 | @kbd{g f} command to display this random walk. Now modify your random |
4600 | walk to walk a unit distance, but in a random direction, at each step. | |
4601 | (Hint: The @code{sincos} function returns a vector of the cosine and | |
4602 | sine of an angle.) @xref{List Answer 14, 14}. (@bullet{}) | |
4603 | ||
4604 | @node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial | |
4605 | @section Types Tutorial | |
4606 | ||
4607 | @noindent | |
4608 | Calc understands a variety of data types as well as simple numbers. | |
4609 | In this section, we'll experiment with each of these types in turn. | |
4610 | ||
4611 | The numbers we've been using so far have mainly been either @dfn{integers} | |
4612 | or @dfn{floats}. We saw that floats are usually a good approximation to | |
4613 | the mathematical concept of real numbers, but they are only approximations | |
4614 | and are susceptible to roundoff error. Calc also supports @dfn{fractions}, | |
4615 | which can exactly represent any rational number. | |
4616 | ||
d7b8e6c6 | 4617 | @smallexample |
5d67986c | 4618 | @group |
d7b8e6c6 EZ |
4619 | 1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414 |
4620 | . 1: 49 . . . | |
4621 | . | |
4622 | ||
5d67986c | 4623 | 10 ! 49 @key{RET} : 2 + & |
d7b8e6c6 | 4624 | @end group |
5d67986c | 4625 | @end smallexample |
d7b8e6c6 EZ |
4626 | |
4627 | @noindent | |
4628 | The @kbd{:} command divides two integers to get a fraction; @kbd{/} | |
4629 | would normally divide integers to get a floating-point result. | |
4630 | Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:} | |
4631 | since the @kbd{:} would otherwise be interpreted as part of a | |
4632 | fraction beginning with 49. | |
4633 | ||
4634 | You can convert between floating-point and fractional format using | |
4635 | @kbd{c f} and @kbd{c F}: | |
4636 | ||
d7b8e6c6 | 4637 | @smallexample |
5d67986c | 4638 | @group |
d7b8e6c6 EZ |
4639 | 1: 1.35027217629e-5 1: 7:518414 |
4640 | . . | |
4641 | ||
4642 | c f c F | |
d7b8e6c6 | 4643 | @end group |
5d67986c | 4644 | @end smallexample |
d7b8e6c6 EZ |
4645 | |
4646 | The @kbd{c F} command replaces a floating-point number with the | |
4647 | ``simplest'' fraction whose floating-point representation is the | |
4648 | same, to within the current precision. | |
4649 | ||
d7b8e6c6 | 4650 | @smallexample |
5d67986c | 4651 | @group |
d7b8e6c6 EZ |
4652 | 1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113 |
4653 | . . . . | |
4654 | ||
5d67986c | 4655 | P c F @key{DEL} p 5 @key{RET} P c F |
d7b8e6c6 | 4656 | @end group |
5d67986c | 4657 | @end smallexample |
d7b8e6c6 EZ |
4658 | |
4659 | (@bullet{}) @strong{Exercise 1.} A calculation has produced the | |
4660 | result 1.26508260337. You suspect it is the square root of the | |
a4231b04 | 4661 | product of @cpi{} and some rational number. Is it? (Be sure |
d7b8e6c6 EZ |
4662 | to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{}) |
4663 | ||
4664 | @dfn{Complex numbers} can be stored in both rectangular and polar form. | |
4665 | ||
d7b8e6c6 | 4666 | @smallexample |
5d67986c | 4667 | @group |
d7b8e6c6 EZ |
4668 | 1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.) |
4669 | . . . . . | |
4670 | ||
4671 | 9 n Q c p 2 * Q | |
d7b8e6c6 | 4672 | @end group |
5d67986c | 4673 | @end smallexample |
d7b8e6c6 EZ |
4674 | |
4675 | @noindent | |
8e04863e | 4676 | The square root of @mathit{-9} is by default rendered in rectangular form |
a4231b04 | 4677 | (@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a |
d7b8e6c6 EZ |
4678 | phase angle of 90 degrees). All the usual arithmetic and scientific |
4679 | operations are defined on both types of complex numbers. | |
4680 | ||
4681 | Another generalized kind of number is @dfn{infinity}. Infinity | |
4682 | isn't really a number, but it can sometimes be treated like one. | |
4683 | Calc uses the symbol @code{inf} to represent positive infinity, | |
4684 | i.e., a value greater than any real number. Naturally, you can | |
4685 | also write @samp{-inf} for minus infinity, a value less than any | |
4686 | real number. The word @code{inf} can only be input using | |
4687 | algebraic entry. | |
4688 | ||
d7b8e6c6 | 4689 | @smallexample |
5d67986c | 4690 | @group |
d7b8e6c6 EZ |
4691 | 2: inf 2: -inf 2: -inf 2: -inf 1: nan |
4692 | 1: -17 1: -inf 1: -inf 1: inf . | |
4693 | . . . . | |
4694 | ||
5d67986c | 4695 | ' inf @key{RET} 17 n * @key{RET} 72 + A + |
d7b8e6c6 | 4696 | @end group |
5d67986c | 4697 | @end smallexample |
d7b8e6c6 EZ |
4698 | |
4699 | @noindent | |
4700 | Since infinity is infinitely large, multiplying it by any finite | |
8e04863e | 4701 | number (like @mathit{-17}) has no effect, except that since @mathit{-17} |
d7b8e6c6 | 4702 | is negative, it changes a plus infinity to a minus infinity. |
8e04863e | 4703 | (``A huge positive number, multiplied by @mathit{-17}, yields a huge |
d7b8e6c6 EZ |
4704 | negative number.'') Adding any finite number to infinity also |
4705 | leaves it unchanged. Taking an absolute value gives us plus | |
4706 | infinity again. Finally, we add this plus infinity to the minus | |
4707 | infinity we had earlier. If you work it out, you might expect | |
8e04863e | 4708 | the answer to be @mathit{-72} for this. But the 72 has been completely |
d7b8e6c6 | 4709 | lost next to the infinities; by the time we compute @w{@samp{inf - inf}} |
28665d46 | 4710 | the finite difference between them, if any, is undetectable. |
d7b8e6c6 EZ |
4711 | So we say the result is @dfn{indeterminate}, which Calc writes |
4712 | with the symbol @code{nan} (for Not A Number). | |
4713 | ||
4714 | Dividing by zero is normally treated as an error, but you can get | |
4715 | Calc to write an answer in terms of infinity by pressing @kbd{m i} | |
07ce2eb3 | 4716 | to turn on Infinite mode. |
d7b8e6c6 | 4717 | |
d7b8e6c6 | 4718 | @smallexample |
5d67986c | 4719 | @group |
d7b8e6c6 EZ |
4720 | 3: nan 2: nan 2: nan 2: nan 1: nan |
4721 | 2: 1 1: 1 / 0 1: uinf 1: uinf . | |
4722 | 1: 0 . . . | |
4723 | . | |
4724 | ||
5d67986c | 4725 | 1 @key{RET} 0 / m i U / 17 n * + |
d7b8e6c6 | 4726 | @end group |
5d67986c | 4727 | @end smallexample |
d7b8e6c6 EZ |
4728 | |
4729 | @noindent | |
4730 | Dividing by zero normally is left unevaluated, but after @kbd{m i} | |
4731 | it instead gives an infinite result. The answer is actually | |
4732 | @code{uinf}, ``undirected infinity.'' If you look at a graph of | |
a4231b04 | 4733 | @expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward |
d7b8e6c6 | 4734 | plus infinity as you approach zero from above, but toward minus |
a4231b04 | 4735 | infinity as you approach from below. Since we said only @expr{1 / 0}, |
d7b8e6c6 EZ |
4736 | Calc knows that the answer is infinite but not in which direction. |
4737 | That's what @code{uinf} means. Notice that multiplying @code{uinf} | |
4738 | by a negative number still leaves plain @code{uinf}; there's no | |
4739 | point in saying @samp{-uinf} because the sign of @code{uinf} is | |
4740 | unknown anyway. Finally, we add @code{uinf} to our @code{nan}, | |
4741 | yielding @code{nan} again. It's easy to see that, because | |
4742 | @code{nan} means ``totally unknown'' while @code{uinf} means | |
4743 | ``unknown sign but known to be infinite,'' the more mysterious | |
4744 | @code{nan} wins out when it is combined with @code{uinf}, or, for | |
4745 | that matter, with anything else. | |
4746 | ||
4747 | (@bullet{}) @strong{Exercise 2.} Predict what Calc will answer | |
4748 | for each of these formulas: @samp{inf / inf}, @samp{exp(inf)}, | |
4749 | @samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)}, | |
4750 | @samp{abs(uinf)}, @samp{ln(0)}. | |
4751 | @xref{Types Answer 2, 2}. (@bullet{}) | |
4752 | ||
4753 | (@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan}, | |
4754 | which stands for an unknown value. Can @code{nan} stand for | |
4755 | a complex number? Can it stand for infinity? | |
4756 | @xref{Types Answer 3, 3}. (@bullet{}) | |
4757 | ||
4758 | @dfn{HMS forms} represent a value in terms of hours, minutes, and | |
4759 | seconds. | |
4760 | ||
d7b8e6c6 | 4761 | @smallexample |
5d67986c | 4762 | @group |
d7b8e6c6 EZ |
4763 | 1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2. |
4764 | . . 1: 1@@ 45' 0." . | |
4765 | . | |
4766 | ||
5d67986c | 4767 | 2@@ 30' @key{RET} 1 + @key{RET} 2 / / |
d7b8e6c6 | 4768 | @end group |
5d67986c | 4769 | @end smallexample |
d7b8e6c6 EZ |
4770 | |
4771 | HMS forms can also be used to hold angles in degrees, minutes, and | |
4772 | seconds. | |
4773 | ||
d7b8e6c6 | 4774 | @smallexample |
5d67986c | 4775 | @group |
d7b8e6c6 EZ |
4776 | 1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721 |
4777 | . . . . | |
4778 | ||
4779 | 0.5 I T c h S | |
d7b8e6c6 | 4780 | @end group |
5d67986c | 4781 | @end smallexample |
d7b8e6c6 EZ |
4782 | |
4783 | @noindent | |
4784 | First we convert the inverse tangent of 0.5 to degrees-minutes-seconds | |
4785 | form, then we take the sine of that angle. Note that the trigonometric | |
4786 | functions will accept HMS forms directly as input. | |
4787 | ||
4788 | @cindex Beatles | |
4789 | (@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is | |
4790 | 47 minutes and 26 seconds long, and contains 17 songs. What is the | |
4791 | average length of a song on @emph{Abbey Road}? If the Extended Disco | |
4792 | Version of @emph{Abbey Road} added 20 seconds to the length of each | |
4793 | song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{}) | |
4794 | ||
4795 | A @dfn{date form} represents a date, or a date and time. Dates must | |
4796 | be entered using algebraic entry. Date forms are surrounded by | |
4797 | @samp{< >} symbols; most standard formats for dates are recognized. | |
4798 | ||
d7b8e6c6 | 4799 | @smallexample |
5d67986c | 4800 | @group |
d7b8e6c6 EZ |
4801 | 2: <Sun Jan 13, 1991> 1: 2.25 |
4802 | 1: <6:00pm Thu Jan 10, 1991> . | |
4803 | . | |
4804 | ||
5d67986c | 4805 | ' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} - |
d7b8e6c6 | 4806 | @end group |
5d67986c | 4807 | @end smallexample |
d7b8e6c6 EZ |
4808 | |
4809 | @noindent | |
4810 | In this example, we enter two dates, then subtract to find the | |
4811 | number of days between them. It is also possible to add an | |
4812 | HMS form or a number (of days) to a date form to get another | |
4813 | date form. | |
4814 | ||
d7b8e6c6 | 4815 | @smallexample |
5d67986c | 4816 | @group |
d7b8e6c6 EZ |
4817 | 1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991> |
4818 | . . | |
4819 | ||
4820 | t N 2 + 10@@ 5' + | |
d7b8e6c6 | 4821 | @end group |
5d67986c | 4822 | @end smallexample |
d7b8e6c6 EZ |
4823 | |
4824 | @c [fix-ref Date Arithmetic] | |
4825 | @noindent | |
4826 | The @kbd{t N} (``now'') command pushes the current date and time on the | |
4827 | stack; then we add two days, ten hours and five minutes to the date and | |
4828 | time. Other date-and-time related commands include @kbd{t J}, which | |
4829 | does Julian day conversions, @kbd{t W}, which finds the beginning of | |
4830 | the week in which a date form lies, and @kbd{t I}, which increments a | |
4831 | date by one or several months. @xref{Date Arithmetic}, for more. | |
4832 | ||
4833 | (@bullet{}) @strong{Exercise 5.} How many days until the next | |
4834 | Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{}) | |
4835 | ||
4836 | (@bullet{}) @strong{Exercise 6.} How many leap years will there be | |
4837 | between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{}) | |
4838 | ||
4839 | @cindex Slope and angle of a line | |
4840 | @cindex Angle and slope of a line | |
4841 | An @dfn{error form} represents a mean value with an attached standard | |
4842 | deviation, or error estimate. Suppose our measurements indicate that | |
4843 | a certain telephone pole is about 30 meters away, with an estimated | |
4844 | error of 1 meter, and 8 meters tall, with an estimated error of 0.2 | |
4845 | meters. What is the slope of a line from here to the top of the | |
4846 | pole, and what is the equivalent angle in degrees? | |
4847 | ||
d7b8e6c6 | 4848 | @smallexample |
5d67986c | 4849 | @group |
d7b8e6c6 EZ |
4850 | 1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594 |
4851 | . 1: 30 +/- 1 . . | |
4852 | . | |
4853 | ||
5d67986c | 4854 | 8 p .2 @key{RET} 30 p 1 / I T |
d7b8e6c6 | 4855 | @end group |
5d67986c | 4856 | @end smallexample |
d7b8e6c6 EZ |
4857 | |
4858 | @noindent | |
4859 | This means that the angle is about 15 degrees, and, assuming our | |
4860 | original error estimates were valid standard deviations, there is about | |
4861 | a 60% chance that the result is correct within 0.59 degrees. | |
4862 | ||
4863 | @cindex Torus, volume of | |
4864 | (@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is | |
8e04863e | 4865 | @texline @math{2 \pi^2 R r^2} |
a4231b04 JB |
4866 | @infoline @w{@expr{2 pi^2 R r^2}} |
4867 | where @expr{R} is the radius of the circle that | |
4868 | defines the center of the tube and @expr{r} is the radius of the tube | |
4869 | itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to | |
d7b8e6c6 EZ |
4870 | within 5 percent. What is the volume and the relative uncertainty of |
4871 | the volume? @xref{Types Answer 7, 7}. (@bullet{}) | |
4872 | ||
4873 | An @dfn{interval form} represents a range of values. While an | |
4874 | error form is best for making statistical estimates, intervals give | |
4875 | you exact bounds on an answer. Suppose we additionally know that | |
4876 | our telephone pole is definitely between 28 and 31 meters away, | |
4877 | and that it is between 7.7 and 8.1 meters tall. | |
4878 | ||
d7b8e6c6 | 4879 | @smallexample |
5d67986c | 4880 | @group |
d7b8e6c6 EZ |
4881 | 1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1] |
4882 | . 1: [28 .. 31] . . | |
4883 | . | |
4884 | ||
4885 | [ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T | |
d7b8e6c6 | 4886 | @end group |
5d67986c | 4887 | @end smallexample |
d7b8e6c6 EZ |
4888 | |
4889 | @noindent | |
4890 | If our bounds were correct, then the angle to the top of the pole | |
4891 | is sure to lie in the range shown. | |
4892 | ||
4893 | The square brackets around these intervals indicate that the endpoints | |
4894 | themselves are allowable values. In other words, the distance to the | |
4895 | telephone pole is between 28 and 31, @emph{inclusive}. You can also | |
4896 | make an interval that is exclusive of its endpoints by writing | |
4897 | parentheses instead of square brackets. You can even make an interval | |
4898 | which is inclusive (``closed'') on one end and exclusive (``open'') on | |
4899 | the other. | |
4900 | ||
d7b8e6c6 | 4901 | @smallexample |
5d67986c | 4902 | @group |
d7b8e6c6 EZ |
4903 | 1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3) |
4904 | . . 1: [2 .. 3) . | |
4905 | . | |
4906 | ||
4907 | [ 1 .. 10 ) & [ 2 .. 3 ) * | |
d7b8e6c6 | 4908 | @end group |
5d67986c | 4909 | @end smallexample |
d7b8e6c6 EZ |
4910 | |
4911 | @noindent | |
4912 | The Calculator automatically keeps track of which end values should | |
4913 | be open and which should be closed. You can also make infinite or | |
4914 | semi-infinite intervals by using @samp{-inf} or @samp{inf} for one | |
4915 | or both endpoints. | |
4916 | ||
4917 | (@bullet{}) @strong{Exercise 8.} What answer would you expect from | |
4918 | @samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What | |
4919 | about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes | |
4920 | zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}? | |
4921 | @xref{Types Answer 8, 8}. (@bullet{}) | |
4922 | ||
4923 | (@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number | |
5d67986c | 4924 | are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same |
d7b8e6c6 EZ |
4925 | answer. Would you expect this still to hold true for interval forms? |
4926 | If not, which of these will result in a larger interval? | |
4927 | @xref{Types Answer 9, 9}. (@bullet{}) | |
4928 | ||
5d67986c | 4929 | A @dfn{modulo form} is used for performing arithmetic modulo @var{m}. |
d7b8e6c6 EZ |
4930 | For example, arithmetic involving time is generally done modulo 12 |
4931 | or 24 hours. | |
4932 | ||
d7b8e6c6 | 4933 | @smallexample |
5d67986c | 4934 | @group |
d7b8e6c6 EZ |
4935 | 1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24 |
4936 | . . . . | |
4937 | ||
5d67986c | 4938 | 17 M 24 @key{RET} 10 + n 5 / |
d7b8e6c6 | 4939 | @end group |
5d67986c | 4940 | @end smallexample |
d7b8e6c6 EZ |
4941 | |
4942 | @noindent | |
e9a2654a JB |
4943 | In this last step, Calc has divided by 5 modulo 24; i.e., it has found a |
4944 | new number which, when multiplied by 5 modulo 24, produces the original | |
4945 | number, 21. If @var{m} is prime and the divisor is not a multiple of | |
4946 | @var{m}, it is always possible to find such a number. For non-prime | |
4947 | @var{m} like 24, it is only sometimes possible. | |
d7b8e6c6 | 4948 | |
d7b8e6c6 | 4949 | @smallexample |
5d67986c | 4950 | @group |
d7b8e6c6 EZ |
4951 | 1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16 |
4952 | . . . . | |
4953 | ||
5d67986c | 4954 | 10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 % |
d7b8e6c6 | 4955 | @end group |
5d67986c | 4956 | @end smallexample |
d7b8e6c6 EZ |
4957 | |
4958 | @noindent | |
4959 | These two calculations get the same answer, but the first one is | |
4960 | much more efficient because it avoids the huge intermediate value | |
4961 | that arises in the second one. | |
4962 | ||
4963 | @cindex Fermat, primality test of | |
4964 | (@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat | |
a4231b04 | 4965 | says that |
8e04863e | 4966 | @texline @w{@math{x^{n-1} \bmod n = 1}} |
a4231b04 JB |
4967 | @infoline @expr{x^(n-1) mod n = 1} |
4968 | if @expr{n} is a prime number and @expr{x} is an integer less than | |
4969 | @expr{n}. If @expr{n} is @emph{not} a prime number, this will | |
4970 | @emph{not} be true for most values of @expr{x}. Thus we can test | |
4971 | informally if a number is prime by trying this formula for several | |
4972 | values of @expr{x}. Use this test to tell whether the following numbers | |
4973 | are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{}) | |
d7b8e6c6 EZ |
4974 | |
4975 | It is possible to use HMS forms as parts of error forms, intervals, | |
4976 | modulo forms, or as the phase part of a polar complex number. | |
4977 | For example, the @code{calc-time} command pushes the current time | |
4978 | of day on the stack as an HMS/modulo form. | |
4979 | ||
d7b8e6c6 | 4980 | @smallexample |
5d67986c | 4981 | @group |
d7b8e6c6 EZ |
4982 | 1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0" |
4983 | . . | |
4984 | ||
5d67986c | 4985 | x time @key{RET} n |
d7b8e6c6 | 4986 | @end group |
5d67986c | 4987 | @end smallexample |
d7b8e6c6 EZ |
4988 | |
4989 | @noindent | |
4990 | This calculation tells me it is six hours and 22 minutes until midnight. | |
4991 | ||
4992 | (@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year | |
a4231b04 | 4993 | is about |
8e04863e | 4994 | @texline @math{\pi \times 10^7} |
a4231b04 JB |
4995 | @infoline @w{@expr{pi * 10^7}} |
4996 | seconds. What time will it be that many seconds from right now? | |
4997 | @xref{Types Answer 11, 11}. (@bullet{}) | |
d7b8e6c6 EZ |
4998 | |
4999 | (@bullet{}) @strong{Exercise 12.} You are preparing to order packaging | |
5000 | for the CD release of the Extended Disco Version of @emph{Abbey Road}. | |
5001 | You are told that the songs will actually be anywhere from 20 to 60 | |
5002 | seconds longer than the originals. One CD can hold about 75 minutes | |
5003 | of music. Should you order single or double packages? | |
5004 | @xref{Types Answer 12, 12}. (@bullet{}) | |
5005 | ||
5006 | Another kind of data the Calculator can manipulate is numbers with | |
5007 | @dfn{units}. This isn't strictly a new data type; it's simply an | |
5008 | application of algebraic expressions, where we use variables with | |
5009 | suggestive names like @samp{cm} and @samp{in} to represent units | |
5010 | like centimeters and inches. | |
5011 | ||
d7b8e6c6 | 5012 | @smallexample |
5d67986c | 5013 | @group |
d7b8e6c6 EZ |
5014 | 1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m |
5015 | . . . . | |
5016 | ||
5d67986c | 5017 | ' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b |
d7b8e6c6 | 5018 | @end group |
5d67986c | 5019 | @end smallexample |
d7b8e6c6 EZ |
5020 | |
5021 | @noindent | |
5022 | We enter the quantity ``2 inches'' (actually an algebraic expression | |
5023 | which means two times the variable @samp{in}), then we convert it | |
5024 | first to centimeters, then to fathoms, then finally to ``base'' units, | |
5025 | which in this case means meters. | |
5026 | ||
d7b8e6c6 | 5027 | @smallexample |
5d67986c | 5028 | @group |
d7b8e6c6 EZ |
5029 | 1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm |
5030 | . . . . | |
5031 | ||
5d67986c | 5032 | ' 9 acre @key{RET} Q u s ' $+30 cm @key{RET} |
d7b8e6c6 | 5033 | |
d7b8e6c6 | 5034 | @end group |
5d67986c | 5035 | @end smallexample |
d7b8e6c6 | 5036 | @noindent |
d7b8e6c6 | 5037 | @smallexample |
5d67986c | 5038 | @group |
d7b8e6c6 EZ |
5039 | 1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2 |
5040 | . . . | |
5041 | ||
5042 | u s 2 ^ u c cgs | |
d7b8e6c6 | 5043 | @end group |
5d67986c | 5044 | @end smallexample |
d7b8e6c6 EZ |
5045 | |
5046 | @noindent | |
5047 | Since units expressions are really just formulas, taking the square | |
5048 | root of @samp{acre} is undefined. After all, @code{acre} might be an | |
5049 | algebraic variable that you will someday assign a value. We use the | |
5050 | ``units-simplify'' command to simplify the expression with variables | |
5051 | being interpreted as unit names. | |
5052 | ||
5053 | In the final step, we have converted not to a particular unit, but to a | |
5054 | units system. The ``cgs'' system uses centimeters instead of meters | |
5055 | as its standard unit of length. | |
5056 | ||
5057 | There is a wide variety of units defined in the Calculator. | |
5058 | ||
d7b8e6c6 | 5059 | @smallexample |
5d67986c | 5060 | @group |
d7b8e6c6 EZ |
5061 | 1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c |
5062 | . . . . | |
5063 | ||
5d67986c | 5064 | ' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET} |
d7b8e6c6 | 5065 | @end group |
5d67986c | 5066 | @end smallexample |
d7b8e6c6 EZ |
5067 | |
5068 | @noindent | |
5069 | We express a speed first in miles per hour, then in kilometers per | |
5070 | hour, then again using a slightly more explicit notation, then | |
5071 | finally in terms of fractions of the speed of light. | |
5072 | ||
5073 | Temperature conversions are a bit more tricky. There are two ways to | |
5074 | interpret ``20 degrees Fahrenheit''---it could mean an actual | |
5075 | temperature, or it could mean a change in temperature. For normal | |
5076 | units there is no difference, but temperature units have an offset | |
5077 | as well as a scale factor and so there must be two explicit commands | |
5078 | for them. | |
5079 | ||
d7b8e6c6 | 5080 | @smallexample |
5d67986c | 5081 | @group |
d7b8e6c6 EZ |
5082 | 1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC |
5083 | . . . . | |
5084 | ||
5d67986c | 5085 | ' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f |
d7b8e6c6 | 5086 | @end group |
5d67986c | 5087 | @end smallexample |
d7b8e6c6 EZ |
5088 | |
5089 | @noindent | |
5090 | First we convert a change of 20 degrees Fahrenheit into an equivalent | |
5091 | change in degrees Celsius (or Centigrade). Then, we convert the | |
5092 | absolute temperature 20 degrees Fahrenheit into Celsius. Since | |
5093 | this comes out as an exact fraction, we then convert to floating-point | |
5094 | for easier comparison with the other result. | |
5095 | ||
5096 | For simple unit conversions, you can put a plain number on the stack. | |
5097 | Then @kbd{u c} and @kbd{u t} will prompt for both old and new units. | |
5098 | When you use this method, you're responsible for remembering which | |
5099 | numbers are in which units: | |
5100 | ||
d7b8e6c6 | 5101 | @smallexample |
5d67986c | 5102 | @group |
d7b8e6c6 EZ |
5103 | 1: 55 1: 88.5139 1: 8.201407e-8 |
5104 | . . . | |
5105 | ||
5d67986c | 5106 | 55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET} |
d7b8e6c6 | 5107 | @end group |
5d67986c | 5108 | @end smallexample |
d7b8e6c6 EZ |
5109 | |
5110 | To see a complete list of built-in units, type @kbd{u v}. Press | |
58547c3e | 5111 | @w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking |
d7b8e6c6 EZ |
5112 | at the units table. |
5113 | ||
5114 | (@bullet{}) @strong{Exercise 13.} How many seconds are there really | |
5115 | in a year? @xref{Types Answer 13, 13}. (@bullet{}) | |
5116 | ||
5117 | @cindex Speed of light | |
5118 | (@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by | |
5119 | the speed of light (and of electricity, which is nearly as fast). | |
5120 | Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its | |
5121 | cabinet is one meter across. Is speed of light going to be a | |
5122 | significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{}) | |
5123 | ||
5124 | (@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about | |
5125 | five yards in an hour. He has obtained a supply of Power Pills; each | |
5126 | Power Pill he eats doubles his speed. How many Power Pills can he | |
5127 | swallow and still travel legally on most US highways? | |
5128 | @xref{Types Answer 15, 15}. (@bullet{}) | |
5129 | ||
5130 | @node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial | |
5131 | @section Algebra and Calculus Tutorial | |
5132 | ||
5133 | @noindent | |
5134 | This section shows how to use Calc's algebra facilities to solve | |
5135 | equations, do simple calculus problems, and manipulate algebraic | |
5136 | formulas. | |
5137 | ||
5138 | @menu | |
5139 | * Basic Algebra Tutorial:: | |
5140 | * Rewrites Tutorial:: | |
5141 | @end menu | |
5142 | ||
5143 | @node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial | |
5144 | @subsection Basic Algebra | |
5145 | ||
5146 | @noindent | |
07ce2eb3 | 5147 | If you enter a formula in Algebraic mode that refers to variables, |
d7b8e6c6 EZ |
5148 | the formula itself is pushed onto the stack. You can manipulate |
5149 | formulas as regular data objects. | |
5150 | ||
d7b8e6c6 | 5151 | @smallexample |
5d67986c | 5152 | @group |
d7b8e6c6 EZ |
5153 | 1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y) |
5154 | . . . | |
5155 | ||
5d67986c | 5156 | ' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} * |
d7b8e6c6 | 5157 | @end group |
5d67986c | 5158 | @end smallexample |
d7b8e6c6 | 5159 | |
5d67986c RS |
5160 | (@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and |
5161 | @kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})? | |
d7b8e6c6 EZ |
5162 | Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{}) |
5163 | ||
5164 | There are also commands for doing common algebraic operations on | |
5165 | formulas. Continuing with the formula from the last example, | |
5166 | ||
d7b8e6c6 | 5167 | @smallexample |
5d67986c | 5168 | @group |
d7b8e6c6 EZ |
5169 | 1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y |
5170 | . . | |
5171 | ||
5d67986c | 5172 | a x a c x @key{RET} |
d7b8e6c6 | 5173 | @end group |
5d67986c | 5174 | @end smallexample |
d7b8e6c6 EZ |
5175 | |
5176 | @noindent | |
5177 | First we ``expand'' using the distributive law, then we ``collect'' | |
a4231b04 | 5178 | terms involving like powers of @expr{x}. |
d7b8e6c6 | 5179 | |
a4231b04 | 5180 | Let's find the value of this expression when @expr{x} is 2 and @expr{y} |
d7b8e6c6 EZ |
5181 | is one-half. |
5182 | ||
d7b8e6c6 | 5183 | @smallexample |
5d67986c | 5184 | @group |
d7b8e6c6 EZ |
5185 | 1: 17 x^2 - 6 x^4 + 3 1: -25 |
5186 | . . | |
5187 | ||
5d67986c | 5188 | 1:2 s l y @key{RET} 2 s l x @key{RET} |
d7b8e6c6 | 5189 | @end group |
5d67986c | 5190 | @end smallexample |
d7b8e6c6 EZ |
5191 | |
5192 | @noindent | |
5193 | The @kbd{s l} command means ``let''; it takes a number from the top of | |
5194 | the stack and temporarily assigns it as the value of the variable | |
5195 | you specify. It then evaluates (as if by the @kbd{=} key) the | |
5196 | next expression on the stack. After this command, the variable goes | |
5197 | back to its original value, if any. | |
5198 | ||
5199 | (An earlier exercise in this tutorial involved storing a value in the | |
5200 | variable @code{x}; if this value is still there, you will have to | |
5d67986c | 5201 | unstore it with @kbd{s u x @key{RET}} before the above example will work |
d7b8e6c6 EZ |
5202 | properly.) |
5203 | ||
5204 | @cindex Maximum of a function using Calculus | |
a4231b04 JB |
5205 | Let's find the maximum value of our original expression when @expr{y} |
5206 | is one-half and @expr{x} ranges over all possible values. We can | |
5207 | do this by taking the derivative with respect to @expr{x} and examining | |
5208 | values of @expr{x} for which the derivative is zero. If the second | |
5209 | derivative of the function at that value of @expr{x} is negative, | |
d7b8e6c6 EZ |
5210 | the function has a local maximum there. |
5211 | ||
d7b8e6c6 | 5212 | @smallexample |
5d67986c | 5213 | @group |
d7b8e6c6 EZ |
5214 | 1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3 |
5215 | . . | |
5216 | ||
5d67986c | 5217 | U @key{DEL} s 1 a d x @key{RET} s 2 |
d7b8e6c6 | 5218 | @end group |
5d67986c | 5219 | @end smallexample |
d7b8e6c6 EZ |
5220 | |
5221 | @noindent | |
a4231b04 JB |
5222 | Well, the derivative is clearly zero when @expr{x} is zero. To find |
5223 | the other root(s), let's divide through by @expr{x} and then solve: | |
d7b8e6c6 | 5224 | |
d7b8e6c6 | 5225 | @smallexample |
5d67986c | 5226 | @group |
d7b8e6c6 EZ |
5227 | 1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2 |
5228 | . . . | |
5229 | ||
5d67986c | 5230 | ' x @key{RET} / a x a s |
d7b8e6c6 | 5231 | |
d7b8e6c6 | 5232 | @end group |
5d67986c | 5233 | @end smallexample |
d7b8e6c6 | 5234 | @noindent |
d7b8e6c6 | 5235 | @smallexample |
5d67986c | 5236 | @group |
d7b8e6c6 EZ |
5237 | 1: 34 - 24 x^2 = 0 1: x = 1.19023 |
5238 | . . | |
5239 | ||
5d67986c | 5240 | 0 a = s 3 a S x @key{RET} |
d7b8e6c6 | 5241 | @end group |
5d67986c | 5242 | @end smallexample |
d7b8e6c6 EZ |
5243 | |
5244 | @noindent | |
5245 | Notice the use of @kbd{a s} to ``simplify'' the formula. When the | |
5246 | default algebraic simplifications don't do enough, you can use | |
5247 | @kbd{a s} to tell Calc to spend more time on the job. | |
5248 | ||
a4231b04 | 5249 | Now we compute the second derivative and plug in our values of @expr{x}: |
d7b8e6c6 | 5250 | |
d7b8e6c6 | 5251 | @smallexample |
5d67986c | 5252 | @group |
d7b8e6c6 EZ |
5253 | 1: 1.19023 2: 1.19023 2: 1.19023 |
5254 | . 1: 34 x - 24 x^3 1: 34 - 72 x^2 | |
5255 | . . | |
5256 | ||
5d67986c | 5257 | a . r 2 a d x @key{RET} s 4 |
d7b8e6c6 | 5258 | @end group |
5d67986c | 5259 | @end smallexample |
d7b8e6c6 EZ |
5260 | |
5261 | @noindent | |
5262 | (The @kbd{a .} command extracts just the righthand side of an equation. | |
5263 | Another method would have been to use @kbd{v u} to unpack the equation | |
5d67986c | 5264 | @w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}} |
d7b8e6c6 EZ |
5265 | to delete the @samp{x}.) |
5266 | ||
d7b8e6c6 | 5267 | @smallexample |
5d67986c | 5268 | @group |
d7b8e6c6 EZ |
5269 | 2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34 |
5270 | 1: 1.19023 . 1: 0 . | |
5271 | . . | |
5272 | ||
5d67986c | 5273 | @key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET} |
d7b8e6c6 | 5274 | @end group |
5d67986c | 5275 | @end smallexample |
d7b8e6c6 EZ |
5276 | |
5277 | @noindent | |
5278 | The first of these second derivatives is negative, so we know the function | |
a4231b04 JB |
5279 | has a maximum value at @expr{x = 1.19023}. (The function also has a |
5280 | local @emph{minimum} at @expr{x = 0}.) | |
d7b8e6c6 | 5281 | |
a4231b04 JB |
5282 | When we solved for @expr{x}, we got only one value even though |
5283 | @expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have | |
d7b8e6c6 EZ |
5284 | two solutions. The reason is that @w{@kbd{a S}} normally returns a |
5285 | single ``principal'' solution. If it needs to come up with an | |
a4231b04 | 5286 | arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}. |
d7b8e6c6 EZ |
5287 | If it needs an arbitrary integer, it picks zero. We can get a full |
5288 | solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}. | |
5289 | ||
d7b8e6c6 | 5290 | @smallexample |
5d67986c | 5291 | @group |
d7b8e6c6 EZ |
5292 | 1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023 |
5293 | . . . | |
5294 | ||
5d67986c | 5295 | r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET} |
d7b8e6c6 | 5296 | @end group |
5d67986c | 5297 | @end smallexample |
d7b8e6c6 EZ |
5298 | |
5299 | @noindent | |
5300 | Calc has invented the variable @samp{s1} to represent an unknown sign; | |
8e04863e | 5301 | it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used |
d7b8e6c6 EZ |
5302 | the ``let'' command to evaluate the expression when the sign is negative. |
5303 | If we plugged this into our second derivative we would get the same, | |
a4231b04 | 5304 | negative, answer, so @expr{x = -1.19023} is also a maximum. |
d7b8e6c6 | 5305 | |
a4231b04 | 5306 | To find the actual maximum value, we must plug our two values of @expr{x} |
d7b8e6c6 EZ |
5307 | into the original formula. |
5308 | ||
d7b8e6c6 | 5309 | @smallexample |
5d67986c | 5310 | @group |
d7b8e6c6 EZ |
5311 | 2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3 |
5312 | 1: x = 1.19023 s1 . | |
5313 | . | |
5314 | ||
5d67986c | 5315 | r 1 r 5 s l @key{RET} |
d7b8e6c6 | 5316 | @end group |
5d67986c | 5317 | @end smallexample |
d7b8e6c6 EZ |
5318 | |
5319 | @noindent | |
5320 | (Here we see another way to use @kbd{s l}; if its input is an equation | |
5321 | with a variable on the lefthand side, then @kbd{s l} treats the equation | |
5322 | like an assignment to that variable if you don't give a variable name.) | |
5323 | ||
5324 | It's clear that this will have the same value for either sign of | |
5325 | @code{s1}, but let's work it out anyway, just for the exercise: | |
5326 | ||
d7b8e6c6 | 5327 | @smallexample |
5d67986c | 5328 | @group |
d7b8e6c6 EZ |
5329 | 2: [-1, 1] 1: [15.04166, 15.04166] |
5330 | 1: 24.08333 s1^2 ... . | |
5331 | . | |
5332 | ||
5d67986c | 5333 | [ 1 n , 1 ] @key{TAB} V M $ @key{RET} |
d7b8e6c6 | 5334 | @end group |
5d67986c | 5335 | @end smallexample |
d7b8e6c6 EZ |
5336 | |
5337 | @noindent | |
5338 | Here we have used a vector mapping operation to evaluate the function | |
5339 | at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '} | |
5340 | except that it takes the formula from the top of the stack. The | |
5341 | formula is interpreted as a function to apply across the vector at the | |
5342 | next-to-top stack level. Since a formula on the stack can't contain | |
5343 | @samp{$} signs, Calc assumes the variables in the formula stand for | |
5344 | different arguments. It prompts you for an @dfn{argument list}, giving | |
5345 | the list of all variables in the formula in alphabetical order as the | |
5346 | default list. In this case the default is @samp{(s1)}, which is just | |
5347 | what we want so we simply press @key{RET} at the prompt. | |
5348 | ||
5349 | If there had been several different values, we could have used | |
5350 | @w{@kbd{V R X}} to find the global maximum. | |
5351 | ||
5352 | Calc has a built-in @kbd{a P} command that solves an equation using | |
5353 | @w{@kbd{H a S}} and returns a vector of all the solutions. It simply | |
5354 | automates the job we just did by hand. Applied to our original | |
5355 | cubic polynomial, it would produce the vector of solutions | |
a4231b04 | 5356 | @expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command |
d7b8e6c6 EZ |
5357 | which finds a local maximum of a function. It uses a numerical search |
5358 | method rather than examining the derivatives, and thus requires you | |
5359 | to provide some kind of initial guess to show it where to look.) | |
5360 | ||
5361 | (@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a | |
5362 | polynomial (such as the output of an @kbd{a P} command), what | |
5363 | sequence of commands would you use to reconstruct the original | |
5364 | polynomial? (The answer will be unique to within a constant | |
5365 | multiple; choose the solution where the leading coefficient is one.) | |
5366 | @xref{Algebra Answer 2, 2}. (@bullet{}) | |
5367 | ||
07ce2eb3 | 5368 | The @kbd{m s} command enables Symbolic mode, in which formulas |
d7b8e6c6 EZ |
5369 | like @samp{sqrt(5)} that can't be evaluated exactly are left in |
5370 | symbolic form rather than giving a floating-point approximate answer. | |
5371 | Fraction mode (@kbd{m f}) is also useful when doing algebra. | |
5372 | ||
d7b8e6c6 | 5373 | @smallexample |
5d67986c | 5374 | @group |
d7b8e6c6 EZ |
5375 | 2: 34 x - 24 x^3 2: 34 x - 24 x^3 |
5376 | 1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0] | |
5377 | . . | |
5378 | ||
5d67986c | 5379 | r 2 @key{RET} m s m f a P x @key{RET} |
d7b8e6c6 | 5380 | @end group |
5d67986c | 5381 | @end smallexample |
d7b8e6c6 | 5382 | |
07ce2eb3 | 5383 | One more mode that makes reading formulas easier is Big mode. |
d7b8e6c6 | 5384 | |
d7b8e6c6 | 5385 | @smallexample |
5d67986c | 5386 | @group |
d7b8e6c6 EZ |
5387 | 3 |
5388 | 2: 34 x - 24 x | |
5389 | ||
5390 | ____ ____ | |
5391 | V 51 V 51 | |
5392 | 1: [-----, -----, 0] | |
5393 | 6 -6 | |
5394 | ||
5395 | . | |
5396 | ||
5397 | d B | |
d7b8e6c6 | 5398 | @end group |
5d67986c | 5399 | @end smallexample |
d7b8e6c6 EZ |
5400 | |
5401 | Here things like powers, square roots, and quotients and fractions | |
5402 | are displayed in a two-dimensional pictorial form. Calc has other | |
8ed713c6 | 5403 | language modes as well, such as C mode, FORTRAN mode, @TeX{} mode |
053bc283 | 5404 | and La@TeX{} mode. |
d7b8e6c6 | 5405 | |
d7b8e6c6 | 5406 | @smallexample |
5d67986c | 5407 | @group |
d7b8e6c6 EZ |
5408 | 2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3 |
5409 | 1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/ | |
5410 | . . | |
5411 | ||
5412 | d C d F | |
5413 | ||
d7b8e6c6 | 5414 | @end group |
5d67986c | 5415 | @end smallexample |
d7b8e6c6 | 5416 | @noindent |
d7b8e6c6 | 5417 | @smallexample |
5d67986c | 5418 | @group |
d7b8e6c6 EZ |
5419 | 3: 34 x - 24 x^3 |
5420 | 2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0] | |
5421 | 1: @{2 \over 3@} \sqrt@{5@} | |
5422 | . | |
5423 | ||
5d67986c | 5424 | d T ' 2 \sqrt@{5@} \over 3 @key{RET} |
d7b8e6c6 | 5425 | @end group |
5d67986c | 5426 | @end smallexample |
d7b8e6c6 EZ |
5427 | |
5428 | @noindent | |
5429 | As you can see, language modes affect both entry and display of | |
5430 | formulas. They affect such things as the names used for built-in | |
5431 | functions, the set of arithmetic operators and their precedences, | |
5432 | and notations for vectors and matrices. | |
5433 | ||
5434 | Notice that @samp{sqrt(51)} may cause problems with older | |
5435 | implementations of C and FORTRAN, which would require something more | |
5436 | like @samp{sqrt(51.0)}. It is always wise to check over the formulas | |
5437 | produced by the various language modes to make sure they are fully | |
5438 | correct. | |
5439 | ||
5440 | Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You | |
5441 | may prefer to remain in Big mode, but all the examples in the tutorial | |
5442 | are shown in normal mode.) | |
5443 | ||
5444 | @cindex Area under a curve | |
a4231b04 | 5445 | What is the area under the portion of this curve from @expr{x = 1} to @expr{2}? |
d7b8e6c6 EZ |
5446 | This is simply the integral of the function: |
5447 | ||
d7b8e6c6 | 5448 | @smallexample |
5d67986c | 5449 | @group |
d7b8e6c6 EZ |
5450 | 1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x |
5451 | . . | |
5452 | ||
5453 | r 1 a i x | |
d7b8e6c6 | 5454 | @end group |
5d67986c | 5455 | @end smallexample |
d7b8e6c6 EZ |
5456 | |
5457 | @noindent | |
a4231b04 | 5458 | We want to evaluate this at our two values for @expr{x} and subtract. |
d7b8e6c6 EZ |
5459 | One way to do it is again with vector mapping and reduction: |
5460 | ||
d7b8e6c6 | 5461 | @smallexample |
5d67986c | 5462 | @group |
d7b8e6c6 EZ |
5463 | 2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666 |
5464 | 1: 5.6666 x^3 ... . . | |
5465 | ||
5d67986c | 5466 | [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R - |
d7b8e6c6 | 5467 | @end group |
5d67986c | 5468 | @end smallexample |
d7b8e6c6 | 5469 | |
a4231b04 JB |
5470 | (@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y} |
5471 | of | |
8e04863e | 5472 | @texline @math{x \sin \pi x} |
a4231b04 JB |
5473 | @infoline @w{@expr{x sin(pi x)}} |
5474 | (where the sine is calculated in radians). Find the values of the | |
5475 | integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3, | |
5476 | 3}. (@bullet{}) | |
d7b8e6c6 EZ |
5477 | |
5478 | Calc's integrator can do many simple integrals symbolically, but many | |
5479 | others are beyond its capabilities. Suppose we wish to find the area | |
a4231b04 | 5480 | under the curve |
8e04863e | 5481 | @texline @math{\sin x \ln x} |
a4231b04 JB |
5482 | @infoline @expr{sin(x) ln(x)} |
5483 | over the same range of @expr{x}. If you entered this formula and typed | |
5484 | @kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a | |
5485 | long time but would be unable to find a solution. In fact, there is no | |
5486 | closed-form solution to this integral. Now what do we do? | |
d7b8e6c6 EZ |
5487 | |
5488 | @cindex Integration, numerical | |
5489 | @cindex Numerical integration | |
5490 | One approach would be to do the integral numerically. It is not hard | |
5491 | to do this by hand using vector mapping and reduction. It is rather | |
5492 | slow, though, since the sine and logarithm functions take a long time. | |
5493 | We can save some time by reducing the working precision. | |
5494 | ||
d7b8e6c6 | 5495 | @smallexample |
5d67986c | 5496 | @group |
d7b8e6c6 EZ |
5497 | 3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9] |
5498 | 2: 1 . | |
5499 | 1: 0.1 | |
5500 | . | |
5501 | ||
5d67986c | 5502 | 10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x |
d7b8e6c6 | 5503 | @end group |
5d67986c | 5504 | @end smallexample |
d7b8e6c6 EZ |
5505 | |
5506 | @noindent | |
5507 | (Note that we have used the extended version of @kbd{v x}; we could | |
5d67986c | 5508 | also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.) |
d7b8e6c6 | 5509 | |
d7b8e6c6 | 5510 | @smallexample |
5d67986c | 5511 | @group |
d7b8e6c6 EZ |
5512 | 2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ] |
5513 | 1: sin(x) ln(x) . | |
5514 | . | |
5515 | ||
5d67986c | 5516 | ' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET} |
d7b8e6c6 | 5517 | |
d7b8e6c6 | 5518 | @end group |
5d67986c | 5519 | @end smallexample |
d7b8e6c6 | 5520 | @noindent |
d7b8e6c6 | 5521 | @smallexample |
5d67986c | 5522 | @group |
d7b8e6c6 EZ |
5523 | 1: 3.4195 0.34195 |
5524 | . . | |
5525 | ||
5526 | V R + 0.1 * | |
d7b8e6c6 | 5527 | @end group |
5d67986c | 5528 | @end smallexample |
d7b8e6c6 EZ |
5529 | |
5530 | @noindent | |
5531 | (If you got wildly different results, did you remember to switch | |
07ce2eb3 | 5532 | to Radians mode?) |
d7b8e6c6 EZ |
5533 | |
5534 | Here we have divided the curve into ten segments of equal width; | |
5535 | approximating these segments as rectangular boxes (i.e., assuming | |
5536 | the curve is nearly flat at that resolution), we compute the areas | |
5537 | of the boxes (height times width), then sum the areas. (It is | |
5538 | faster to sum first, then multiply by the width, since the width | |
5539 | is the same for every box.) | |
5540 | ||
5541 | The true value of this integral turns out to be about 0.374, so | |
5542 | we're not doing too well. Let's try another approach. | |
5543 | ||
d7b8e6c6 | 5544 | @smallexample |
5d67986c | 5545 | @group |
d7b8e6c6 EZ |
5546 | 1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ... |
5547 | . . | |
5548 | ||
5d67986c | 5549 | r 1 a t x=1 @key{RET} 4 @key{RET} |
d7b8e6c6 | 5550 | @end group |
5d67986c | 5551 | @end smallexample |
d7b8e6c6 EZ |
5552 | |
5553 | @noindent | |
5554 | Here we have computed the Taylor series expansion of the function | |
a4231b04 | 5555 | about the point @expr{x=1}. We can now integrate this polynomial |
d7b8e6c6 EZ |
5556 | approximation, since polynomials are easy to integrate. |
5557 | ||
d7b8e6c6 | 5558 | @smallexample |
5d67986c | 5559 | @group |
d7b8e6c6 EZ |
5560 | 1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761 |
5561 | . . . | |
5562 | ||
5d67986c | 5563 | a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R - |
d7b8e6c6 | 5564 | @end group |
5d67986c | 5565 | @end smallexample |
d7b8e6c6 EZ |
5566 | |
5567 | @noindent | |
5568 | Better! By increasing the precision and/or asking for more terms | |
5569 | in the Taylor series, we can get a result as accurate as we like. | |
5570 | (Taylor series converge better away from singularities in the | |
5571 | function such as the one at @code{ln(0)}, so it would also help to | |
a4231b04 JB |
5572 | expand the series about the points @expr{x=2} or @expr{x=1.5} instead |
5573 | of @expr{x=1}.) | |
d7b8e6c6 EZ |
5574 | |
5575 | @cindex Simpson's rule | |
5576 | @cindex Integration by Simpson's rule | |
5577 | (@bullet{}) @strong{Exercise 4.} Our first method approximated the | |
5578 | curve by stairsteps of width 0.1; the total area was then the sum | |
5579 | of the areas of the rectangles under these stairsteps. Our second | |
5580 | method approximated the function by a polynomial, which turned out | |
5581 | to be a better approximation than stairsteps. A third method is | |
5582 | @dfn{Simpson's rule}, which is like the stairstep method except | |
5583 | that the steps are not required to be flat. Simpson's rule boils | |
5584 | down to the formula, | |
5585 | ||
5586 | @ifinfo | |
5587 | @example | |
5588 | (h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ... | |
5589 | + 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h)) | |
5590 | @end example | |
5591 | @end ifinfo | |
5592 | @tex | |
5593 | \turnoffactive | |
5594 | \beforedisplay | |
5595 | $$ \displaylines{ | |
5596 | \qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots | |
5597 | \hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad | |
5598 | } $$ | |
5599 | \afterdisplay | |
5600 | @end tex | |
5601 | ||
5602 | @noindent | |
a4231b04 | 5603 | where @expr{n} (which must be even) is the number of slices and @expr{h} |
d7b8e6c6 EZ |
5604 | is the width of each slice. These are 10 and 0.1 in our example. |
5605 | For reference, here is the corresponding formula for the stairstep | |
5606 | method: | |
5607 | ||
5608 | @ifinfo | |
5609 | @example | |
5610 | h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ... | |
5611 | + f(a+(n-2)*h) + f(a+(n-1)*h)) | |
5612 | @end example | |
5613 | @end ifinfo | |
5614 | @tex | |
5615 | \turnoffactive | |
5616 | \beforedisplay | |
5617 | $$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots | |
5618 | + f(a+(n-2)h) + f(a+(n-1)h)) $$ | |
5619 | \afterdisplay | |
5620 | @end tex | |
5621 | ||
a4231b04 | 5622 | Compute the integral from 1 to 2 of |
8e04863e | 5623 | @texline @math{\sin x \ln x} |
a4231b04 JB |
5624 | @infoline @expr{sin(x) ln(x)} |
5625 | using Simpson's rule with 10 slices. | |
5626 | @xref{Algebra Answer 4, 4}. (@bullet{}) | |
d7b8e6c6 EZ |
5627 | |
5628 | Calc has a built-in @kbd{a I} command for doing numerical integration. | |
5629 | It uses @dfn{Romberg's method}, which is a more sophisticated cousin | |
5630 | of Simpson's rule. In particular, it knows how to keep refining the | |
5631 | result until the current precision is satisfied. | |
5632 | ||
5633 | @c [fix-ref Selecting Sub-Formulas] | |
5634 | Aside from the commands we've seen so far, Calc also provides a | |
5635 | large set of commands for operating on parts of formulas. You | |
5636 | indicate the desired sub-formula by placing the cursor on any part | |
5637 | of the formula before giving a @dfn{selection} command. Selections won't | |
5638 | be covered in the tutorial; @pxref{Selecting Subformulas}, for | |
5639 | details and examples. | |
5640 | ||
5641 | @c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1) | |
5642 | @c to 2^((n-1)*(r-1)). | |
5643 | ||
5644 | @node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial | |
5645 | @subsection Rewrite Rules | |
5646 | ||
5647 | @noindent | |
5648 | No matter how many built-in commands Calc provided for doing algebra, | |
5649 | there would always be something you wanted to do that Calc didn't have | |
5650 | in its repertoire. So Calc also provides a @dfn{rewrite rule} system | |
5651 | that you can use to define your own algebraic manipulations. | |
5652 | ||
5653 | Suppose we want to simplify this trigonometric formula: | |
5654 | ||
d7b8e6c6 | 5655 | @smallexample |
5d67986c | 5656 | @group |
d7b8e6c6 EZ |
5657 | 1: 1 / cos(x) - sin(x) tan(x) |
5658 | . | |
5659 | ||
5d67986c | 5660 | ' 1/cos(x) - sin(x) tan(x) @key{RET} s 1 |
d7b8e6c6 | 5661 | @end group |
5d67986c | 5662 | @end smallexample |
d7b8e6c6 EZ |
5663 | |
5664 | @noindent | |
5665 | If we were simplifying this by hand, we'd probably replace the | |
5666 | @samp{tan} with a @samp{sin/cos} first, then combine over a common | |
5667 | denominator. There is no Calc command to do the former; the @kbd{a n} | |
5668 | algebra command will do the latter but we'll do both with rewrite | |
5669 | rules just for practice. | |
5670 | ||
5671 | Rewrite rules are written with the @samp{:=} symbol. | |
5672 | ||
d7b8e6c6 | 5673 | @smallexample |
5d67986c | 5674 | @group |
d7b8e6c6 EZ |
5675 | 1: 1 / cos(x) - sin(x)^2 / cos(x) |
5676 | . | |
5677 | ||
5d67986c | 5678 | a r tan(a) := sin(a)/cos(a) @key{RET} |
d7b8e6c6 | 5679 | @end group |
5d67986c | 5680 | @end smallexample |
d7b8e6c6 EZ |
5681 | |
5682 | @noindent | |
5683 | (The ``assignment operator'' @samp{:=} has several uses in Calc. All | |
5684 | by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything, | |
5685 | but when it is given to the @kbd{a r} command, that command interprets | |
5686 | it as a rewrite rule.) | |
5687 | ||
5688 | The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the | |
5689 | rewrite rule. Calc searches the formula on the stack for parts that | |
5690 | match the pattern. Variables in a rewrite pattern are called | |
5691 | @dfn{meta-variables}, and when matching the pattern each meta-variable | |
5692 | can match any sub-formula. Here, the meta-variable @samp{a} matched | |
5693 | the actual variable @samp{x}. | |
5694 | ||
5695 | When the pattern part of a rewrite rule matches a part of the formula, | |
5696 | that part is replaced by the righthand side with all the meta-variables | |
5697 | substituted with the things they matched. So the result is | |
5698 | @samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then | |
5699 | mix this in with the rest of the original formula. | |
5700 | ||
5701 | To merge over a common denominator, we can use another simple rule: | |
5702 | ||
d7b8e6c6 | 5703 | @smallexample |
5d67986c | 5704 | @group |
d7b8e6c6 EZ |
5705 | 1: (1 - sin(x)^2) / cos(x) |
5706 | . | |
5707 | ||
5d67986c | 5708 | a r a/x + b/x := (a+b)/x @key{RET} |
d7b8e6c6 | 5709 | @end group |
5d67986c | 5710 | @end smallexample |
d7b8e6c6 EZ |
5711 | |
5712 | This rule points out several interesting features of rewrite patterns. | |
5713 | First, if a meta-variable appears several times in a pattern, it must | |
5714 | match the same thing everywhere. This rule detects common denominators | |
5715 | because the same meta-variable @samp{x} is used in both of the | |
5716 | denominators. | |
5717 | ||
5718 | Second, meta-variable names are independent from variables in the | |
5719 | target formula. Notice that the meta-variable @samp{x} here matches | |
5720 | the subformula @samp{cos(x)}; Calc never confuses the two meanings of | |
5721 | @samp{x}. | |
5722 | ||
5723 | And third, rewrite patterns know a little bit about the algebraic | |
5724 | properties of formulas. The pattern called for a sum of two quotients; | |
5725 | Calc was able to match a difference of two quotients by matching | |
5726 | @samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}. | |
5727 | ||
5728 | @c [fix-ref Algebraic Properties of Rewrite Rules] | |
5729 | We could just as easily have written @samp{a/x - b/x := (a-b)/x} for | |
5730 | the rule. It would have worked just the same in all cases. (If we | |
5731 | really wanted the rule to apply only to @samp{+} or only to @samp{-}, | |
5732 | we could have used the @code{plain} symbol. @xref{Algebraic Properties | |
5733 | of Rewrite Rules}, for some examples of this.) | |
5734 | ||
5735 | One more rewrite will complete the job. We want to use the identity | |
5736 | @samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange | |
5737 | the identity in a way that matches our formula. The obvious rule | |
5738 | would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows | |
5739 | that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The | |
5740 | latter rule has a more general pattern so it will work in many other | |
5741 | situations, too. | |
5742 | ||
d7b8e6c6 | 5743 | @smallexample |
5d67986c | 5744 | @group |
d7b8e6c6 EZ |
5745 | 1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x) |
5746 | . . | |
5747 | ||
5d67986c | 5748 | a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s |
d7b8e6c6 | 5749 | @end group |
5d67986c | 5750 | @end smallexample |
d7b8e6c6 EZ |
5751 | |
5752 | You may ask, what's the point of using the most general rule if you | |
5753 | have to type it in every time anyway? The answer is that Calc allows | |
5754 | you to store a rewrite rule in a variable, then give the variable | |
5755 | name in the @kbd{a r} command. In fact, this is the preferred way to | |
5756 | use rewrites. For one, if you need a rule once you'll most likely | |
5757 | need it again later. Also, if the rule doesn't work quite right you | |
5758 | can simply Undo, edit the variable, and run the rule again without | |
5759 | having to retype it. | |
5760 | ||
d7b8e6c6 | 5761 | @smallexample |
5d67986c RS |
5762 | @group |
5763 | ' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET} | |
5764 | ' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET} | |
5765 | ' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET} | |
d7b8e6c6 EZ |
5766 | |
5767 | 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x) | |
5768 | . . | |
5769 | ||
5d67986c | 5770 | r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s |
d7b8e6c6 | 5771 | @end group |
5d67986c | 5772 | @end smallexample |
d7b8e6c6 EZ |
5773 | |
5774 | To edit a variable, type @kbd{s e} and the variable name, use regular | |
33108698 JB |
5775 | Emacs editing commands as necessary, then type @kbd{C-c C-c} to store |
5776 | the edited value back into the variable. | |
d7b8e6c6 EZ |
5777 | You can also use @w{@kbd{s e}} to create a new variable if you wish. |
5778 | ||
5779 | Notice that the first time you use each rule, Calc puts up a ``compiling'' | |
5780 | message briefly. The pattern matcher converts rules into a special | |
5781 | optimized pattern-matching language rather than using them directly. | |
5782 | This allows @kbd{a r} to apply even rather complicated rules very | |
5783 | efficiently. If the rule is stored in a variable, Calc compiles it | |
5784 | only once and stores the compiled form along with the variable. That's | |
5785 | another good reason to store your rules in variables rather than | |
5786 | entering them on the fly. | |
5787 | ||
07ce2eb3 | 5788 | (@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic |
d7b8e6c6 | 5789 | mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}. |
029b2a44 JB |
5790 | Using a rewrite rule, simplify this formula by multiplying the top and |
5791 | bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have | |
d7b8e6c6 EZ |
5792 | to be expanded by the distributive law; do this with another |
5793 | rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{}) | |
5794 | ||
5795 | The @kbd{a r} command can also accept a vector of rewrite rules, or | |
5796 | a variable containing a vector of rules. | |
5797 | ||
d7b8e6c6 | 5798 | @smallexample |
5d67986c | 5799 | @group |
d7b8e6c6 EZ |
5800 | 1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ] |
5801 | . . | |
5802 | ||
5d67986c | 5803 | ' [tsc,merge,sinsqr] @key{RET} = |
d7b8e6c6 | 5804 | |
d7b8e6c6 | 5805 | @end group |
5d67986c | 5806 | @end smallexample |
d7b8e6c6 | 5807 | @noindent |
d7b8e6c6 | 5808 | @smallexample |
5d67986c | 5809 | @group |
d7b8e6c6 EZ |
5810 | 1: 1 / cos(x) - sin(x) tan(x) 1: cos(x) |
5811 | . . | |
5812 | ||
5d67986c | 5813 | s t trig @key{RET} r 1 a r trig @key{RET} a s |
d7b8e6c6 | 5814 | @end group |
5d67986c | 5815 | @end smallexample |
d7b8e6c6 EZ |
5816 | |
5817 | @c [fix-ref Nested Formulas with Rewrite Rules] | |
5818 | Calc tries all the rules you give against all parts of the formula, | |
5819 | repeating until no further change is possible. (The exact order in | |
5820 | which things are tried is rather complex, but for simple rules like | |
5821 | the ones we've used here the order doesn't really matter. | |
5822 | @xref{Nested Formulas with Rewrite Rules}.) | |
5823 | ||
5824 | Calc actually repeats only up to 100 times, just in case your rule set | |
5825 | has gotten into an infinite loop. You can give a numeric prefix argument | |
5826 | to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does | |
5827 | only one rewrite at a time. | |
5828 | ||
d7b8e6c6 | 5829 | @smallexample |
5d67986c | 5830 | @group |
d7b8e6c6 EZ |
5831 | 1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x) |
5832 | . . | |
5833 | ||
5d67986c | 5834 | r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET} |
d7b8e6c6 | 5835 | @end group |
5d67986c | 5836 | @end smallexample |
d7b8e6c6 EZ |
5837 | |
5838 | You can type @kbd{M-0 a r} if you want no limit at all on the number | |
5839 | of rewrites that occur. | |
5840 | ||
5841 | Rewrite rules can also be @dfn{conditional}. Simply follow the rule | |
5842 | with a @samp{::} symbol and the desired condition. For example, | |
5843 | ||
d7b8e6c6 | 5844 | @smallexample |
5d67986c | 5845 | @group |
d7b8e6c6 EZ |
5846 | 1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i) |
5847 | . | |
5848 | ||
5d67986c | 5849 | ' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET} |
d7b8e6c6 | 5850 | |
d7b8e6c6 | 5851 | @end group |
5d67986c | 5852 | @end smallexample |
d7b8e6c6 | 5853 | @noindent |
d7b8e6c6 | 5854 | @smallexample |
5d67986c | 5855 | @group |
d7b8e6c6 EZ |
5856 | 1: 1 + exp(3 pi i) + 1 |
5857 | . | |
5858 | ||
5d67986c | 5859 | a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET} |
d7b8e6c6 | 5860 | @end group |
5d67986c | 5861 | @end smallexample |
d7b8e6c6 EZ |
5862 | |
5863 | @noindent | |
5864 | (Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2, | |
5865 | which will be zero only when @samp{k} is an even integer.) | |
5866 | ||
5867 | An interesting point is that the variables @samp{pi} and @samp{i} | |
5868 | were matched literally rather than acting as meta-variables. | |
5869 | This is because they are special-constant variables. The special | |
5870 | constants @samp{e}, @samp{phi}, and so on also match literally. | |
5871 | A common error with rewrite | |
5872 | rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting | |
5873 | to match any @samp{f} with five arguments but in fact matching | |
a4231b04 | 5874 | only when the fifth argument is literally @samp{e}! |
d7b8e6c6 EZ |
5875 | |
5876 | @cindex Fibonacci numbers | |
5d67986c RS |
5877 | @ignore |
5878 | @starindex | |
5879 | @end ignore | |
d7b8e6c6 EZ |
5880 | @tindex fib |
5881 | Rewrite rules provide an interesting way to define your own functions. | |
5882 | Suppose we want to define @samp{fib(n)} to produce the @var{n}th | |
5883 | Fibonacci number. The first two Fibonacci numbers are each 1; | |
5884 | later numbers are formed by summing the two preceding numbers in | |
5885 | the sequence. This is easy to express in a set of three rules: | |
5886 | ||
d7b8e6c6 | 5887 | @smallexample |
5d67986c RS |
5888 | @group |
5889 | ' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib | |
d7b8e6c6 EZ |
5890 | |
5891 | 1: fib(7) 1: 13 | |
5892 | . . | |
5893 | ||
5d67986c | 5894 | ' fib(7) @key{RET} a r fib @key{RET} |
d7b8e6c6 | 5895 | @end group |
5d67986c | 5896 | @end smallexample |
d7b8e6c6 EZ |
5897 | |
5898 | One thing that is guaranteed about the order that rewrites are tried | |
5899 | is that, for any given subformula, earlier rules in the rule set will | |
5900 | be tried for that subformula before later ones. So even though the | |
5901 | first and third rules both match @samp{fib(1)}, we know the first will | |
5902 | be used preferentially. | |
5903 | ||
5904 | This rule set has one dangerous bug: Suppose we apply it to the | |
5905 | formula @samp{fib(x)}? (Don't actually try this.) The third rule | |
5906 | will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}. | |
5907 | Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) + | |
5908 | fib(x-4)}, and so on, expanding forever. What we really want is to apply | |
5909 | the third rule only when @samp{n} is an integer greater than two. Type | |
5d67986c | 5910 | @w{@kbd{s e fib @key{RET}}}, then edit the third rule to: |
d7b8e6c6 EZ |
5911 | |
5912 | @smallexample | |
5913 | fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 | |
5914 | @end smallexample | |
5915 | ||
5916 | @noindent | |
5917 | Now: | |
5918 | ||
d7b8e6c6 | 5919 | @smallexample |
5d67986c | 5920 | @group |
d7b8e6c6 EZ |
5921 | 1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0) |
5922 | . . | |
5923 | ||
5d67986c | 5924 | ' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET} |
d7b8e6c6 | 5925 | @end group |
5d67986c | 5926 | @end smallexample |
d7b8e6c6 EZ |
5927 | |
5928 | @noindent | |
5929 | We've created a new function, @code{fib}, and a new command, | |
5d67986c | 5930 | @w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in |
d7b8e6c6 EZ |
5931 | this formula.'' To make things easier still, we can tell Calc to |
5932 | apply these rules automatically by storing them in the special | |
5933 | variable @code{EvalRules}. | |
5934 | ||
d7b8e6c6 | 5935 | @smallexample |
5d67986c | 5936 | @group |
d7b8e6c6 EZ |
5937 | 1: [fib(1) := ...] . 1: [8, 13] |
5938 | . . | |
5939 | ||
5d67986c | 5940 | s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET} |
d7b8e6c6 | 5941 | @end group |
5d67986c | 5942 | @end smallexample |
d7b8e6c6 EZ |
5943 | |
5944 | It turns out that this rule set has the problem that it does far | |
5945 | more work than it needs to when @samp{n} is large. Consider the | |
5946 | first few steps of the computation of @samp{fib(6)}: | |
5947 | ||
d7b8e6c6 | 5948 | @smallexample |
5d67986c | 5949 | @group |
d7b8e6c6 EZ |
5950 | fib(6) = |
5951 | fib(5) + fib(4) = | |
5952 | fib(4) + fib(3) + fib(3) + fib(2) = | |
5953 | fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ... | |
d7b8e6c6 | 5954 | @end group |
5d67986c | 5955 | @end smallexample |
d7b8e6c6 EZ |
5956 | |
5957 | @noindent | |
5958 | Note that @samp{fib(3)} appears three times here. Unless Calc's | |
5959 | algebraic simplifier notices the multiple @samp{fib(3)}s and combines | |
5960 | them (and, as it happens, it doesn't), this rule set does lots of | |
5961 | needless recomputation. To cure the problem, type @code{s e EvalRules} | |
5962 | to edit the rules (or just @kbd{s E}, a shorthand command for editing | |
5963 | @code{EvalRules}) and add another condition: | |
5964 | ||
5965 | @smallexample | |
5966 | fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember | |
5967 | @end smallexample | |
5968 | ||
5969 | @noindent | |
5970 | If a @samp{:: remember} condition appears anywhere in a rule, then if | |
5971 | that rule succeeds Calc will add another rule that describes that match | |
5972 | to the front of the rule set. (Remembering works in any rule set, but | |
5973 | for technical reasons it is most effective in @code{EvalRules}.) For | |
5974 | example, if the rule rewrites @samp{fib(7)} to something that evaluates | |
5975 | to 13, then the rule @samp{fib(7) := 13} will be added to the rule set. | |
5976 | ||
5d67986c | 5977 | Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then |
d7b8e6c6 EZ |
5978 | type @kbd{s E} again to see what has happened to the rule set. |
5979 | ||
5980 | With the @code{remember} feature, our rule set can now compute | |
5981 | @samp{fib(@var{n})} in just @var{n} steps. In the process it builds | |
5982 | up a table of all Fibonacci numbers up to @var{n}. After we have | |
5983 | computed the result for a particular @var{n}, we can get it back | |
5984 | (and the results for all smaller @var{n}) later in just one step. | |
5985 | ||
5986 | All Calc operations will run somewhat slower whenever @code{EvalRules} | |
5d67986c | 5987 | contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to |
d7b8e6c6 EZ |
5988 | un-store the variable. |
5989 | ||
5990 | (@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate | |
5991 | a problem to reduce the amount of recursion necessary to solve it. | |
5992 | Create a rule that, in about @var{n} simple steps and without recourse | |
5993 | to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with | |
5994 | @samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the | |
5995 | @var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is | |
5996 | rather clunky to use, so add a couple more rules to make the ``user | |
5997 | interface'' the same as for our first version: enter @samp{fib(@var{n})}, | |
5998 | get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{}) | |
5999 | ||
6000 | There are many more things that rewrites can do. For example, there | |
6001 | are @samp{&&&} and @samp{|||} pattern operators that create ``and'' | |
6002 | and ``or'' combinations of rules. As one really simple example, we | |
6003 | could combine our first two Fibonacci rules thusly: | |
6004 | ||
6005 | @example | |
6006 | [fib(1 ||| 2) := 1, fib(n) := ... ] | |
6007 | @end example | |
6008 | ||
6009 | @noindent | |
6010 | That means ``@code{fib} of something matching either 1 or 2 rewrites | |
6011 | to 1.'' | |
6012 | ||
6013 | You can also make meta-variables optional by enclosing them in @code{opt}. | |
6014 | For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not | |
6015 | @samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x} | |
6016 | matches all of these forms, filling in a default of zero for @samp{a} | |
6017 | and one for @samp{b}. | |
6018 | ||
6019 | (@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x} | |
6020 | on the stack and tried to use the rule | |
6021 | @samp{opt(a) + opt(b) x := f(a, b, x)}. What happened? | |
6022 | @xref{Rewrites Answer 3, 3}. (@bullet{}) | |
6023 | ||
a4231b04 JB |
6024 | (@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a}, |
6025 | divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}. | |
d7b8e6c6 | 6026 | Now repeat this step over and over. A famous unproved conjecture |
a4231b04 | 6027 | is that for any starting @expr{a}, the sequence always eventually |
d7b8e6c6 EZ |
6028 | reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of |
6029 | rules that convert this into @samp{seq(1, @var{n})} where @var{n} | |
6030 | is the number of steps it took the sequence to reach the value 1. | |
6031 | Now enhance the rules to accept @samp{seq(@var{a})} as a starting | |
6032 | configuration, and to stop with just the number @var{n} by itself. | |
6033 | Now make the result be a vector of values in the sequence, from @var{a} | |
6034 | to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x} | |
6035 | and @var{y}.) For example, rewriting @samp{seq(6)} should yield the | |
a4231b04 | 6036 | vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. |
d7b8e6c6 EZ |
6037 | @xref{Rewrites Answer 4, 4}. (@bullet{}) |
6038 | ||
6039 | (@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function | |
6040 | @samp{nterms(@var{x})} that returns the number of terms in the sum | |
6041 | @var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes | |
6042 | is one or more non-sum terms separated by @samp{+} or @samp{-} signs, | |
a4231b04 | 6043 | so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.) |
d7b8e6c6 EZ |
6044 | @xref{Rewrites Answer 5, 5}. (@bullet{}) |
6045 | ||
8c399bc1 | 6046 | (@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an |
d7b8e6c6 | 6047 | infinite series that exactly equals the value of that function at |
a4231b04 | 6048 | values of @expr{x} near zero. |
d7b8e6c6 EZ |
6049 | |
6050 | @ifinfo | |
6051 | @example | |
6052 | cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ... | |
6053 | @end example | |
6054 | @end ifinfo | |
6055 | @tex | |
a4231b04 | 6056 | \turnoffactive |
d7b8e6c6 EZ |
6057 | \beforedisplay |
6058 | $$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$ | |
6059 | \afterdisplay | |
6060 | @end tex | |
6061 | ||
6062 | The @kbd{a t} command produces a @dfn{truncated Taylor series} which | |
a4231b04 JB |
6063 | is obtained by dropping all the terms higher than, say, @expr{x^2}. |
6064 | Calc represents the truncated Taylor series as a polynomial in @expr{x}. | |
d7b8e6c6 EZ |
6065 | Mathematicians often write a truncated series using a ``big-O'' notation |
6066 | that records what was the lowest term that was truncated. | |
6067 | ||
6068 | @ifinfo | |
6069 | @example | |
6070 | cos(x) = 1 - x^2 / 2! + O(x^3) | |
6071 | @end example | |
6072 | @end ifinfo | |
6073 | @tex | |
a4231b04 | 6074 | \turnoffactive |
d7b8e6c6 EZ |
6075 | \beforedisplay |
6076 | $$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$ | |
6077 | \afterdisplay | |
6078 | @end tex | |
6079 | ||
6080 | @noindent | |
a4231b04 JB |
6081 | The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small |
6082 | if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.'' | |
d7b8e6c6 EZ |
6083 | |
6084 | The exercise is to create rewrite rules that simplify sums and products of | |
6085 | power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}. | |
6086 | For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)} | |
6087 | on the stack, we want to be able to type @kbd{*} and get the result | |
6088 | @samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are | |
6089 | rearranged or if @kbd{a s} needs to be typed after rewriting. (This one | |
6090 | is rather tricky; the solution at the end of this chapter uses 6 rewrite | |
6091 | rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is | |
8c399bc1 JB |
6092 | a number.) @xref{Rewrites Answer 6, 6}. (@bullet{}) |
6093 | ||
6094 | Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}. | |
6095 | What happens? (Be sure to remove this rule afterward, or you might get | |
6096 | a nasty surprise when you use Calc to balance your checkbook!) | |
d7b8e6c6 | 6097 | |
d7b8e6c6 EZ |
6098 | @xref{Rewrite Rules}, for the whole story on rewrite rules. |
6099 | ||
6100 | @node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial | |
6101 | @section Programming Tutorial | |
6102 | ||
6103 | @noindent | |
6104 | The Calculator is written entirely in Emacs Lisp, a highly extensible | |
6105 | language. If you know Lisp, you can program the Calculator to do | |
6106 | anything you like. Rewrite rules also work as a powerful programming | |
6107 | system. But Lisp and rewrite rules take a while to master, and often | |
6108 | all you want to do is define a new function or repeat a command a few | |
6109 | times. Calc has features that allow you to do these things easily. | |
6110 | ||
d7b8e6c6 EZ |
6111 | One very limited form of programming is defining your own functions. |
6112 | Calc's @kbd{Z F} command allows you to define a function name and | |
6113 | key sequence to correspond to any formula. Programming commands use | |
6114 | the shift-@kbd{Z} prefix; the user commands they create use the lower | |
6115 | case @kbd{z} prefix. | |
6116 | ||
d7b8e6c6 | 6117 | @smallexample |
5d67986c | 6118 | @group |
d7b8e6c6 EZ |
6119 | 1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6 |
6120 | . . | |
6121 | ||
5d67986c | 6122 | ' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y |
d7b8e6c6 | 6123 | @end group |
5d67986c | 6124 | @end smallexample |
d7b8e6c6 EZ |
6125 | |
6126 | This polynomial is a Taylor series approximation to @samp{exp(x)}. | |
6127 | The @kbd{Z F} command asks a number of questions. The above answers | |
6128 | say that the key sequence for our function should be @kbd{z e}; the | |
6129 | @kbd{M-x} equivalent should be @code{calc-myexp}; the name of the | |
6130 | function in algebraic formulas should also be @code{myexp}; the | |
6131 | default argument list @samp{(x)} is acceptable; and finally @kbd{y} | |
6132 | answers the question ``leave it in symbolic form for non-constant | |
6133 | arguments?'' | |
6134 | ||
d7b8e6c6 | 6135 | @smallexample |
5d67986c | 6136 | @group |
d7b8e6c6 EZ |
6137 | 1: 1.3495 2: 1.3495 3: 1.3495 |
6138 | . 1: 1.34986 2: 1.34986 | |
6139 | . 1: myexp(a + 1) | |
6140 | . | |
6141 | ||
5d67986c | 6142 | .3 z e .3 E ' a+1 @key{RET} z e |
d7b8e6c6 | 6143 | @end group |
5d67986c | 6144 | @end smallexample |
d7b8e6c6 EZ |
6145 | |
6146 | @noindent | |
6147 | First we call our new @code{exp} approximation with 0.3 as an | |
6148 | argument, and compare it with the true @code{exp} function. Then | |
6149 | we note that, as requested, if we try to give @kbd{z e} an | |
6150 | argument that isn't a plain number, it leaves the @code{myexp} | |
6151 | function call in symbolic form. If we had answered @kbd{n} to the | |
6152 | final question, @samp{myexp(a + 1)} would have evaluated by plugging | |
6153 | in @samp{a + 1} for @samp{x} in the defining formula. | |
6154 | ||
6155 | @cindex Sine integral Si(x) | |
5d67986c RS |
6156 | @ignore |
6157 | @starindex | |
6158 | @end ignore | |
d7b8e6c6 EZ |
6159 | @tindex Si |
6160 | (@bullet{}) @strong{Exercise 1.} The ``sine integral'' function | |
8e04863e | 6161 | @texline @math{{\rm Si}(x)} |
a4231b04 JB |
6162 | @infoline @expr{Si(x)} |
6163 | is defined as the integral of @samp{sin(t)/t} for | |
6164 | @expr{t = 0} to @expr{x} in radians. (It was invented because this | |
d7b8e6c6 EZ |
6165 | integral has no solution in terms of basic functions; if you give it |
6166 | to Calc's @kbd{a i} command, it will ponder it for a long time and then | |
6167 | give up.) We can use the numerical integration command, however, | |
6168 | which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)} | |
6169 | with any integrand @samp{f(t)}. Define a @kbd{z s} command and | |
6170 | @code{Si} function that implement this. You will need to edit the | |
6171 | default argument list a bit. As a test, @samp{Si(1)} should return | |
59b568a7 JB |
6172 | 0.946083. (If you don't get this answer, you might want to check that |
6173 | Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if | |
6174 | you reduce the precision to, say, six digits beforehand.) | |
d7b8e6c6 EZ |
6175 | @xref{Programming Answer 1, 1}. (@bullet{}) |
6176 | ||
6177 | The simplest way to do real ``programming'' of Emacs is to define a | |
6178 | @dfn{keyboard macro}. A keyboard macro is simply a sequence of | |
6179 | keystrokes which Emacs has stored away and can play back on demand. | |
6180 | For example, if you find yourself typing @kbd{H a S x @key{RET}} often, | |
6181 | you may wish to program a keyboard macro to type this for you. | |
6182 | ||
d7b8e6c6 | 6183 | @smallexample |
5d67986c | 6184 | @group |
d7b8e6c6 EZ |
6185 | 1: y = sqrt(x) 1: x = y^2 |
6186 | . . | |
6187 | ||
5d67986c | 6188 | ' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x ) |
d7b8e6c6 EZ |
6189 | |
6190 | 1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1 | |
6191 | . . | |
6192 | ||
5d67986c | 6193 | ' y=cos(x) @key{RET} X |
d7b8e6c6 | 6194 | @end group |
5d67986c | 6195 | @end smallexample |
d7b8e6c6 EZ |
6196 | |
6197 | @noindent | |
6198 | When you type @kbd{C-x (}, Emacs begins recording. But it is also | |
6199 | still ready to execute your keystrokes, so you're really ``training'' | |
6200 | Emacs by walking it through the procedure once. When you type | |
6201 | @w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to | |
6202 | re-execute the same keystrokes. | |
6203 | ||
6204 | You can give a name to your macro by typing @kbd{Z K}. | |
6205 | ||
d7b8e6c6 | 6206 | @smallexample |
5d67986c | 6207 | @group |
d7b8e6c6 EZ |
6208 | 1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y)) |
6209 | . . | |
6210 | ||
5d67986c | 6211 | Z K x @key{RET} ' y=x^4 @key{RET} z x |
d7b8e6c6 | 6212 | @end group |
5d67986c | 6213 | @end smallexample |
d7b8e6c6 EZ |
6214 | |
6215 | @noindent | |
6216 | Notice that we use shift-@kbd{Z} to define the command, and lower-case | |
6217 | @kbd{z} to call it up. | |
6218 | ||
6219 | Keyboard macros can call other macros. | |
6220 | ||
d7b8e6c6 | 6221 | @smallexample |
5d67986c | 6222 | @group |
d7b8e6c6 EZ |
6223 | 1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y |
6224 | . . . . | |
6225 | ||
5d67986c | 6226 | ' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X |
d7b8e6c6 | 6227 | @end group |
5d67986c | 6228 | @end smallexample |
d7b8e6c6 EZ |
6229 | |
6230 | (@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate | |
6231 | the item in level 3 of the stack, without disturbing the rest of | |
6232 | the stack. @xref{Programming Answer 2, 2}. (@bullet{}) | |
6233 | ||
6234 | (@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute | |
6235 | the following functions: | |
6236 | ||
6237 | @enumerate | |
6238 | @item | |
a4231b04 | 6239 | Compute |
8e04863e | 6240 | @texline @math{\displaystyle{\sin x \over x}}, |
a4231b04 JB |
6241 | @infoline @expr{sin(x) / x}, |
6242 | where @expr{x} is the number on the top of the stack. | |
d7b8e6c6 EZ |
6243 | |
6244 | @item | |
a4231b04 | 6245 | Compute the base-@expr{b} logarithm, just like the @kbd{B} key except |
d7b8e6c6 EZ |
6246 | the arguments are taken in the opposite order. |
6247 | ||
6248 | @item | |
6249 | Produce a vector of integers from 1 to the integer on the top of | |
6250 | the stack. | |
6251 | @end enumerate | |
6252 | @noindent | |
6253 | @xref{Programming Answer 3, 3}. (@bullet{}) | |
6254 | ||
6255 | (@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute | |
6256 | the average (mean) value of a list of numbers. | |
6257 | @xref{Programming Answer 4, 4}. (@bullet{}) | |
6258 | ||
6259 | In many programs, some of the steps must execute several times. | |
6260 | Calc has @dfn{looping} commands that allow this. Loops are useful | |
6261 | inside keyboard macros, but actually work at any time. | |
6262 | ||
d7b8e6c6 | 6263 | @smallexample |
5d67986c | 6264 | @group |
d7b8e6c6 EZ |
6265 | 1: x^6 2: x^6 1: 360 x^2 |
6266 | . 1: 4 . | |
6267 | . | |
6268 | ||
5d67986c | 6269 | ' x^6 @key{RET} 4 Z < a d x @key{RET} Z > |
d7b8e6c6 | 6270 | @end group |
5d67986c | 6271 | @end smallexample |
d7b8e6c6 EZ |
6272 | |
6273 | @noindent | |
a4231b04 | 6274 | Here we have computed the fourth derivative of @expr{x^6} by |
d7b8e6c6 EZ |
6275 | enclosing a derivative command in a ``repeat loop'' structure. |
6276 | This structure pops a repeat count from the stack, then | |
6277 | executes the body of the loop that many times. | |
6278 | ||
6279 | If you make a mistake while entering the body of the loop, | |
6280 | type @w{@kbd{Z C-g}} to cancel the loop command. | |
6281 | ||
6282 | @cindex Fibonacci numbers | |
6283 | Here's another example: | |
6284 | ||
d7b8e6c6 | 6285 | @smallexample |
5d67986c | 6286 | @group |
d7b8e6c6 EZ |
6287 | 3: 1 2: 10946 |
6288 | 2: 1 1: 17711 | |
6289 | 1: 20 . | |
6290 | . | |
6291 | ||
5d67986c | 6292 | 1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z > |
d7b8e6c6 | 6293 | @end group |
5d67986c | 6294 | @end smallexample |
d7b8e6c6 EZ |
6295 | |
6296 | @noindent | |
6297 | The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci | |
6298 | numbers, respectively. (To see what's going on, try a few repetitions | |
6299 | of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD} | |
6300 | key if you have one, makes a copy of the number in level 2.) | |
6301 | ||
6302 | @cindex Golden ratio | |
6303 | @cindex Phi, golden ratio | |
a4231b04 JB |
6304 | A fascinating property of the Fibonacci numbers is that the @expr{n}th |
6305 | Fibonacci number can be found directly by computing | |
8e04863e | 6306 | @texline @math{\phi^n / \sqrt{5}} |
a4231b04 JB |
6307 | @infoline @expr{phi^n / sqrt(5)} |
6308 | and then rounding to the nearest integer, where | |
8e04863e | 6309 | @texline @math{\phi} (``phi''), |
a4231b04 JB |
6310 | @infoline @expr{phi}, |
6311 | the ``golden ratio,'' is | |
8e04863e | 6312 | @texline @math{(1 + \sqrt{5}) / 2}. |
a4231b04 JB |
6313 | @infoline @expr{(1 + sqrt(5)) / 2}. |
6314 | (For convenience, this constant is available from the @code{phi} | |
6315 | variable, or the @kbd{I H P} command.) | |
d7b8e6c6 | 6316 | |
d7b8e6c6 | 6317 | @smallexample |
5d67986c | 6318 | @group |
d7b8e6c6 EZ |
6319 | 1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946 |
6320 | . . . . | |
6321 | ||
6322 | I H P 21 ^ 5 Q / R | |
d7b8e6c6 | 6323 | @end group |
5d67986c | 6324 | @end smallexample |
d7b8e6c6 EZ |
6325 | |
6326 | @cindex Continued fractions | |
6327 | (@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction} | |
a4231b04 | 6328 | representation of |
8e04863e | 6329 | @texline @math{\phi} |
a4231b04 JB |
6330 | @infoline @expr{phi} |
6331 | is | |
8e04863e | 6332 | @texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}. |
a4231b04 | 6333 | @infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}. |
d7b8e6c6 | 6334 | We can compute an approximate value by carrying this however far |
a4231b04 | 6335 | and then replacing the innermost |
8e04863e | 6336 | @texline @math{1/( \ldots )} |
a4231b04 JB |
6337 | @infoline @expr{1/( ...@: )} |
6338 | by 1. Approximate | |
8e04863e | 6339 | @texline @math{\phi} |
a4231b04 JB |
6340 | @infoline @expr{phi} |
6341 | using a twenty-term continued fraction. | |
d7b8e6c6 EZ |
6342 | @xref{Programming Answer 5, 5}. (@bullet{}) |
6343 | ||
6344 | (@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for | |
6345 | Fibonacci numbers can be expressed in terms of matrices. Given a | |
a4231b04 JB |
6346 | vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this |
6347 | vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and | |
6348 | @expr{c} are three successive Fibonacci numbers. Now write a program | |
6349 | that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number | |
d7b8e6c6 EZ |
6350 | using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{}) |
6351 | ||
6352 | @cindex Harmonic numbers | |
6353 | A more sophisticated kind of loop is the @dfn{for} loop. Suppose | |
6354 | we wish to compute the 20th ``harmonic'' number, which is equal to | |
6355 | the sum of the reciprocals of the integers from 1 to 20. | |
6356 | ||
d7b8e6c6 | 6357 | @smallexample |
5d67986c | 6358 | @group |
d7b8e6c6 EZ |
6359 | 3: 0 1: 3.597739 |
6360 | 2: 1 . | |
6361 | 1: 20 | |
6362 | . | |
6363 | ||
5d67986c | 6364 | 0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z ) |
d7b8e6c6 | 6365 | @end group |
5d67986c | 6366 | @end smallexample |
d7b8e6c6 EZ |
6367 | |
6368 | @noindent | |
6369 | The ``for'' loop pops two numbers, the lower and upper limits, then | |
6370 | repeats the body of the loop as an internal counter increases from | |
6371 | the lower limit to the upper one. Just before executing the loop | |
6372 | body, it pushes the current loop counter. When the loop body | |
6373 | finishes, it pops the ``step,'' i.e., the amount by which to | |
6374 | increment the loop counter. As you can see, our loop always | |
6375 | uses a step of one. | |
6376 | ||
6377 | This harmonic number function uses the stack to hold the running | |
6378 | total as well as for the various loop housekeeping functions. If | |
6379 | you find this disorienting, you can sum in a variable instead: | |
6380 | ||
d7b8e6c6 | 6381 | @smallexample |
5d67986c | 6382 | @group |
d7b8e6c6 EZ |
6383 | 1: 0 2: 1 . 1: 3.597739 |
6384 | . 1: 20 . | |
6385 | . | |
6386 | ||
5d67986c | 6387 | 0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7 |
d7b8e6c6 | 6388 | @end group |
5d67986c | 6389 | @end smallexample |
d7b8e6c6 EZ |
6390 | |
6391 | @noindent | |
6392 | The @kbd{s +} command adds the top-of-stack into the value in a | |
6393 | variable (and removes that value from the stack). | |
6394 | ||
6395 | It's worth noting that many jobs that call for a ``for'' loop can | |
6396 | also be done more easily by Calc's high-level operations. Two | |
6397 | other ways to compute harmonic numbers are to use vector mapping | |
6398 | and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}), | |
6399 | or to use the summation command @kbd{a +}. Both of these are | |
6400 | probably easier than using loops. However, there are some | |
6401 | situations where loops really are the way to go: | |
6402 | ||
6403 | (@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first | |
6404 | harmonic number which is greater than 4.0. | |
6405 | @xref{Programming Answer 7, 7}. (@bullet{}) | |
6406 | ||
6407 | Of course, if we're going to be using variables in our programs, | |
6408 | we have to worry about the programs clobbering values that the | |
6409 | caller was keeping in those same variables. This is easy to | |
6410 | fix, though: | |
6411 | ||
d7b8e6c6 | 6412 | @smallexample |
5d67986c | 6413 | @group |
d7b8e6c6 EZ |
6414 | . 1: 0.6667 1: 0.6667 3: 0.6667 |
6415 | . . 2: 3.597739 | |
6416 | 1: 0.6667 | |
6417 | . | |
6418 | ||
5d67986c | 6419 | Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET} |
d7b8e6c6 | 6420 | @end group |
5d67986c | 6421 | @end smallexample |
d7b8e6c6 EZ |
6422 | |
6423 | @noindent | |
6424 | When we type @kbd{Z `} (that's a back-quote character), Calc saves | |
6425 | its mode settings and the contents of the ten ``quick variables'' | |
6426 | for later reference. When we type @kbd{Z '} (that's an apostrophe | |
6427 | now), Calc restores those saved values. Thus the @kbd{p 4} and | |
6428 | @kbd{s 7} commands have no effect outside this sequence. Wrapping | |
6429 | this around the body of a keyboard macro ensures that it doesn't | |
6430 | interfere with what the user of the macro was doing. Notice that | |
6431 | the contents of the stack, and the values of named variables, | |
6432 | survive past the @kbd{Z '} command. | |
6433 | ||
6434 | @cindex Bernoulli numbers, approximate | |
6435 | The @dfn{Bernoulli numbers} are a sequence with the interesting | |
6436 | property that all of the odd Bernoulli numbers are zero, and the | |
6437 | even ones, while difficult to compute, can be roughly approximated | |
a4231b04 | 6438 | by the formula |
8e04863e | 6439 | @texline @math{\displaystyle{2 n! \over (2 \pi)^n}}. |
a4231b04 JB |
6440 | @infoline @expr{2 n!@: / (2 pi)^n}. |
6441 | Let's write a keyboard macro to compute (approximate) Bernoulli numbers. | |
6442 | (Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but | |
6443 | this command is very slow for large @expr{n} since the higher Bernoulli | |
6444 | numbers are very large fractions.) | |
d7b8e6c6 | 6445 | |
d7b8e6c6 | 6446 | @smallexample |
5d67986c | 6447 | @group |
d7b8e6c6 EZ |
6448 | 1: 10 1: 0.0756823 |
6449 | . . | |
6450 | ||
5d67986c | 6451 | 10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x ) |
d7b8e6c6 | 6452 | @end group |
5d67986c | 6453 | @end smallexample |
d7b8e6c6 EZ |
6454 | |
6455 | @noindent | |
6456 | You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and | |
6457 | @kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if'' | |
6458 | command. For the purposes of @w{@kbd{Z [}}, the condition is ``true'' | |
6459 | if the value it pops from the stack is a nonzero number, or ``false'' | |
6460 | if it pops zero or something that is not a number (like a formula). | |
6461 | Here we take our integer argument modulo 2; this will be nonzero | |
6462 | if we're asking for an odd Bernoulli number. | |
6463 | ||
a4231b04 | 6464 | The actual tenth Bernoulli number is @expr{5/66}. |
d7b8e6c6 | 6465 | |
d7b8e6c6 | 6466 | @smallexample |
5d67986c | 6467 | @group |
d7b8e6c6 EZ |
6468 | 3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659 |
6469 | 2: 5:66 . . . . | |
6470 | 1: 0.0757575 | |
6471 | . | |
6472 | ||
5d67986c | 6473 | 10 k b @key{RET} c f M-0 @key{DEL} 11 X @key{DEL} 12 X @key{DEL} 13 X @key{DEL} 14 X |
d7b8e6c6 | 6474 | @end group |
5d67986c | 6475 | @end smallexample |
d7b8e6c6 EZ |
6476 | |
6477 | Just to exercise loops a bit more, let's compute a table of even | |
6478 | Bernoulli numbers. | |
6479 | ||
d7b8e6c6 | 6480 | @smallexample |
5d67986c | 6481 | @group |
d7b8e6c6 EZ |
6482 | 3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...] |
6483 | 2: 2 . | |
6484 | 1: 30 | |
6485 | . | |
6486 | ||
5d67986c | 6487 | [ ] 2 @key{RET} 30 Z ( X | 2 Z ) |
d7b8e6c6 | 6488 | @end group |
5d67986c | 6489 | @end smallexample |
d7b8e6c6 EZ |
6490 | |
6491 | @noindent | |
6492 | The vertical-bar @kbd{|} is the vector-concatenation command. When | |
6493 | we execute it, the list we are building will be in stack level 2 | |
6494 | (initially this is an empty list), and the next Bernoulli number | |
6495 | will be in level 1. The effect is to append the Bernoulli number | |
6496 | onto the end of the list. (To create a table of exact fractional | |
6497 | Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above | |
6498 | sequence of keystrokes.) | |
6499 | ||
6500 | With loops and conditionals, you can program essentially anything | |
6501 | in Calc. One other command that makes looping easier is @kbd{Z /}, | |
6502 | which takes a condition from the stack and breaks out of the enclosing | |
6503 | loop if the condition is true (non-zero). You can use this to make | |
6504 | ``while'' and ``until'' style loops. | |
6505 | ||
6506 | If you make a mistake when entering a keyboard macro, you can edit | |
6507 | it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}. | |
6508 | One technique is to enter a throwaway dummy definition for the macro, | |
6509 | then enter the real one in the edit command. | |
6510 | ||
d7b8e6c6 | 6511 | @smallexample |
5d67986c | 6512 | @group |
74857f83 JB |
6513 | 1: 3 1: 3 Calc Macro Edit Mode. |
6514 | . . Original keys: 1 <return> 2 + | |
d7b8e6c6 | 6515 | |
74857f83 JB |
6516 | 1 ;; calc digits |
6517 | RET ;; calc-enter | |
6518 | 2 ;; calc digits | |
6519 | + ;; calc-plus | |
d7b8e6c6 | 6520 | |
5d67986c | 6521 | C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h |
d7b8e6c6 | 6522 | @end group |
5d67986c | 6523 | @end smallexample |
d7b8e6c6 EZ |
6524 | |
6525 | @noindent | |
d7b8e6c6 | 6526 | A keyboard macro is stored as a pure keystroke sequence. The |
74857f83 | 6527 | @file{edmacro} package (invoked by @kbd{Z E}) scans along the |
d7b8e6c6 | 6528 | macro and tries to decode it back into human-readable steps. |
74857f83 JB |
6529 | Descriptions of the keystrokes are given as comments, which begin with |
6530 | @samp{;;}, and which are ignored when the edited macro is saved. | |
6531 | Spaces and line breaks are also ignored when the edited macro is saved. | |
6532 | To enter a space into the macro, type @code{SPC}. All the special | |
6533 | characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL}, | |
6534 | and @code{NUL} must be written in all uppercase, as must the prefixes | |
6535 | @code{C-} and @code{M-}. | |
d7b8e6c6 EZ |
6536 | |
6537 | Let's edit in a new definition, for computing harmonic numbers. | |
74857f83 | 6538 | First, erase the four lines of the old definition. Then, type |
d7b8e6c6 | 6539 | in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands |
74857f83 JB |
6540 | to copy it from this page of the Info file; you can of course skip |
6541 | typing the comments, which begin with @samp{;;}). | |
d7b8e6c6 EZ |
6542 | |
6543 | @smallexample | |
74857f83 JB |
6544 | Z` ;; calc-kbd-push (Save local values) |
6545 | 0 ;; calc digits (Push a zero onto the stack) | |
6546 | st ;; calc-store-into (Store it in the following variable) | |
6547 | 1 ;; calc quick variable (Quick variable q1) | |
6548 | 1 ;; calc digits (Initial value for the loop) | |
6549 | TAB ;; calc-roll-down (Swap initial and final) | |
6550 | Z( ;; calc-kbd-for (Begin the "for" loop) | |
6551 | & ;; calc-inv (Take the reciprocal) | |
6552 | s+ ;; calc-store-plus (Add to the following variable) | |
6553 | 1 ;; calc quick variable (Quick variable q1) | |
6554 | 1 ;; calc digits (The loop step is 1) | |
6555 | Z) ;; calc-kbd-end-for (End the "for" loop) | |
6556 | sr ;; calc-recall (Recall the final accumulated value) | |
6557 | 1 ;; calc quick variable (Quick variable q1) | |
6558 | Z' ;; calc-kbd-pop (Restore values) | |
d7b8e6c6 EZ |
6559 | @end smallexample |
6560 | ||
6561 | @noindent | |
33108698 | 6562 | Press @kbd{C-c C-c} to finish editing and return to the Calculator. |
d7b8e6c6 | 6563 | |
d7b8e6c6 | 6564 | @smallexample |
5d67986c | 6565 | @group |
d7b8e6c6 EZ |
6566 | 1: 20 1: 3.597739 |
6567 | . . | |
6568 | ||
6569 | 20 z h | |
d7b8e6c6 | 6570 | @end group |
5d67986c | 6571 | @end smallexample |
d7b8e6c6 | 6572 | |
74857f83 JB |
6573 | The @file{edmacro} package defines a handy @code{read-kbd-macro} command |
6574 | which reads the current region of the current buffer as a sequence of | |
6575 | keystroke names, and defines that sequence on the @kbd{X} | |
6576 | (and @kbd{C-x e}) key. Because this is so useful, Calc puts this | |
58547c3e | 6577 | command on the @kbd{C-x * m} key. Try reading in this macro in the |
74857f83 | 6578 | following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at |
58547c3e | 6579 | one end of the text below, then type @kbd{C-x * m} at the other. |
d7b8e6c6 | 6580 | |
d7b8e6c6 | 6581 | @example |
5d67986c | 6582 | @group |
d7b8e6c6 | 6583 | Z ` 0 t 1 |
aed79377 | 6584 | 1 TAB |
d7b8e6c6 EZ |
6585 | Z ( & s + 1 1 Z ) |
6586 | r 1 | |
6587 | Z ' | |
d7b8e6c6 | 6588 | @end group |
5d67986c | 6589 | @end example |
d7b8e6c6 EZ |
6590 | |
6591 | (@bullet{}) @strong{Exercise 8.} A general algorithm for solving | |
6592 | equations numerically is @dfn{Newton's Method}. Given the equation | |
a4231b04 JB |
6593 | @expr{f(x) = 0} for any function @expr{f}, and an initial guess |
6594 | @expr{x_0} which is reasonably close to the desired solution, apply | |
d7b8e6c6 EZ |
6595 | this formula over and over: |
6596 | ||
6597 | @ifinfo | |
6598 | @example | |
6599 | new_x = x - f(x)/f'(x) | |
6600 | @end example | |
6601 | @end ifinfo | |
6602 | @tex | |
6603 | \beforedisplay | |
a4231b04 | 6604 | $$ x_{\rm new} = x - {f(x) \over f'(x)} $$ |
d7b8e6c6 EZ |
6605 | \afterdisplay |
6606 | @end tex | |
6607 | ||
6608 | @noindent | |
a4231b04 | 6609 | where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x} |
d7b8e6c6 | 6610 | values will quickly converge to a solution, i.e., eventually |
8e04863e | 6611 | @texline @math{x_{\rm new}} |
a4231b04 JB |
6612 | @infoline @expr{new_x} |
6613 | and @expr{x} will be equal to within the limits | |
d7b8e6c6 | 6614 | of the current precision. Write a program which takes a formula |
a4231b04 JB |
6615 | involving the variable @expr{x}, and an initial guess @expr{x_0}, |
6616 | on the stack, and produces a value of @expr{x} for which the formula | |
6617 | is zero. Use it to find a solution of | |
8e04863e | 6618 | @texline @math{\sin(\cos x) = 0.5} |
a4231b04 JB |
6619 | @infoline @expr{sin(cos(x)) = 0.5} |
6620 | near @expr{x = 4.5}. (Use angles measured in radians.) Note that | |
d7b8e6c6 EZ |
6621 | the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's |
6622 | method when it is able. @xref{Programming Answer 8, 8}. (@bullet{}) | |
6623 | ||
6624 | @cindex Digamma function | |
6625 | @cindex Gamma constant, Euler's | |
6626 | @cindex Euler's gamma constant | |
a4231b04 | 6627 | (@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function |
8e04863e | 6628 | @texline @math{\psi(z) (``psi'')} |
a4231b04 JB |
6629 | @infoline @expr{psi(z)} |
6630 | is defined as the derivative of | |
8e04863e | 6631 | @texline @math{\ln \Gamma(z)}. |
a4231b04 JB |
6632 | @infoline @expr{ln(gamma(z))}. |
6633 | For large values of @expr{z}, it can be approximated by the infinite sum | |
d7b8e6c6 EZ |
6634 | |
6635 | @ifinfo | |
6636 | @example | |
6637 | psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf) | |
6638 | @end example | |
6639 | @end ifinfo | |
6640 | @tex | |
d7b8e6c6 EZ |
6641 | \beforedisplay |
6642 | $$ \psi(z) \approx \ln z - {1\over2z} - | |
6643 | \sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}} | |
6644 | $$ | |
6645 | \afterdisplay | |
6646 | @end tex | |
6647 | ||
6648 | @noindent | |
a4231b04 | 6649 | where |
8e04863e | 6650 | @texline @math{\sum} |
a4231b04 JB |
6651 | @infoline @expr{sum} |
6652 | represents the sum over @expr{n} from 1 to infinity | |
d7b8e6c6 EZ |
6653 | (or to some limit high enough to give the desired accuracy), and |
6654 | the @code{bern} function produces (exact) Bernoulli numbers. | |
6655 | While this sum is not guaranteed to converge, in practice it is safe. | |
6656 | An interesting mathematical constant is Euler's gamma, which is equal | |
6657 | to about 0.5772. One way to compute it is by the formula, | |
8e04863e | 6658 | @texline @math{\gamma = -\psi(1)}. |
a4231b04 JB |
6659 | @infoline @expr{gamma = -psi(1)}. |
6660 | Unfortunately, 1 isn't a large enough argument | |
6661 | for the above formula to work (5 is a much safer value for @expr{z}). | |
6662 | Fortunately, we can compute | |
8e04863e | 6663 | @texline @math{\psi(1)} |
a4231b04 JB |
6664 | @infoline @expr{psi(1)} |
6665 | from | |
8e04863e | 6666 | @texline @math{\psi(5)} |
a4231b04 JB |
6667 | @infoline @expr{psi(5)} |
6668 | using the recurrence | |
8e04863e | 6669 | @texline @math{\psi(z+1) = \psi(z) + {1 \over z}}. |
a4231b04 JB |
6670 | @infoline @expr{psi(z+1) = psi(z) + 1/z}. |
6671 | Your task: Develop a program to compute | |
8e04863e | 6672 | @texline @math{\psi(z)}; |
a4231b04 JB |
6673 | @infoline @expr{psi(z)}; |
6674 | it should ``pump up'' @expr{z} | |
d7b8e6c6 EZ |
6675 | if necessary to be greater than 5, then use the above summation |
6676 | formula. Use looping commands to compute the sum. Use your function | |
a4231b04 | 6677 | to compute |
8e04863e | 6678 | @texline @math{\gamma} |
a4231b04 JB |
6679 | @infoline @expr{gamma} |
6680 | to twelve decimal places. (Calc has a built-in command | |
d7b8e6c6 EZ |
6681 | for Euler's constant, @kbd{I P}, which you can use to check your answer.) |
6682 | @xref{Programming Answer 9, 9}. (@bullet{}) | |
6683 | ||
6684 | @cindex Polynomial, list of coefficients | |
a4231b04 JB |
6685 | (@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and |
6686 | a number @expr{m} on the stack, where the polynomial is of degree | |
6687 | @expr{m} or less (i.e., does not have any terms higher than @expr{x^m}), | |
d7b8e6c6 | 6688 | write a program to convert the polynomial into a list-of-coefficients |
a4231b04 JB |
6689 | notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6} |
6690 | should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop | |
d7b8e6c6 EZ |
6691 | a way to convert from this form back to the standard algebraic form. |
6692 | @xref{Programming Answer 10, 10}. (@bullet{}) | |
6693 | ||
6694 | @cindex Recursion | |
6695 | (@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the | |
6696 | first kind} are defined by the recurrences, | |
6697 | ||
6698 | @ifinfo | |
6699 | @example | |
6700 | s(n,n) = 1 for n >= 0, | |
6701 | s(n,0) = 0 for n > 0, | |
6702 | s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1. | |
6703 | @end example | |
6704 | @end ifinfo | |
6705 | @tex | |
6706 | \turnoffactive | |
6707 | \beforedisplay | |
6708 | $$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr | |
6709 | s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr | |
6710 | s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad | |
6711 | \hbox{for } n \ge m \ge 1.} | |
6712 | $$ | |
6713 | \afterdisplay | |
6714 | \vskip5pt | |
6715 | (These numbers are also sometimes written $\displaystyle{n \brack m}$.) | |
6716 | @end tex | |
6717 | ||
6718 | This can be implemented using a @dfn{recursive} program in Calc; the | |
6719 | program must invoke itself in order to calculate the two righthand | |
6720 | terms in the general formula. Since it always invokes itself with | |
6721 | ``simpler'' arguments, it's easy to see that it must eventually finish | |
6722 | the computation. Recursion is a little difficult with Emacs keyboard | |
6723 | macros since the macro is executed before its definition is complete. | |
6724 | So here's the recommended strategy: Create a ``dummy macro'' and assign | |
6725 | it to a key with, e.g., @kbd{Z K s}. Now enter the true definition, | |
6726 | using the @kbd{z s} command to call itself recursively, then assign it | |
6727 | to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run | |
6728 | the complete recursive program. (Another way is to use @w{@kbd{Z E}} | |
58547c3e | 6729 | or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once, |
d7b8e6c6 | 6730 | thus avoiding the ``training'' phase.) The task: Write a program |
a4231b04 JB |
6731 | that computes Stirling numbers of the first kind, given @expr{n} and |
6732 | @expr{m} on the stack. Test it with @emph{small} inputs like | |
6733 | @expr{s(4,2)}. (There is a built-in command for Stirling numbers, | |
d7b8e6c6 EZ |
6734 | @kbd{k s}, which you can use to check your answers.) |
6735 | @xref{Programming Answer 11, 11}. (@bullet{}) | |
6736 | ||
6737 | The programming commands we've seen in this part of the tutorial | |
6738 | are low-level, general-purpose operations. Often you will find | |
6739 | that a higher-level function, such as vector mapping or rewrite | |
6740 | rules, will do the job much more easily than a detailed, step-by-step | |
6741 | program can: | |
6742 | ||
6743 | (@bullet{}) @strong{Exercise 12.} Write another program for | |
6744 | computing Stirling numbers of the first kind, this time using | |
a4231b04 | 6745 | rewrite rules. Once again, @expr{n} and @expr{m} should be taken |
d7b8e6c6 EZ |
6746 | from the stack. @xref{Programming Answer 12, 12}. (@bullet{}) |
6747 | ||
6748 | @example | |
6749 | ||
6750 | @end example | |
6751 | This ends the tutorial section of the Calc manual. Now you know enough | |
6752 | about Calc to use it effectively for many kinds of calculations. But | |
6753 | Calc has many features that were not even touched upon in this tutorial. | |
6754 | @c [not-split] | |
6755 | The rest of this manual tells the whole story. | |
6756 | @c [when-split] | |
6757 | @c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story. | |
6758 | ||
6759 | @page | |
6760 | @node Answers to Exercises, , Programming Tutorial, Tutorial | |
6761 | @section Answers to Exercises | |
6762 | ||
6763 | @noindent | |
6764 | This section includes answers to all the exercises in the Calc tutorial. | |
6765 | ||
6766 | @menu | |
5d67986c | 6767 | * RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * - |
d7b8e6c6 EZ |
6768 | * RPN Answer 2:: 2*4 + 7*9.5 + 5/4 |
6769 | * RPN Answer 3:: Operating on levels 2 and 3 | |
6770 | * RPN Answer 4:: Joe's complex problems | |
6771 | * Algebraic Answer 1:: Simulating Q command | |
6772 | * Algebraic Answer 2:: Joe's algebraic woes | |
6773 | * Algebraic Answer 3:: 1 / 0 | |
6774 | * Modes Answer 1:: 3#0.1 = 3#0.0222222? | |
6775 | * Modes Answer 2:: 16#f.e8fe15 | |
6776 | * Modes Answer 3:: Joe's rounding bug | |
6777 | * Modes Answer 4:: Why floating point? | |
6778 | * Arithmetic Answer 1:: Why the \ command? | |
6779 | * Arithmetic Answer 2:: Tripping up the B command | |
6780 | * Vector Answer 1:: Normalizing a vector | |
6781 | * Vector Answer 2:: Average position | |
6782 | * Matrix Answer 1:: Row and column sums | |
6783 | * Matrix Answer 2:: Symbolic system of equations | |
6784 | * Matrix Answer 3:: Over-determined system | |
6785 | * List Answer 1:: Powers of two | |
6786 | * List Answer 2:: Least-squares fit with matrices | |
6787 | * List Answer 3:: Geometric mean | |
6788 | * List Answer 4:: Divisor function | |
6789 | * List Answer 5:: Duplicate factors | |
6790 | * List Answer 6:: Triangular list | |
6791 | * List Answer 7:: Another triangular list | |
6792 | * List Answer 8:: Maximum of Bessel function | |
6793 | * List Answer 9:: Integers the hard way | |
6794 | * List Answer 10:: All elements equal | |
6795 | * List Answer 11:: Estimating pi with darts | |
6796 | * List Answer 12:: Estimating pi with matchsticks | |
6797 | * List Answer 13:: Hash codes | |
6798 | * List Answer 14:: Random walk | |
6799 | * Types Answer 1:: Square root of pi times rational | |
6800 | * Types Answer 2:: Infinities | |
6801 | * Types Answer 3:: What can "nan" be? | |
6802 | * Types Answer 4:: Abbey Road | |
6803 | * Types Answer 5:: Friday the 13th | |
6804 | * Types Answer 6:: Leap years | |
6805 | * Types Answer 7:: Erroneous donut | |
6806 | * Types Answer 8:: Dividing intervals | |
6807 | * Types Answer 9:: Squaring intervals | |
6808 | * Types Answer 10:: Fermat's primality test | |
6809 | * Types Answer 11:: pi * 10^7 seconds | |
6810 | * Types Answer 12:: Abbey Road on CD | |
6811 | * Types Answer 13:: Not quite pi * 10^7 seconds | |
6812 | * Types Answer 14:: Supercomputers and c | |
6813 | * Types Answer 15:: Sam the Slug | |
6814 | * Algebra Answer 1:: Squares and square roots | |
6815 | * Algebra Answer 2:: Building polynomial from roots | |
6816 | * Algebra Answer 3:: Integral of x sin(pi x) | |
6817 | * Algebra Answer 4:: Simpson's rule | |
6818 | * Rewrites Answer 1:: Multiplying by conjugate | |
6819 | * Rewrites Answer 2:: Alternative fib rule | |
6820 | * Rewrites Answer 3:: Rewriting opt(a) + opt(b) x | |
6821 | * Rewrites Answer 4:: Sequence of integers | |
6822 | * Rewrites Answer 5:: Number of terms in sum | |
8c399bc1 | 6823 | * Rewrites Answer 6:: Truncated Taylor series |
d7b8e6c6 EZ |
6824 | * Programming Answer 1:: Fresnel's C(x) |
6825 | * Programming Answer 2:: Negate third stack element | |
6826 | * Programming Answer 3:: Compute sin(x) / x, etc. | |
6827 | * Programming Answer 4:: Average value of a list | |
6828 | * Programming Answer 5:: Continued fraction phi | |
6829 | * Programming Answer 6:: Matrix Fibonacci numbers | |
6830 | * Programming Answer 7:: Harmonic number greater than 4 | |
6831 | * Programming Answer 8:: Newton's method | |
6832 | * Programming Answer 9:: Digamma function | |
6833 | * Programming Answer 10:: Unpacking a polynomial | |
6834 | * Programming Answer 11:: Recursive Stirling numbers | |
6835 | * Programming Answer 12:: Stirling numbers with rewrites | |
6836 | @end menu | |
6837 | ||
6838 | @c The following kludgery prevents the individual answers from | |
6839 | @c being entered on the table of contents. | |
6840 | @tex | |
6841 | \global\let\oldwrite=\write | |
6842 | \gdef\skipwrite#1#2{\let\write=\oldwrite} | |
6843 | \global\let\oldchapternofonts=\chapternofonts | |
6844 | \gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts} | |
6845 | @end tex | |
6846 | ||
6847 | @node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises | |
6848 | @subsection RPN Tutorial Exercise 1 | |
6849 | ||
6850 | @noindent | |
6851 | @kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -} | |
6852 | ||
a4231b04 | 6853 | The result is |
8e04863e | 6854 | @texline @math{1 - (2 \times (3 + 4)) = -13}. |
a4231b04 | 6855 | @infoline @expr{1 - (2 * (3 + 4)) = -13}. |
d7b8e6c6 EZ |
6856 | |
6857 | @node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises | |
6858 | @subsection RPN Tutorial Exercise 2 | |
6859 | ||
6860 | @noindent | |
8e04863e | 6861 | @texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75} |
a4231b04 | 6862 | @infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75} |
d7b8e6c6 | 6863 | |
a4231b04 | 6864 | After computing the intermediate term |
8e04863e | 6865 | @texline @math{2\times4 = 8}, |
a4231b04 JB |
6866 | @infoline @expr{2*4 = 8}, |
6867 | you can leave that result on the stack while you compute the second | |
6868 | term. With both of these results waiting on the stack you can then | |
6869 | compute the final term, then press @kbd{+ +} to add everything up. | |
d7b8e6c6 | 6870 | |
d7b8e6c6 | 6871 | @smallexample |
5d67986c | 6872 | @group |
d7b8e6c6 EZ |
6873 | 2: 2 1: 8 3: 8 2: 8 |
6874 | 1: 4 . 2: 7 1: 66.5 | |
6875 | . 1: 9.5 . | |
6876 | . | |
6877 | ||
5d67986c | 6878 | 2 @key{RET} 4 * 7 @key{RET} 9.5 * |
d7b8e6c6 | 6879 | |
d7b8e6c6 | 6880 | @end group |
5d67986c | 6881 | @end smallexample |
d7b8e6c6 | 6882 | @noindent |
d7b8e6c6 | 6883 | @smallexample |
5d67986c | 6884 | @group |
d7b8e6c6 EZ |
6885 | 4: 8 3: 8 2: 8 1: 75.75 |
6886 | 3: 66.5 2: 66.5 1: 67.75 . | |
6887 | 2: 5 1: 1.25 . | |
6888 | 1: 4 . | |
6889 | . | |
6890 | ||
5d67986c | 6891 | 5 @key{RET} 4 / + + |
d7b8e6c6 | 6892 | @end group |
5d67986c | 6893 | @end smallexample |
d7b8e6c6 EZ |
6894 | |
6895 | Alternatively, you could add the first two terms before going on | |
6896 | with the third term. | |
6897 | ||
d7b8e6c6 | 6898 | @smallexample |
5d67986c | 6899 | @group |
d7b8e6c6 EZ |
6900 | 2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75 |
6901 | 1: 66.5 . 2: 5 1: 1.25 . | |
6902 | . 1: 4 . | |
6903 | . | |
6904 | ||
5d67986c | 6905 | ... + 5 @key{RET} 4 / + |
d7b8e6c6 | 6906 | @end group |
5d67986c | 6907 | @end smallexample |
d7b8e6c6 EZ |
6908 | |
6909 | On an old-style RPN calculator this second method would have the | |
6910 | advantage of using only three stack levels. But since Calc's stack | |
6911 | can grow arbitrarily large this isn't really an issue. Which method | |
6912 | you choose is purely a matter of taste. | |
6913 | ||
6914 | @node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises | |
6915 | @subsection RPN Tutorial Exercise 3 | |
6916 | ||
6917 | @noindent | |
6918 | The @key{TAB} key provides a way to operate on the number in level 2. | |
6919 | ||
d7b8e6c6 | 6920 | @smallexample |
5d67986c | 6921 | @group |
d7b8e6c6 EZ |
6922 | 3: 10 3: 10 4: 10 3: 10 3: 10 |
6923 | 2: 20 2: 30 3: 30 2: 30 2: 21 | |
6924 | 1: 30 1: 20 2: 20 1: 21 1: 30 | |
6925 | . . 1: 1 . . | |
6926 | . | |
6927 | ||
5d67986c | 6928 | @key{TAB} 1 + @key{TAB} |
d7b8e6c6 | 6929 | @end group |
5d67986c | 6930 | @end smallexample |
d7b8e6c6 | 6931 | |
5d67986c | 6932 | Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3. |
d7b8e6c6 | 6933 | |
d7b8e6c6 | 6934 | @smallexample |
5d67986c | 6935 | @group |
d7b8e6c6 EZ |
6936 | 3: 10 3: 21 3: 21 3: 30 3: 11 |
6937 | 2: 21 2: 30 2: 30 2: 11 2: 21 | |
6938 | 1: 30 1: 10 1: 11 1: 21 1: 30 | |
6939 | . . . . . | |
6940 | ||
5d67986c | 6941 | M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB} |
d7b8e6c6 | 6942 | @end group |
5d67986c | 6943 | @end smallexample |
d7b8e6c6 EZ |
6944 | |
6945 | @node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises | |
6946 | @subsection RPN Tutorial Exercise 4 | |
6947 | ||
6948 | @noindent | |
6949 | Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked, | |
6950 | but using both the comma and the space at once yields: | |
6951 | ||
d7b8e6c6 | 6952 | @smallexample |
5d67986c | 6953 | @group |
d7b8e6c6 EZ |
6954 | 1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ... |
6955 | . 1: 2 . 1: (2, ... 1: (2, 3) | |
6956 | . . . | |
6957 | ||
5d67986c | 6958 | ( 2 , @key{SPC} 3 ) |
d7b8e6c6 | 6959 | @end group |
5d67986c | 6960 | @end smallexample |
d7b8e6c6 EZ |
6961 | |
6962 | Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the | |
6963 | extra incomplete object to the top of the stack and delete it. | |
6964 | But a feature of Calc is that @key{DEL} on an incomplete object | |
6965 | deletes just one component out of that object, so he had to press | |
6966 | @key{DEL} twice to finish the job. | |
6967 | ||
d7b8e6c6 | 6968 | @smallexample |
5d67986c | 6969 | @group |
d7b8e6c6 EZ |
6970 | 2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3) |
6971 | 1: (2, 3) 1: (2, ... 1: ( ... . | |
6972 | . . . | |
6973 | ||
5d67986c | 6974 | @key{TAB} @key{DEL} @key{DEL} |
d7b8e6c6 | 6975 | @end group |
5d67986c | 6976 | @end smallexample |
d7b8e6c6 EZ |
6977 | |
6978 | (As it turns out, deleting the second-to-top stack entry happens often | |
5d67986c RS |
6979 | enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that. |
6980 | @kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit | |
d7b8e6c6 EZ |
6981 | the ``feature'' that tripped poor Joe.) |
6982 | ||
6983 | @node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises | |
6984 | @subsection Algebraic Entry Tutorial Exercise 1 | |
6985 | ||
6986 | @noindent | |
6987 | Type @kbd{' sqrt($) @key{RET}}. | |
6988 | ||
6989 | If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}. | |
6990 | Or, RPN style, @kbd{0.5 ^}. | |
6991 | ||
6992 | (Actually, @samp{$^1:2}, using the fraction one-half as the power, is | |
a4231b04 JB |
6993 | a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas |
6994 | @samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.) | |
d7b8e6c6 EZ |
6995 | |
6996 | @node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises | |
6997 | @subsection Algebraic Entry Tutorial Exercise 2 | |
6998 | ||
6999 | @noindent | |
7000 | In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function | |
7001 | name with @samp{1+y} as its argument. Assigning a value to a variable | |
7002 | has no relation to a function by the same name. Joe needed to use an | |
7003 | explicit @samp{*} symbol here: @samp{2 x*(1+y)}. | |
7004 | ||
7005 | @node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises | |
7006 | @subsection Algebraic Entry Tutorial Exercise 3 | |
7007 | ||
7008 | @noindent | |
a4231b04 | 7009 | The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}. |
d7b8e6c6 EZ |
7010 | The ``function'' @samp{/} cannot be evaluated when its second argument |
7011 | is zero, so it is left in symbolic form. When you now type @kbd{0 *}, | |
7012 | the result will be zero because Calc uses the general rule that ``zero | |
7013 | times anything is zero.'' | |
7014 | ||
7015 | @c [fix-ref Infinities] | |
07ce2eb3 | 7016 | The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0} |
d7b8e6c6 EZ |
7017 | results in a special symbol that represents ``infinity.'' If you |
7018 | multiply infinity by zero, Calc uses another special new symbol to | |
7019 | show that the answer is ``indeterminate.'' @xref{Infinities}, for | |
7020 | further discussion of infinite and indeterminate values. | |
7021 | ||
7022 | @node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises | |
7023 | @subsection Modes Tutorial Exercise 1 | |
7024 | ||
7025 | @noindent | |
7026 | Calc always stores its numbers in decimal, so even though one-third has | |
7027 | an exact base-3 representation (@samp{3#0.1}), it is still stored as | |
7028 | 0.3333333 (chopped off after 12 or however many decimal digits) inside | |
7029 | the calculator's memory. When this inexact number is converted back | |
7030 | to base 3 for display, it may still be slightly inexact. When we | |
7031 | multiply this number by 3, we get 0.999999, also an inexact value. | |
7032 | ||
7033 | When Calc displays a number in base 3, it has to decide how many digits | |
7034 | to show. If the current precision is 12 (decimal) digits, that corresponds | |
7035 | to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an | |
7036 | exact integer, Calc shows only 25 digits, with the result that stored | |
7037 | numbers carry a little bit of extra information that may not show up on | |
7038 | the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666 | |
7039 | happened to round to a pleasing value when it lost that last 0.15 of a | |
7040 | digit, but it was still inexact in Calc's memory. When he divided by 2, | |
7041 | he still got the dreaded inexact value 0.333333. (Actually, he divided | |
7042 | 0.666667 by 2 to get 0.333334, which is why he got something a little | |
7043 | higher than @code{3#0.1} instead of a little lower.) | |
7044 | ||
7045 | If Joe didn't want to be bothered with all this, he could have typed | |
7046 | @kbd{M-24 d n} to display with one less digit than the default. (If | |
7047 | you give @kbd{d n} a negative argument, it uses default-minus-that, | |
7048 | so @kbd{M-- d n} would be an easier way to get the same effect.) Those | |
7049 | inexact results would still be lurking there, but they would now be | |
7050 | rounded to nice, natural-looking values for display purposes. (Remember, | |
7051 | @samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding | |
7052 | off one digit will round the number up to @samp{0.1}.) Depending on the | |
7053 | nature of your work, this hiding of the inexactness may be a benefit or | |
7054 | a danger. With the @kbd{d n} command, Calc gives you the choice. | |
7055 | ||
7056 | Incidentally, another consequence of all this is that if you type | |
7057 | @kbd{M-30 d n} to display more digits than are ``really there,'' | |
7058 | you'll see garbage digits at the end of the number. (In decimal | |
7059 | display mode, with decimally-stored numbers, these garbage digits are | |
7060 | always zero so they vanish and you don't notice them.) Because Calc | |
7061 | rounds off that 0.15 digit, there is the danger that two numbers could | |
7062 | be slightly different internally but still look the same. If you feel | |
7063 | uneasy about this, set the @kbd{d n} precision to be a little higher | |
7064 | than normal; you'll get ugly garbage digits, but you'll always be able | |
7065 | to tell two distinct numbers apart. | |
7066 | ||
7067 | An interesting side note is that most computers store their | |
7068 | floating-point numbers in binary, and convert to decimal for display. | |
7069 | Thus everyday programs have the same problem: Decimal 0.1 cannot be | |
7070 | represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10} | |
7071 | comes out as an inexact approximation to 1 on some machines (though | |
7072 | they generally arrange to hide it from you by rounding off one digit as | |
7073 | we did above). Because Calc works in decimal instead of binary, you can | |
7074 | be sure that numbers that look exact @emph{are} exact as long as you stay | |
7075 | in decimal display mode. | |
7076 | ||
7077 | It's not hard to show that any number that can be represented exactly | |
7078 | in binary, octal, or hexadecimal is also exact in decimal, so the kinds | |
7079 | of problems we saw in this exercise are likely to be severe only when | |
7080 | you use a relatively unusual radix like 3. | |
7081 | ||
7082 | @node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises | |
7083 | @subsection Modes Tutorial Exercise 2 | |
7084 | ||
7085 | If the radix is 15 or higher, we can't use the letter @samp{e} to mark | |
7086 | the exponent because @samp{e} is interpreted as a digit. When Calc | |
7087 | needs to display scientific notation in a high radix, it writes | |
7088 | @samp{16#F.E8F*16.^15}. You can enter a number like this as an | |
7089 | algebraic entry. Also, pressing @kbd{e} without any digits before it | |
7090 | normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and | |
5d67986c | 7091 | puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another |
d7b8e6c6 EZ |
7092 | way to enter this number. |
7093 | ||
7094 | The reason Calc puts a decimal point in the @samp{16.^} is to prevent | |
7095 | huge integers from being generated if the exponent is large (consider | |
7096 | @samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant | |
7097 | exact integer and then throw away most of the digits when we multiply | |
7098 | it by the floating-point @samp{16#1.23}). While this wouldn't normally | |
7099 | matter for display purposes, it could give you a nasty surprise if you | |
7100 | copied that number into a file and later moved it back into Calc. | |
7101 | ||
7102 | @node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises | |
7103 | @subsection Modes Tutorial Exercise 3 | |
7104 | ||
7105 | @noindent | |
a4231b04 | 7106 | The answer he got was @expr{0.5000000000006399}. |
d7b8e6c6 EZ |
7107 | |
7108 | The problem is not that the square operation is inexact, but that the | |
7109 | sine of 45 that was already on the stack was accurate to only 12 places. | |
7110 | Arbitrary-precision calculations still only give answers as good as | |
7111 | their inputs. | |
7112 | ||
7113 | The real problem is that there is no 12-digit number which, when | |
7114 | squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]} | |
7115 | commands decrease or increase a number by one unit in the last | |
7116 | place (according to the current precision). They are useful for | |
7117 | determining facts like this. | |
7118 | ||
d7b8e6c6 | 7119 | @smallexample |
5d67986c | 7120 | @group |
d7b8e6c6 EZ |
7121 | 1: 0.707106781187 1: 0.500000000001 |
7122 | . . | |
7123 | ||
7124 | 45 S 2 ^ | |
7125 | ||
d7b8e6c6 | 7126 | @end group |
5d67986c | 7127 | @end smallexample |
d7b8e6c6 | 7128 | @noindent |
d7b8e6c6 | 7129 | @smallexample |
5d67986c | 7130 | @group |
d7b8e6c6 EZ |
7131 | 1: 0.707106781187 1: 0.707106781186 1: 0.499999999999 |
7132 | . . . | |
7133 | ||
5d67986c | 7134 | U @key{DEL} f [ 2 ^ |
d7b8e6c6 | 7135 | @end group |
5d67986c | 7136 | @end smallexample |
d7b8e6c6 EZ |
7137 | |
7138 | A high-precision calculation must be carried out in high precision | |
7139 | all the way. The only number in the original problem which was known | |
7140 | exactly was the quantity 45 degrees, so the precision must be raised | |
7141 | before anything is done after the number 45 has been entered in order | |
7142 | for the higher precision to be meaningful. | |
7143 | ||
7144 | @node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises | |
7145 | @subsection Modes Tutorial Exercise 4 | |
7146 | ||
7147 | @noindent | |
7148 | Many calculations involve real-world quantities, like the width and | |
7149 | height of a piece of wood or the volume of a jar. Such quantities | |
7150 | can't be measured exactly anyway, and if the data that is input to | |
7151 | a calculation is inexact, doing exact arithmetic on it is a waste | |
7152 | of time. | |
7153 | ||
7154 | Fractions become unwieldy after too many calculations have been | |
7155 | done with them. For example, the sum of the reciprocals of the | |
7156 | integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is | |
7157 | 9304682830147:2329089562800. After a point it will take a long | |
7158 | time to add even one more term to this sum, but a floating-point | |
7159 | calculation of the sum will not have this problem. | |
7160 | ||
7161 | Also, rational numbers cannot express the results of all calculations. | |
7162 | There is no fractional form for the square root of two, so if you type | |
7163 | @w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer. | |
7164 | ||
7165 | @node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises | |
7166 | @subsection Arithmetic Tutorial Exercise 1 | |
7167 | ||
7168 | @noindent | |
7169 | Dividing two integers that are larger than the current precision may | |
7170 | give a floating-point result that is inaccurate even when rounded | |
a4231b04 JB |
7171 | down to an integer. Consider @expr{123456789 / 2} when the current |
7172 | precision is 6 digits. The true answer is @expr{61728394.5}, but | |
7173 | with a precision of 6 this will be rounded to | |
8e04863e | 7174 | @texline @math{12345700.0/2.0 = 61728500.0}. |
a4231b04 | 7175 | @infoline @expr{12345700.@: / 2.@: = 61728500.}. |
d7b8e6c6 EZ |
7176 | The result, when converted to an integer, will be off by 106. |
7177 | ||
7178 | Here are two solutions: Raise the precision enough that the | |
7179 | floating-point round-off error is strictly to the right of the | |
07ce2eb3 | 7180 | decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2} |
a4231b04 | 7181 | produces the exact fraction @expr{123456789:2}, which can be rounded |
d7b8e6c6 EZ |
7182 | down by the @kbd{F} command without ever switching to floating-point |
7183 | format. | |
7184 | ||
7185 | @node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises | |
7186 | @subsection Arithmetic Tutorial Exercise 2 | |
7187 | ||
7188 | @noindent | |
a4231b04 JB |
7189 | @kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it |
7190 | does a floating-point calculation instead and produces @expr{1.5}. | |
d7b8e6c6 EZ |
7191 | |
7192 | Calc will find an exact result for a logarithm if the result is an integer | |
07ce2eb3 JB |
7193 | or (when in Fraction mode) the reciprocal of an integer. But there is |
7194 | no efficient way to search the space of all possible rational numbers | |
7195 | for an exact answer, so Calc doesn't try. | |
d7b8e6c6 EZ |
7196 | |
7197 | @node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises | |
7198 | @subsection Vector Tutorial Exercise 1 | |
7199 | ||
7200 | @noindent | |
7201 | Duplicate the vector, compute its length, then divide the vector | |
7202 | by its length: @kbd{@key{RET} A /}. | |
7203 | ||
d7b8e6c6 | 7204 | @smallexample |
5d67986c | 7205 | @group |
d7b8e6c6 EZ |
7206 | 1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1. |
7207 | . 1: 3.74165738677 . . | |
7208 | . | |
7209 | ||
5d67986c | 7210 | r 1 @key{RET} A / A |
d7b8e6c6 | 7211 | @end group |
5d67986c | 7212 | @end smallexample |
d7b8e6c6 EZ |
7213 | |
7214 | The final @kbd{A} command shows that the normalized vector does | |
7215 | indeed have unit length. | |
7216 | ||
7217 | @node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises | |
7218 | @subsection Vector Tutorial Exercise 2 | |
7219 | ||
7220 | @noindent | |
7221 | The average position is equal to the sum of the products of the | |
7222 | positions times their corresponding probabilities. This is the | |
7223 | definition of the dot product operation. So all you need to do | |
7224 | is to put the two vectors on the stack and press @kbd{*}. | |
7225 | ||
7226 | @node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises | |
7227 | @subsection Matrix Tutorial Exercise 1 | |
7228 | ||
7229 | @noindent | |
7230 | The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to | |
7231 | get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum. | |
7232 | ||
7233 | @node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises | |
7234 | @subsection Matrix Tutorial Exercise 2 | |
7235 | ||
7236 | @ifinfo | |
d7b8e6c6 | 7237 | @example |
5d67986c | 7238 | @group |
d7b8e6c6 EZ |
7239 | x + a y = 6 |
7240 | x + b y = 10 | |
d7b8e6c6 | 7241 | @end group |
5d67986c | 7242 | @end example |
d7b8e6c6 EZ |
7243 | @end ifinfo |
7244 | @tex | |
7245 | \turnoffactive | |
7246 | \beforedisplay | |
7247 | $$ \eqalign{ x &+ a y = 6 \cr | |
7248 | x &+ b y = 10} | |
7249 | $$ | |
7250 | \afterdisplay | |
7251 | @end tex | |
7252 | ||
7253 | Just enter the righthand side vector, then divide by the lefthand side | |
7254 | matrix as usual. | |
7255 | ||
d7b8e6c6 | 7256 | @smallexample |
5d67986c | 7257 | @group |
d7b8e6c6 EZ |
7258 | 1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ] |
7259 | . 1: [ [ 1, a ] . | |
7260 | [ 1, b ] ] | |
7261 | . | |
7262 | ||
5d67986c | 7263 | ' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} / |
d7b8e6c6 | 7264 | @end group |
5d67986c | 7265 | @end smallexample |
d7b8e6c6 | 7266 | |
07ce2eb3 | 7267 | This can be made more readable using @kbd{d B} to enable Big display |
d7b8e6c6 EZ |
7268 | mode: |
7269 | ||
d7b8e6c6 | 7270 | @smallexample |
5d67986c | 7271 | @group |
d7b8e6c6 EZ |
7272 | 4 a 4 |
7273 | 1: [6 - -----, -----] | |
7274 | b - a b - a | |
d7b8e6c6 | 7275 | @end group |
5d67986c | 7276 | @end smallexample |
d7b8e6c6 | 7277 | |
07ce2eb3 | 7278 | Type @kbd{d N} to return to Normal display mode afterwards. |
d7b8e6c6 EZ |
7279 | |
7280 | @node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises | |
7281 | @subsection Matrix Tutorial Exercise 3 | |
7282 | ||
7283 | @noindent | |
a4231b04 | 7284 | To solve |
8e04863e | 7285 | @texline @math{A^T A \, X = A^T B}, |
a4231b04 JB |
7286 | @infoline @expr{trn(A) * A * X = trn(A) * B}, |
7287 | first we compute | |
8e04863e | 7288 | @texline @math{A' = A^T A} |
a4231b04 JB |
7289 | @infoline @expr{A2 = trn(A) * A} |
7290 | and | |
8e04863e | 7291 | @texline @math{B' = A^T B}; |
a4231b04 JB |
7292 | @infoline @expr{B2 = trn(A) * B}; |
7293 | now, we have a system | |
8e04863e | 7294 | @texline @math{A' X = B'} |
a4231b04 JB |
7295 | @infoline @expr{A2 * X = B2} |
7296 | which we can solve using Calc's @samp{/} command. | |
d7b8e6c6 EZ |
7297 | |
7298 | @ifinfo | |
d7b8e6c6 | 7299 | @example |
5d67986c | 7300 | @group |
d7b8e6c6 EZ |
7301 | a + 2b + 3c = 6 |
7302 | 4a + 5b + 6c = 2 | |
7303 | 7a + 6b = 3 | |
7304 | 2a + 4b + 6c = 11 | |
d7b8e6c6 | 7305 | @end group |
5d67986c | 7306 | @end example |
d7b8e6c6 EZ |
7307 | @end ifinfo |
7308 | @tex | |
7309 | \turnoffactive | |
7310 | \beforedisplayh | |
7311 | $$ \openup1\jot \tabskip=0pt plus1fil | |
7312 | \halign to\displaywidth{\tabskip=0pt | |
7313 | $\hfil#$&$\hfil{}#{}$& | |
7314 | $\hfil#$&$\hfil{}#{}$& | |
7315 | $\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr | |
7316 | a&+&2b&+&3c&=6 \cr | |
7317 | 4a&+&5b&+&6c&=2 \cr | |
7318 | 7a&+&6b& & &=3 \cr | |
7319 | 2a&+&4b&+&6c&=11 \cr} | |
7320 | $$ | |
7321 | \afterdisplayh | |
7322 | @end tex | |
7323 | ||
7324 | The first step is to enter the coefficient matrix. We'll store it in | |
7325 | quick variable number 7 for later reference. Next, we compute the | |
8e04863e | 7326 | @texline @math{B'} |
a4231b04 JB |
7327 | @infoline @expr{B2} |
7328 | vector. | |
d7b8e6c6 | 7329 | |
d7b8e6c6 | 7330 | @smallexample |
5d67986c | 7331 | @group |
d7b8e6c6 EZ |
7332 | 1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96] |
7333 | [ 4, 5, 6 ] [ 2, 5, 6, 4 ] . | |
7334 | [ 7, 6, 0 ] [ 3, 6, 0, 6 ] ] | |
7335 | [ 2, 4, 6 ] ] 1: [6, 2, 3, 11] | |
7336 | . . | |
7337 | ||
5d67986c | 7338 | ' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] * |
d7b8e6c6 | 7339 | @end group |
5d67986c | 7340 | @end smallexample |
d7b8e6c6 EZ |
7341 | |
7342 | @noindent | |
a4231b04 | 7343 | Now we compute the matrix |
8e04863e | 7344 | @texline @math{A'} |
a4231b04 JB |
7345 | @infoline @expr{A2} |
7346 | and divide. | |
d7b8e6c6 | 7347 | |
d7b8e6c6 | 7348 | @smallexample |
5d67986c | 7349 | @group |
d7b8e6c6 EZ |
7350 | 2: [57, 84, 96] 1: [-11.64, 14.08, -3.64] |
7351 | 1: [ [ 70, 72, 39 ] . | |
7352 | [ 72, 81, 60 ] | |
7353 | [ 39, 60, 81 ] ] | |
7354 | . | |
7355 | ||
7356 | r 7 v t r 7 * / | |
d7b8e6c6 | 7357 | @end group |
5d67986c | 7358 | @end smallexample |
d7b8e6c6 EZ |
7359 | |
7360 | @noindent | |
7361 | (The actual computed answer will be slightly inexact due to | |
7362 | round-off error.) | |
7363 | ||
a4231b04 | 7364 | Notice that the answers are similar to those for the |
8e04863e | 7365 | @texline @math{3\times3} |
a4231b04 JB |
7366 | @infoline 3x3 |
7367 | system solved in the text. That's because the fourth equation that was | |
d7b8e6c6 EZ |
7368 | added to the system is almost identical to the first one multiplied |
7369 | by two. (If it were identical, we would have gotten the exact same | |
a4231b04 | 7370 | answer since the |
8e04863e | 7371 | @texline @math{4\times3} |
a4231b04 JB |
7372 | @infoline 4x3 |
7373 | system would be equivalent to the original | |
8e04863e | 7374 | @texline @math{3\times3} |
a4231b04 | 7375 | @infoline 3x3 |
d7b8e6c6 EZ |
7376 | system.) |
7377 | ||
7378 | Since the first and fourth equations aren't quite equivalent, they | |
7379 | can't both be satisfied at once. Let's plug our answers back into | |
7380 | the original system of equations to see how well they match. | |
7381 | ||
d7b8e6c6 | 7382 | @smallexample |
5d67986c | 7383 | @group |
d7b8e6c6 EZ |
7384 | 2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2] |
7385 | 1: [ [ 1, 2, 3 ] . | |
7386 | [ 4, 5, 6 ] | |
7387 | [ 7, 6, 0 ] | |
7388 | [ 2, 4, 6 ] ] | |
7389 | . | |
7390 | ||
5d67986c | 7391 | r 7 @key{TAB} * |
d7b8e6c6 | 7392 | @end group |
5d67986c | 7393 | @end smallexample |
d7b8e6c6 EZ |
7394 | |
7395 | @noindent | |
a4231b04 JB |
7396 | This is reasonably close to our original @expr{B} vector, |
7397 | @expr{[6, 2, 3, 11]}. | |
d7b8e6c6 EZ |
7398 | |
7399 | @node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises | |
7400 | @subsection List Tutorial Exercise 1 | |
7401 | ||
7402 | @noindent | |
7403 | We can use @kbd{v x} to build a vector of integers. This needs to be | |
7404 | adjusted to get the range of integers we desire. Mapping @samp{-} | |
7405 | across the vector will accomplish this, although it turns out the | |
7406 | plain @samp{-} key will work just as well. | |
7407 | ||
d7b8e6c6 | 7408 | @smallexample |
5d67986c | 7409 | @group |
d7b8e6c6 EZ |
7410 | 2: 2 2: 2 |
7411 | 1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4] | |
7412 | . . | |
7413 | ||
5d67986c | 7414 | 2 v x 9 @key{RET} 5 V M - or 5 - |
d7b8e6c6 | 7415 | @end group |
5d67986c | 7416 | @end smallexample |
d7b8e6c6 EZ |
7417 | |
7418 | @noindent | |
7419 | Now we use @kbd{V M ^} to map the exponentiation operator across the | |
7420 | vector. | |
7421 | ||
d7b8e6c6 | 7422 | @smallexample |
5d67986c | 7423 | @group |
d7b8e6c6 EZ |
7424 | 1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] |
7425 | . | |
7426 | ||
7427 | V M ^ | |
d7b8e6c6 | 7428 | @end group |
5d67986c | 7429 | @end smallexample |
d7b8e6c6 EZ |
7430 | |
7431 | @node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises | |
7432 | @subsection List Tutorial Exercise 2 | |
7433 | ||
7434 | @noindent | |
a4231b04 | 7435 | Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before, |
d7b8e6c6 EZ |
7436 | the first job is to form the matrix that describes the problem. |
7437 | ||
7438 | @ifinfo | |
7439 | @example | |
7440 | m*x + b*1 = y | |
7441 | @end example | |
7442 | @end ifinfo | |
7443 | @tex | |
7444 | \turnoffactive | |
7445 | \beforedisplay | |
7446 | $$ m \times x + b \times 1 = y $$ | |
7447 | \afterdisplay | |
7448 | @end tex | |
7449 | ||
a4231b04 | 7450 | Thus we want a |
8e04863e | 7451 | @texline @math{19\times2} |
a4231b04 JB |
7452 | @infoline 19x2 |
7453 | matrix with our @expr{x} vector as one column and | |
d7b8e6c6 | 7454 | ones as the other column. So, first we build the column of ones, then |
a4231b04 | 7455 | we combine the two columns to form our @expr{A} matrix. |
d7b8e6c6 | 7456 | |
d7b8e6c6 | 7457 | @smallexample |
5d67986c | 7458 | @group |
d7b8e6c6 EZ |
7459 | 2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ] |
7460 | 1: [1, 1, 1, ...] [ 1.41, 1 ] | |
7461 | . [ 1.49, 1 ] | |
7462 | @dots{} | |
7463 | ||
5d67986c | 7464 | r 1 1 v b 19 @key{RET} M-2 v p v t s 3 |
d7b8e6c6 | 7465 | @end group |
5d67986c | 7466 | @end smallexample |
d7b8e6c6 EZ |
7467 | |
7468 | @noindent | |
a4231b04 | 7469 | Now we compute |
8e04863e | 7470 | @texline @math{A^T y} |
a4231b04 JB |
7471 | @infoline @expr{trn(A) * y} |
7472 | and | |
8e04863e | 7473 | @texline @math{A^T A} |
a4231b04 JB |
7474 | @infoline @expr{trn(A) * A} |
7475 | and divide. | |
d7b8e6c6 | 7476 | |
d7b8e6c6 | 7477 | @smallexample |
5d67986c | 7478 | @group |
d7b8e6c6 EZ |
7479 | 1: [33.36554, 13.613] 2: [33.36554, 13.613] |
7480 | . 1: [ [ 98.0003, 41.63 ] | |
7481 | [ 41.63, 19 ] ] | |
7482 | . | |
7483 | ||
7484 | v t r 2 * r 3 v t r 3 * | |
d7b8e6c6 | 7485 | @end group |
5d67986c | 7486 | @end smallexample |
d7b8e6c6 EZ |
7487 | |
7488 | @noindent | |
7489 | (Hey, those numbers look familiar!) | |
7490 | ||
d7b8e6c6 | 7491 | @smallexample |
5d67986c | 7492 | @group |
d7b8e6c6 EZ |
7493 | 1: [0.52141679, -0.425978] |
7494 | . | |
7495 | ||
7496 | / | |
d7b8e6c6 | 7497 | @end group |
5d67986c | 7498 | @end smallexample |
d7b8e6c6 | 7499 | |
a4231b04 | 7500 | Since we were solving equations of the form |
8e04863e | 7501 | @texline @math{m \times x + b \times 1 = y}, |
a4231b04 JB |
7502 | @infoline @expr{m*x + b*1 = y}, |
7503 | these numbers should be @expr{m} and @expr{b}, respectively. Sure | |
7504 | enough, they agree exactly with the result computed using @kbd{V M} and | |
7505 | @kbd{V R}! | |
d7b8e6c6 EZ |
7506 | |
7507 | The moral of this story: @kbd{V M} and @kbd{V R} will probably solve | |
7508 | your problem, but there is often an easier way using the higher-level | |
7509 | arithmetic functions! | |
7510 | ||
7511 | @c [fix-ref Curve Fitting] | |
7512 | In fact, there is a built-in @kbd{a F} command that does least-squares | |
7513 | fits. @xref{Curve Fitting}. | |
7514 | ||
7515 | @node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises | |
7516 | @subsection List Tutorial Exercise 3 | |
7517 | ||
7518 | @noindent | |
5d67986c | 7519 | Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or |
d7b8e6c6 | 7520 | whatever) to set the mark, then move to the other end of the list |
58547c3e | 7521 | and type @w{@kbd{C-x * g}}. |
d7b8e6c6 | 7522 | |
d7b8e6c6 | 7523 | @smallexample |
5d67986c | 7524 | @group |
d7b8e6c6 EZ |
7525 | 1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5] |
7526 | . | |
d7b8e6c6 | 7527 | @end group |
5d67986c | 7528 | @end smallexample |
d7b8e6c6 EZ |
7529 | |
7530 | To make things interesting, let's assume we don't know at a glance | |
7531 | how many numbers are in this list. Then we could type: | |
7532 | ||
d7b8e6c6 | 7533 | @smallexample |
5d67986c | 7534 | @group |
d7b8e6c6 EZ |
7535 | 2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ] |
7536 | 1: [2.3, 6, 22, ... ] 1: 126356422.5 | |
7537 | . . | |
7538 | ||
5d67986c | 7539 | @key{RET} V R * |
d7b8e6c6 | 7540 | |
d7b8e6c6 | 7541 | @end group |
5d67986c | 7542 | @end smallexample |
d7b8e6c6 | 7543 | @noindent |
d7b8e6c6 | 7544 | @smallexample |
5d67986c | 7545 | @group |
d7b8e6c6 EZ |
7546 | 2: 126356422.5 2: 126356422.5 1: 7.94652913734 |
7547 | 1: [2.3, 6, 22, ... ] 1: 9 . | |
7548 | . . | |
7549 | ||
5d67986c | 7550 | @key{TAB} v l I ^ |
d7b8e6c6 | 7551 | @end group |
5d67986c | 7552 | @end smallexample |
d7b8e6c6 EZ |
7553 | |
7554 | @noindent | |
7555 | (The @kbd{I ^} command computes the @var{n}th root of a number. | |
7556 | You could also type @kbd{& ^} to take the reciprocal of 9 and | |
7557 | then raise the number to that power.) | |
7558 | ||
7559 | @node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises | |
7560 | @subsection List Tutorial Exercise 4 | |
7561 | ||
7562 | @noindent | |
a4231b04 | 7563 | A number @expr{j} is a divisor of @expr{n} if |
8e04863e | 7564 | @texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}. |
a4231b04 JB |
7565 | @infoline @samp{n % j = 0}. |
7566 | The first step is to get a vector that identifies the divisors. | |
d7b8e6c6 | 7567 | |
d7b8e6c6 | 7568 | @smallexample |
5d67986c | 7569 | @group |
d7b8e6c6 EZ |
7570 | 2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...] |
7571 | 1: [1, 2, 3, 4, ...] 1: 0 . | |
7572 | . . | |
7573 | ||
5d67986c | 7574 | 30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2 |
d7b8e6c6 | 7575 | @end group |
5d67986c | 7576 | @end smallexample |
d7b8e6c6 EZ |
7577 | |
7578 | @noindent | |
7579 | This vector has 1's marking divisors of 30 and 0's marking non-divisors. | |
7580 | ||
7581 | The zeroth divisor function is just the total number of divisors. | |
7582 | The first divisor function is the sum of the divisors. | |
7583 | ||
d7b8e6c6 | 7584 | @smallexample |
5d67986c | 7585 | @group |
d7b8e6c6 EZ |
7586 | 1: 8 3: 8 2: 8 2: 8 |
7587 | 2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72 | |
7588 | 1: [1, 1, 1, 0, ...] . . | |
7589 | . | |
7590 | ||
7591 | V R + r 1 r 2 V M * V R + | |
d7b8e6c6 | 7592 | @end group |
5d67986c | 7593 | @end smallexample |
d7b8e6c6 EZ |
7594 | |
7595 | @noindent | |
7596 | Once again, the last two steps just compute a dot product for which | |
7597 | a simple @kbd{*} would have worked equally well. | |
7598 | ||
7599 | @node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises | |
7600 | @subsection List Tutorial Exercise 5 | |
7601 | ||
7602 | @noindent | |
7603 | The obvious first step is to obtain the list of factors with @kbd{k f}. | |
7604 | This list will always be in sorted order, so if there are duplicates | |
7605 | they will be right next to each other. A suitable method is to compare | |
7606 | the list with a copy of itself shifted over by one. | |
7607 | ||
d7b8e6c6 | 7608 | @smallexample |
5d67986c | 7609 | @group |
d7b8e6c6 EZ |
7610 | 1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0] |
7611 | . 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19] | |
7612 | . . | |
7613 | ||
5d67986c | 7614 | 19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} | |
d7b8e6c6 | 7615 | |
d7b8e6c6 | 7616 | @end group |
5d67986c | 7617 | @end smallexample |
d7b8e6c6 | 7618 | @noindent |
d7b8e6c6 | 7619 | @smallexample |
5d67986c | 7620 | @group |
d7b8e6c6 EZ |
7621 | 1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0 |
7622 | . . . | |
7623 | ||
7624 | V M a = V R + 0 a = | |
d7b8e6c6 | 7625 | @end group |
5d67986c | 7626 | @end smallexample |
d7b8e6c6 EZ |
7627 | |
7628 | @noindent | |
7629 | Note that we have to arrange for both vectors to have the same length | |
7630 | so that the mapping operation works; no prime factor will ever be | |
7631 | zero, so adding zeros on the left and right is safe. From then on | |
7632 | the job is pretty straightforward. | |
7633 | ||
a4231b04 | 7634 | Incidentally, Calc provides the |
8e04863e | 7635 | @texline @dfn{M@"obius} @math{\mu} |
a4231b04 JB |
7636 | @infoline @dfn{Moebius mu} |
7637 | function which is zero if and only if its argument is square-free. It | |
7638 | would be a much more convenient way to do the above test in practice. | |
d7b8e6c6 EZ |
7639 | |
7640 | @node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises | |
7641 | @subsection List Tutorial Exercise 6 | |
7642 | ||
7643 | @noindent | |
5d67986c | 7644 | First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x} |
d7b8e6c6 EZ |
7645 | to get a list of lists of integers! |
7646 | ||
7647 | @node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises | |
7648 | @subsection List Tutorial Exercise 7 | |
7649 | ||
7650 | @noindent | |
7651 | Here's one solution. First, compute the triangular list from the previous | |
7652 | exercise and type @kbd{1 -} to subtract one from all the elements. | |
7653 | ||
d7b8e6c6 | 7654 | @smallexample |
5d67986c | 7655 | @group |
d7b8e6c6 EZ |
7656 | 1: [ [0], |
7657 | [0, 1], | |
7658 | [0, 1, 2], | |
7659 | @dots{} | |
7660 | ||
7661 | 1 - | |
d7b8e6c6 | 7662 | @end group |
5d67986c | 7663 | @end smallexample |
d7b8e6c6 EZ |
7664 | |
7665 | The numbers down the lefthand edge of the list we desire are called | |
a4231b04 JB |
7666 | the ``triangular numbers'' (now you know why!). The @expr{n}th |
7667 | triangular number is the sum of the integers from 1 to @expr{n}, and | |
7668 | can be computed directly by the formula | |
8e04863e | 7669 | @texline @math{n (n+1) \over 2}. |
a4231b04 | 7670 | @infoline @expr{n * (n+1) / 2}. |
d7b8e6c6 | 7671 | |
d7b8e6c6 | 7672 | @smallexample |
5d67986c | 7673 | @group |
d7b8e6c6 EZ |
7674 | 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] |
7675 | 1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15] | |
7676 | . . | |
7677 | ||
5d67986c | 7678 | v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET} |
d7b8e6c6 | 7679 | @end group |
5d67986c | 7680 | @end smallexample |
d7b8e6c6 EZ |
7681 | |
7682 | @noindent | |
7683 | Adding this list to the above list of lists produces the desired | |
7684 | result: | |
7685 | ||
d7b8e6c6 | 7686 | @smallexample |
5d67986c | 7687 | @group |
d7b8e6c6 EZ |
7688 | 1: [ [0], |
7689 | [1, 2], | |
7690 | [3, 4, 5], | |
7691 | [6, 7, 8, 9], | |
7692 | [10, 11, 12, 13, 14], | |
7693 | [15, 16, 17, 18, 19, 20] ] | |
7694 | . | |
7695 | ||
7696 | V M + | |
d7b8e6c6 | 7697 | @end group |
5d67986c | 7698 | @end smallexample |
d7b8e6c6 EZ |
7699 | |
7700 | If we did not know the formula for triangular numbers, we could have | |
7701 | computed them using a @kbd{V U +} command. We could also have | |
7702 | gotten them the hard way by mapping a reduction across the original | |
7703 | triangular list. | |
7704 | ||
d7b8e6c6 | 7705 | @smallexample |
5d67986c | 7706 | @group |
d7b8e6c6 EZ |
7707 | 2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ] |
7708 | 1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15] | |
7709 | . . | |
7710 | ||
5d67986c | 7711 | @key{RET} V M V R + |
d7b8e6c6 | 7712 | @end group |
5d67986c | 7713 | @end smallexample |
d7b8e6c6 EZ |
7714 | |
7715 | @noindent | |
7716 | (This means ``map a @kbd{V R +} command across the vector,'' and | |
7717 | since each element of the main vector is itself a small vector, | |
7718 | @kbd{V R +} computes the sum of its elements.) | |
7719 | ||
7720 | @node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises | |
7721 | @subsection List Tutorial Exercise 8 | |
7722 | ||
7723 | @noindent | |
a4231b04 | 7724 | The first step is to build a list of values of @expr{x}. |
d7b8e6c6 | 7725 | |
d7b8e6c6 | 7726 | @smallexample |
5d67986c | 7727 | @group |
d7b8e6c6 EZ |
7728 | 1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5] |
7729 | . . . | |
7730 | ||
5d67986c | 7731 | v x 21 @key{RET} 1 - 4 / s 1 |
d7b8e6c6 | 7732 | @end group |
5d67986c | 7733 | @end smallexample |
d7b8e6c6 EZ |
7734 | |
7735 | Next, we compute the Bessel function values. | |
7736 | ||
d7b8e6c6 | 7737 | @smallexample |
5d67986c | 7738 | @group |
d7b8e6c6 EZ |
7739 | 1: [0., 0.124, 0.242, ..., -0.328] |
7740 | . | |
7741 | ||
5d67986c | 7742 | V M ' besJ(1,$) @key{RET} |
d7b8e6c6 | 7743 | @end group |
5d67986c | 7744 | @end smallexample |
d7b8e6c6 EZ |
7745 | |
7746 | @noindent | |
5d67986c | 7747 | (Another way to do this would be @kbd{1 @key{TAB} V M f j}.) |
d7b8e6c6 EZ |
7748 | |
7749 | A way to isolate the maximum value is to compute the maximum using | |
7750 | @kbd{V R X}, then compare all the Bessel values with that maximum. | |
7751 | ||
d7b8e6c6 | 7752 | @smallexample |
5d67986c | 7753 | @group |
d7b8e6c6 EZ |
7754 | 2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ] |
7755 | 1: 0.5801562 . 1: 1 | |
7756 | . . | |
7757 | ||
5d67986c | 7758 | @key{RET} V R X V M a = @key{RET} V R + @key{DEL} |
d7b8e6c6 | 7759 | @end group |
5d67986c | 7760 | @end smallexample |
d7b8e6c6 EZ |
7761 | |
7762 | @noindent | |
7763 | It's a good idea to verify, as in the last step above, that only | |
a4231b04 | 7764 | one value is equal to the maximum. (After all, a plot of |
8e04863e | 7765 | @texline @math{\sin x} |
a4231b04 | 7766 | @infoline @expr{sin(x)} |
d7b8e6c6 EZ |
7767 | might have many points all equal to the maximum value, 1.) |
7768 | ||
7769 | The vector we have now has a single 1 in the position that indicates | |
a4231b04 | 7770 | the maximum value of @expr{x}. Now it is a simple matter to convert |
d7b8e6c6 EZ |
7771 | this back into the corresponding value itself. |
7772 | ||
d7b8e6c6 | 7773 | @smallexample |
5d67986c | 7774 | @group |
d7b8e6c6 EZ |
7775 | 2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75 |
7776 | 1: [0, 0.25, 0.5, ... ] . . | |
7777 | . | |
7778 | ||
7779 | r 1 V M * V R + | |
d7b8e6c6 | 7780 | @end group |
5d67986c | 7781 | @end smallexample |
d7b8e6c6 | 7782 | |
a4231b04 JB |
7783 | If @kbd{a =} had produced more than one @expr{1} value, this method |
7784 | would have given the sum of all maximum @expr{x} values; not very | |
d7b8e6c6 EZ |
7785 | useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector}) |
7786 | instead. This command deletes all elements of a ``data'' vector that | |
7787 | correspond to zeros in a ``mask'' vector, leaving us with, in this | |
a4231b04 | 7788 | example, a vector of maximum @expr{x} values. |
d7b8e6c6 EZ |
7789 | |
7790 | The built-in @kbd{a X} command maximizes a function using more | |
7791 | efficient methods. Just for illustration, let's use @kbd{a X} | |
7792 | to maximize @samp{besJ(1,x)} over this same interval. | |
7793 | ||
d7b8e6c6 | 7794 | @smallexample |
5d67986c | 7795 | @group |
d7b8e6c6 EZ |
7796 | 2: besJ(1, x) 1: [1.84115, 0.581865] |
7797 | 1: [0 .. 5] . | |
7798 | . | |
7799 | ||
5d67986c | 7800 | ' besJ(1,x), [0..5] @key{RET} a X x @key{RET} |
d7b8e6c6 | 7801 | @end group |
5d67986c | 7802 | @end smallexample |
d7b8e6c6 EZ |
7803 | |
7804 | @noindent | |
a4231b04 | 7805 | The output from @kbd{a X} is a vector containing the value of @expr{x} |
d7b8e6c6 EZ |
7806 | that maximizes the function, and the function's value at that maximum. |
7807 | As you can see, our simple search got quite close to the right answer. | |
7808 | ||
7809 | @node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises | |
7810 | @subsection List Tutorial Exercise 9 | |
7811 | ||
7812 | @noindent | |
7813 | Step one is to convert our integer into vector notation. | |
7814 | ||
d7b8e6c6 | 7815 | @smallexample |
5d67986c | 7816 | @group |
d7b8e6c6 EZ |
7817 | 1: 25129925999 3: 25129925999 |
7818 | . 2: 10 | |
7819 | 1: [11, 10, 9, ..., 1, 0] | |
7820 | . | |
7821 | ||
5d67986c | 7822 | 25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} - |
d7b8e6c6 | 7823 | |
d7b8e6c6 | 7824 | @end group |
5d67986c | 7825 | @end smallexample |
d7b8e6c6 | 7826 | @noindent |
d7b8e6c6 | 7827 | @smallexample |
5d67986c | 7828 | @group |
d7b8e6c6 EZ |
7829 | 1: 25129925999 1: [0, 2, 25, 251, 2512, ... ] |
7830 | 2: [100000000000, ... ] . | |
7831 | . | |
7832 | ||
7833 | V M ^ s 1 V M \ | |
d7b8e6c6 | 7834 | @end group |
5d67986c | 7835 | @end smallexample |
d7b8e6c6 EZ |
7836 | |
7837 | @noindent | |
7838 | (Recall, the @kbd{\} command computes an integer quotient.) | |
7839 | ||
d7b8e6c6 | 7840 | @smallexample |
5d67986c | 7841 | @group |
d7b8e6c6 EZ |
7842 | 1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9] |
7843 | . | |
7844 | ||
7845 | 10 V M % s 2 | |
d7b8e6c6 | 7846 | @end group |
5d67986c | 7847 | @end smallexample |
d7b8e6c6 EZ |
7848 | |
7849 | Next we must increment this number. This involves adding one to | |
7850 | the last digit, plus handling carries. There is a carry to the | |
7851 | left out of a digit if that digit is a nine and all the digits to | |
7852 | the right of it are nines. | |
7853 | ||
d7b8e6c6 | 7854 | @smallexample |
5d67986c | 7855 | @group |
d7b8e6c6 EZ |
7856 | 1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ] |
7857 | . . | |
7858 | ||
7859 | 9 V M a = v v | |
7860 | ||
d7b8e6c6 | 7861 | @end group |
5d67986c | 7862 | @end smallexample |
d7b8e6c6 | 7863 | @noindent |
d7b8e6c6 | 7864 | @smallexample |
5d67986c | 7865 | @group |
d7b8e6c6 EZ |
7866 | 1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1] |
7867 | . . | |
7868 | ||
7869 | V U * v v 1 | | |
d7b8e6c6 | 7870 | @end group |
5d67986c | 7871 | @end smallexample |
d7b8e6c6 EZ |
7872 | |
7873 | @noindent | |
7874 | Accumulating @kbd{*} across a vector of ones and zeros will preserve | |
7875 | only the initial run of ones. These are the carries into all digits | |
7876 | except the rightmost digit. Concatenating a one on the right takes | |
7877 | care of aligning the carries properly, and also adding one to the | |
7878 | rightmost digit. | |
7879 | ||
d7b8e6c6 | 7880 | @smallexample |
5d67986c | 7881 | @group |
d7b8e6c6 EZ |
7882 | 2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0] |
7883 | 1: [0, 0, 2, 5, ... ] . | |
7884 | . | |
7885 | ||
7886 | 0 r 2 | V M + 10 V M % | |
d7b8e6c6 | 7887 | @end group |
5d67986c | 7888 | @end smallexample |
d7b8e6c6 EZ |
7889 | |
7890 | @noindent | |
7891 | Here we have concatenated 0 to the @emph{left} of the original number; | |
7892 | this takes care of shifting the carries by one with respect to the | |
7893 | digits that generated them. | |
7894 | ||
7895 | Finally, we must convert this list back into an integer. | |
7896 | ||
d7b8e6c6 | 7897 | @smallexample |
5d67986c | 7898 | @group |
d7b8e6c6 EZ |
7899 | 3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ] |
7900 | 2: 1000000000000 1: [1000000000000, 100000000000, ... ] | |
7901 | 1: [100000000000, ... ] . | |
7902 | . | |
7903 | ||
5d67986c | 7904 | 10 @key{RET} 12 ^ r 1 | |
d7b8e6c6 | 7905 | |
d7b8e6c6 | 7906 | @end group |
5d67986c | 7907 | @end smallexample |
d7b8e6c6 | 7908 | @noindent |
d7b8e6c6 | 7909 | @smallexample |
5d67986c | 7910 | @group |
d7b8e6c6 EZ |
7911 | 1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000 |
7912 | . . | |
7913 | ||
7914 | V M * V R + | |
d7b8e6c6 | 7915 | @end group |
5d67986c | 7916 | @end smallexample |
d7b8e6c6 EZ |
7917 | |
7918 | @noindent | |
7919 | Another way to do this final step would be to reduce the formula | |
7920 | @w{@samp{10 $$ + $}} across the vector of digits. | |
7921 | ||
d7b8e6c6 | 7922 | @smallexample |
5d67986c | 7923 | @group |
d7b8e6c6 EZ |
7924 | 1: [0, 0, 2, 5, ... ] 1: 25129926000 |
7925 | . . | |
7926 | ||
5d67986c | 7927 | V R ' 10 $$ + $ @key{RET} |
d7b8e6c6 | 7928 | @end group |
5d67986c | 7929 | @end smallexample |
d7b8e6c6 EZ |
7930 | |
7931 | @node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises | |
7932 | @subsection List Tutorial Exercise 10 | |
7933 | ||
7934 | @noindent | |
a4231b04 JB |
7935 | For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d}, |
7936 | which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is | |
7937 | then compared with @expr{c} to produce another 1 or 0, which is then | |
7938 | compared with @expr{d}. This is not at all what Joe wanted. | |
d7b8e6c6 EZ |
7939 | |
7940 | Here's a more correct method: | |
7941 | ||
d7b8e6c6 | 7942 | @smallexample |
5d67986c | 7943 | @group |
d7b8e6c6 EZ |
7944 | 1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7] |
7945 | . 1: 7 | |
7946 | . | |
7947 | ||
5d67986c | 7948 | ' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET} |
d7b8e6c6 | 7949 | |
d7b8e6c6 | 7950 | @end group |
5d67986c | 7951 | @end smallexample |
d7b8e6c6 | 7952 | @noindent |
d7b8e6c6 | 7953 | @smallexample |
5d67986c | 7954 | @group |
d7b8e6c6 EZ |
7955 | 1: [1, 1, 1, 0, 1] 1: 0 |
7956 | . . | |
7957 | ||
7958 | V M a = V R * | |
d7b8e6c6 | 7959 | @end group |
5d67986c | 7960 | @end smallexample |
d7b8e6c6 EZ |
7961 | |
7962 | @node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises | |
7963 | @subsection List Tutorial Exercise 11 | |
7964 | ||
7965 | @noindent | |
a4231b04 JB |
7966 | The circle of unit radius consists of those points @expr{(x,y)} for which |
7967 | @expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2} | |
7968 | and a vector of @expr{y^2}. | |
d7b8e6c6 EZ |
7969 | |
7970 | We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} | |
7971 | commands. | |
7972 | ||
d7b8e6c6 | 7973 | @smallexample |
5d67986c | 7974 | @group |
d7b8e6c6 EZ |
7975 | 2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.] |
7976 | 1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81] | |
7977 | . . | |
7978 | ||
5d67986c | 7979 | v . t . 2. v b 100 @key{RET} @key{RET} V M k r |
d7b8e6c6 | 7980 | |
d7b8e6c6 | 7981 | @end group |
5d67986c | 7982 | @end smallexample |
d7b8e6c6 | 7983 | @noindent |
d7b8e6c6 | 7984 | @smallexample |
5d67986c | 7985 | @group |
d7b8e6c6 EZ |
7986 | 2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036] |
7987 | 1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094] | |
7988 | . . | |
7989 | ||
5d67986c | 7990 | 1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^ |
d7b8e6c6 | 7991 | @end group |
5d67986c | 7992 | @end smallexample |
d7b8e6c6 | 7993 | |
a4231b04 | 7994 | Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to |
d7b8e6c6 EZ |
7995 | get a vector of 1/0 truth values, then sum the truth values. |
7996 | ||
d7b8e6c6 | 7997 | @smallexample |
5d67986c | 7998 | @group |
d7b8e6c6 EZ |
7999 | 1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84 |
8000 | . . . | |
8001 | ||
8002 | + 1 V M a < V R + | |
d7b8e6c6 | 8003 | @end group |
5d67986c | 8004 | @end smallexample |
d7b8e6c6 EZ |
8005 | |
8006 | @noindent | |
a4231b04 | 8007 | The ratio @expr{84/100} should approximate the ratio @cpiover{4}. |
d7b8e6c6 | 8008 | |
d7b8e6c6 | 8009 | @smallexample |
5d67986c | 8010 | @group |
d7b8e6c6 EZ |
8011 | 1: 0.84 1: 3.36 2: 3.36 1: 1.0695 |
8012 | . . 1: 3.14159 . | |
8013 | ||
8014 | 100 / 4 * P / | |
d7b8e6c6 | 8015 | @end group |
5d67986c | 8016 | @end smallexample |
d7b8e6c6 EZ |
8017 | |
8018 | @noindent | |
8019 | Our estimate, 3.36, is off by about 7%. We could get a better estimate | |
8020 | by taking more points (say, 1000), but it's clear that this method is | |
8021 | not very efficient! | |
8022 | ||
8023 | (Naturally, since this example uses random numbers your own answer | |
8024 | will be slightly different from the one shown here!) | |
8025 | ||
8026 | If you typed @kbd{v .} and @kbd{t .} before, type them again to | |
8027 | return to full-sized display of vectors. | |
8028 | ||
8029 | @node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises | |
8030 | @subsection List Tutorial Exercise 12 | |
8031 | ||
8032 | @noindent | |
8033 | This problem can be made a lot easier by taking advantage of some | |
8034 | symmetries. First of all, after some thought it's clear that the | |
a4231b04 JB |
8035 | @expr{y} axis can be ignored altogether. Just pick a random @expr{x} |
8036 | component for one end of the match, pick a random direction | |
8e04863e | 8037 | @texline @math{\theta}, |
a4231b04 JB |
8038 | @infoline @expr{theta}, |
8039 | and see if @expr{x} and | |
8e04863e | 8040 | @texline @math{x + \cos \theta} |
a4231b04 JB |
8041 | @infoline @expr{x + cos(theta)} |
8042 | (which is the @expr{x} coordinate of the other endpoint) cross a line. | |
8043 | The lines are at integer coordinates, so this happens when the two | |
8044 | numbers surround an integer. | |
d7b8e6c6 EZ |
8045 | |
8046 | Since the two endpoints are equivalent, we may as well choose the leftmost | |
a4231b04 | 8047 | of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing |
d7b8e6c6 | 8048 | to the right, in the range -90 to 90 degrees. (We could use radians, but |
a4231b04 JB |
8049 | it would feel like cheating to refer to @cpiover{2} radians while trying |
8050 | to estimate @cpi{}!) | |
d7b8e6c6 EZ |
8051 | |
8052 | In fact, since the field of lines is infinite we can choose the | |
8053 | coordinates 0 and 1 for the lines on either side of the leftmost | |
8054 | endpoint. The rightmost endpoint will be between 0 and 1 if the | |
8055 | match does not cross a line, or between 1 and 2 if it does. So: | |
a4231b04 | 8056 | Pick random @expr{x} and |
8e04863e | 8057 | @texline @math{\theta}, |
a4231b04 JB |
8058 | @infoline @expr{theta}, |
8059 | compute | |
8e04863e | 8060 | @texline @math{x + \cos \theta}, |
a4231b04 | 8061 | @infoline @expr{x + cos(theta)}, |
d7b8e6c6 EZ |
8062 | and count how many of the results are greater than one. Simple! |
8063 | ||
8064 | We can make this go a bit faster by using the @kbd{v .} and @kbd{t .} | |
8065 | commands. | |
8066 | ||
d7b8e6c6 | 8067 | @smallexample |
5d67986c | 8068 | @group |
d7b8e6c6 EZ |
8069 | 1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72] |
8070 | . 1: [78.4, 64.5, ..., -42.9] | |
8071 | . | |
8072 | ||
5d67986c | 8073 | v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 - |
d7b8e6c6 | 8074 | @end group |
5d67986c | 8075 | @end smallexample |
d7b8e6c6 EZ |
8076 | |
8077 | @noindent | |
8078 | (The next step may be slow, depending on the speed of your computer.) | |
8079 | ||
d7b8e6c6 | 8080 | @smallexample |
5d67986c | 8081 | @group |
d7b8e6c6 EZ |
8082 | 2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45] |
8083 | 1: [0.20, 0.43, ..., 0.73] . | |
8084 | . | |
8085 | ||
8086 | m d V M C + | |
8087 | ||
d7b8e6c6 | 8088 | @end group |
5d67986c | 8089 | @end smallexample |
d7b8e6c6 | 8090 | @noindent |
d7b8e6c6 | 8091 | @smallexample |
5d67986c | 8092 | @group |
d7b8e6c6 EZ |
8093 | 1: [0, 1, ..., 1] 1: 0.64 1: 3.125 |
8094 | . . . | |
8095 | ||
5d67986c | 8096 | 1 V M a > V R + 100 / 2 @key{TAB} / |
d7b8e6c6 | 8097 | @end group |
5d67986c | 8098 | @end smallexample |
d7b8e6c6 EZ |
8099 | |
8100 | Let's try the third method, too. We'll use random integers up to | |
8101 | one million. The @kbd{k r} command with an integer argument picks | |
8102 | a random integer. | |
8103 | ||
d7b8e6c6 | 8104 | @smallexample |
5d67986c | 8105 | @group |
d7b8e6c6 EZ |
8106 | 2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975] |
8107 | 1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450] | |
8108 | . . | |
8109 | ||
5d67986c | 8110 | 1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r |
d7b8e6c6 | 8111 | |
d7b8e6c6 | 8112 | @end group |
5d67986c | 8113 | @end smallexample |
d7b8e6c6 | 8114 | @noindent |
d7b8e6c6 | 8115 | @smallexample |
5d67986c | 8116 | @group |
d7b8e6c6 EZ |
8117 | 1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56 |
8118 | . . . | |
8119 | ||
8120 | V M k g 1 V M a = V R + 100 / | |
8121 | ||
d7b8e6c6 | 8122 | @end group |
5d67986c | 8123 | @end smallexample |
d7b8e6c6 | 8124 | @noindent |
d7b8e6c6 | 8125 | @smallexample |
5d67986c | 8126 | @group |
d7b8e6c6 EZ |
8127 | 1: 10.714 1: 3.273 |
8128 | . . | |
8129 | ||
5d67986c | 8130 | 6 @key{TAB} / Q |
d7b8e6c6 | 8131 | @end group |
5d67986c | 8132 | @end smallexample |
d7b8e6c6 EZ |
8133 | |
8134 | For a proof of this property of the GCD function, see section 4.5.2, | |
8135 | exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II. | |
8136 | ||
8137 | If you typed @kbd{v .} and @kbd{t .} before, type them again to | |
8138 | return to full-sized display of vectors. | |
8139 | ||
8140 | @node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises | |
8141 | @subsection List Tutorial Exercise 13 | |
8142 | ||
8143 | @noindent | |
8144 | First, we put the string on the stack as a vector of ASCII codes. | |
8145 | ||
d7b8e6c6 | 8146 | @smallexample |
5d67986c | 8147 | @group |
d7b8e6c6 EZ |
8148 | 1: [84, 101, 115, ..., 51] |
8149 | . | |
8150 | ||
5d67986c | 8151 | "Testing, 1, 2, 3 @key{RET} |
d7b8e6c6 | 8152 | @end group |
5d67986c | 8153 | @end smallexample |
d7b8e6c6 EZ |
8154 | |
8155 | @noindent | |
8156 | Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so | |
8157 | there was no need to type an apostrophe. Also, Calc didn't mind that | |
8158 | we omitted the closing @kbd{"}. (The same goes for all closing delimiters | |
8159 | like @kbd{)} and @kbd{]} at the end of a formula. | |
8160 | ||
8161 | We'll show two different approaches here. In the first, we note that | |
a4231b04 JB |
8162 | if the input vector is @expr{[a, b, c, d]}, then the hash code is |
8163 | @expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words, | |
d7b8e6c6 EZ |
8164 | it's a sum of descending powers of three times the ASCII codes. |
8165 | ||
d7b8e6c6 | 8166 | @smallexample |
5d67986c | 8167 | @group |
d7b8e6c6 EZ |
8168 | 2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51] |
8169 | 1: 16 1: [15, 14, 13, ..., 0] | |
8170 | . . | |
8171 | ||
5d67986c | 8172 | @key{RET} v l v x 16 @key{RET} - |
d7b8e6c6 | 8173 | |
d7b8e6c6 | 8174 | @end group |
5d67986c | 8175 | @end smallexample |
d7b8e6c6 | 8176 | @noindent |
d7b8e6c6 | 8177 | @smallexample |
5d67986c | 8178 | @group |
d7b8e6c6 EZ |
8179 | 2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121 |
8180 | 1: [14348907, ..., 1] . . | |
8181 | . | |
8182 | ||
5d67986c | 8183 | 3 @key{TAB} V M ^ * 511 % |
d7b8e6c6 | 8184 | @end group |
5d67986c | 8185 | @end smallexample |
d7b8e6c6 EZ |
8186 | |
8187 | @noindent | |
8188 | Once again, @kbd{*} elegantly summarizes most of the computation. | |
8189 | But there's an even more elegant approach: Reduce the formula | |
8190 | @kbd{3 $$ + $} across the vector. Recall that this represents a | |
8191 | function of two arguments that computes its first argument times three | |
8192 | plus its second argument. | |
8193 | ||
d7b8e6c6 | 8194 | @smallexample |
5d67986c | 8195 | @group |
d7b8e6c6 EZ |
8196 | 1: [84, 101, 115, ..., 51] 1: 1960915098 |
8197 | . . | |
8198 | ||
5d67986c | 8199 | "Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET} |
d7b8e6c6 | 8200 | @end group |
5d67986c | 8201 | @end smallexample |
d7b8e6c6 EZ |
8202 | |
8203 | @noindent | |
8204 | If you did the decimal arithmetic exercise, this will be familiar. | |
8205 | Basically, we're turning a base-3 vector of digits into an integer, | |
8206 | except that our ``digits'' are much larger than real digits. | |
8207 | ||
8208 | Instead of typing @kbd{511 %} again to reduce the result, we can be | |
8209 | cleverer still and notice that rather than computing a huge integer | |
8210 | and taking the modulo at the end, we can take the modulo at each step | |
8211 | without affecting the result. While this means there are more | |
8212 | arithmetic operations, the numbers we operate on remain small so | |
8213 | the operations are faster. | |
8214 | ||
d7b8e6c6 | 8215 | @smallexample |
5d67986c | 8216 | @group |
d7b8e6c6 EZ |
8217 | 1: [84, 101, 115, ..., 51] 1: 121 |
8218 | . . | |
8219 | ||
5d67986c | 8220 | "Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET} |
d7b8e6c6 | 8221 | @end group |
5d67986c | 8222 | @end smallexample |
d7b8e6c6 EZ |
8223 | |
8224 | Why does this work? Think about a two-step computation: | |
a4231b04 | 8225 | @w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means |
d7b8e6c6 EZ |
8226 | subtracting off enough 511's to put the result in the desired range. |
8227 | So the result when we take the modulo after every step is, | |
8228 | ||
8229 | @ifinfo | |
8230 | @example | |
8231 | 3 (3 a + b - 511 m) + c - 511 n | |
8232 | @end example | |
8233 | @end ifinfo | |
8234 | @tex | |
8235 | \turnoffactive | |
8236 | \beforedisplay | |
8237 | $$ 3 (3 a + b - 511 m) + c - 511 n $$ | |
8238 | \afterdisplay | |
8239 | @end tex | |
8240 | ||
8241 | @noindent | |
a4231b04 | 8242 | for some suitable integers @expr{m} and @expr{n}. Expanding out by |
d7b8e6c6 EZ |
8243 | the distributive law yields |
8244 | ||
8245 | @ifinfo | |
8246 | @example | |
8247 | 9 a + 3 b + c - 511*3 m - 511 n | |
8248 | @end example | |
8249 | @end ifinfo | |
8250 | @tex | |
8251 | \turnoffactive | |
8252 | \beforedisplay | |
8253 | $$ 9 a + 3 b + c - 511\times3 m - 511 n $$ | |
8254 | \afterdisplay | |
8255 | @end tex | |
8256 | ||
8257 | @noindent | |
a4231b04 JB |
8258 | The @expr{m} term in the latter formula is redundant because any |
8259 | contribution it makes could just as easily be made by the @expr{n} | |
d7b8e6c6 | 8260 | term. So we can take it out to get an equivalent formula with |
a4231b04 | 8261 | @expr{n' = 3m + n}, |
d7b8e6c6 EZ |
8262 | |
8263 | @ifinfo | |
8264 | @example | |
8265 | 9 a + 3 b + c - 511 n' | |
8266 | @end example | |
8267 | @end ifinfo | |
8268 | @tex | |
8269 | \turnoffactive | |
8270 | \beforedisplay | |
8271 | $$ 9 a + 3 b + c - 511 n' $$ | |
8272 | \afterdisplay | |
8273 | @end tex | |
8274 | ||
8275 | @noindent | |
8276 | which is just the formula for taking the modulo only at the end of | |
8277 | the calculation. Therefore the two methods are essentially the same. | |
8278 | ||
8279 | Later in the tutorial we will encounter @dfn{modulo forms}, which | |
8280 | basically automate the idea of reducing every intermediate result | |
5d67986c | 8281 | modulo some value @var{m}. |
d7b8e6c6 EZ |
8282 | |
8283 | @node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises | |
8284 | @subsection List Tutorial Exercise 14 | |
8285 | ||
8286 | We want to use @kbd{H V U} to nest a function which adds a random | |
a4231b04 | 8287 | step to an @expr{(x,y)} coordinate. The function is a bit long, but |
d7b8e6c6 EZ |
8288 | otherwise the problem is quite straightforward. |
8289 | ||
d7b8e6c6 | 8290 | @smallexample |
5d67986c | 8291 | @group |
d7b8e6c6 EZ |
8292 | 2: [0, 0] 1: [ [ 0, 0 ] |
8293 | 1: 50 [ 0.4288, -0.1695 ] | |
8294 | . [ -0.4787, -0.9027 ] | |
8295 | ... | |
8296 | ||
5d67986c | 8297 | [0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET} |
d7b8e6c6 | 8298 | @end group |
5d67986c | 8299 | @end smallexample |
d7b8e6c6 EZ |
8300 | |
8301 | Just as the text recommended, we used @samp{< >} nameless function | |
8302 | notation to keep the two @code{random} calls from being evaluated | |
8303 | before nesting even begins. | |
8304 | ||
a4231b04 | 8305 | We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's |
d7b8e6c6 | 8306 | rules acts like a matrix. We can transpose this matrix and unpack |
a4231b04 | 8307 | to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing. |
d7b8e6c6 | 8308 | |
d7b8e6c6 | 8309 | @smallexample |
5d67986c | 8310 | @group |
d7b8e6c6 EZ |
8311 | 2: [ 0, 0.4288, -0.4787, ... ] |
8312 | 1: [ 0, -0.1696, -0.9027, ... ] | |
8313 | . | |
8314 | ||
8315 | v t v u g f | |
d7b8e6c6 | 8316 | @end group |
5d67986c | 8317 | @end smallexample |
d7b8e6c6 | 8318 | |
a4231b04 | 8319 | Incidentally, because the @expr{x} and @expr{y} are completely |
d7b8e6c6 | 8320 | independent in this case, we could have done two separate commands |
a4231b04 | 8321 | to create our @expr{x} and @expr{y} vectors of numbers directly. |
d7b8e6c6 EZ |
8322 | |
8323 | To make a random walk of unit steps, we note that @code{sincos} of | |
a4231b04 | 8324 | a random direction exactly gives us an @expr{[x, y]} step of unit |
d7b8e6c6 EZ |
8325 | length; in fact, the new nesting function is even briefer, though |
8326 | we might want to lower the precision a bit for it. | |
8327 | ||
d7b8e6c6 | 8328 | @smallexample |
5d67986c | 8329 | @group |
d7b8e6c6 EZ |
8330 | 2: [0, 0] 1: [ [ 0, 0 ] |
8331 | 1: 50 [ 0.1318, 0.9912 ] | |
8332 | . [ -0.5965, 0.3061 ] | |
8333 | ... | |
8334 | ||
5d67986c | 8335 | [0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET} |
d7b8e6c6 | 8336 | @end group |
5d67986c | 8337 | @end smallexample |
d7b8e6c6 EZ |
8338 | |
8339 | Another @kbd{v t v u g f} sequence will graph this new random walk. | |
8340 | ||
8341 | An interesting twist on these random walk functions would be to use | |
8342 | complex numbers instead of 2-vectors to represent points on the plane. | |
8343 | In the first example, we'd use something like @samp{random + random*(0,1)}, | |
8344 | and in the second we could use polar complex numbers with random phase | |
8345 | angles. (This exercise was first suggested in this form by Randal | |
8346 | Schwartz.) | |
8347 | ||
8348 | @node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises | |
8349 | @subsection Types Tutorial Exercise 1 | |
8350 | ||
8351 | @noindent | |
a4231b04 JB |
8352 | If the number is the square root of @cpi{} times a rational number, |
8353 | then its square, divided by @cpi{}, should be a rational number. | |
d7b8e6c6 | 8354 | |
d7b8e6c6 | 8355 | @smallexample |
5d67986c | 8356 | @group |
d7b8e6c6 EZ |
8357 | 1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627 |
8358 | . . . | |
8359 | ||
8360 | 2 ^ P / c F | |
d7b8e6c6 | 8361 | @end group |
5d67986c | 8362 | @end smallexample |
d7b8e6c6 EZ |
8363 | |
8364 | @noindent | |
8365 | Technically speaking this is a rational number, but not one that is | |
8366 | likely to have arisen in the original problem. More likely, it just | |
8367 | happens to be the fraction which most closely represents some | |
8368 | irrational number to within 12 digits. | |
8369 | ||
8370 | But perhaps our result was not quite exact. Let's reduce the | |
8371 | precision slightly and try again: | |
8372 | ||
d7b8e6c6 | 8373 | @smallexample |
5d67986c | 8374 | @group |
d7b8e6c6 EZ |
8375 | 1: 0.509433962268 1: 27:53 |
8376 | . . | |
8377 | ||
5d67986c | 8378 | U p 10 @key{RET} c F |
d7b8e6c6 | 8379 | @end group |
5d67986c | 8380 | @end smallexample |
d7b8e6c6 EZ |
8381 | |
8382 | @noindent | |
8383 | Aha! It's unlikely that an irrational number would equal a fraction | |
8384 | this simple to within ten digits, so our original number was probably | |
8e04863e | 8385 | @texline @math{\sqrt{27 \pi / 53}}. |
a4231b04 | 8386 | @infoline @expr{sqrt(27 pi / 53)}. |
d7b8e6c6 EZ |
8387 | |
8388 | Notice that we didn't need to re-round the number when we reduced the | |
8389 | precision. Remember, arithmetic operations always round their inputs | |
8390 | to the current precision before they begin. | |
8391 | ||
8392 | @node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises | |
8393 | @subsection Types Tutorial Exercise 2 | |
8394 | ||
8395 | @noindent | |
8396 | @samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer. | |
8397 | But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too. | |
8398 | ||
8399 | @samp{exp(inf) = inf}. It's tempting to say that the exponential | |
8400 | of infinity must be ``bigger'' than ``regular'' infinity, but as | |
8401 | far as Calc is concerned all infinities are as just as big. | |
a4231b04 JB |
8402 | In other words, as @expr{x} goes to infinity, @expr{e^x} also goes |
8403 | to infinity, but the fact the @expr{e^x} grows much faster than | |
8404 | @expr{x} is not relevant here. | |
d7b8e6c6 EZ |
8405 | |
8406 | @samp{exp(-inf) = 0}. Here we have a finite answer even though | |
8407 | the input is infinite. | |
8408 | ||
a4231b04 JB |
8409 | @samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)} |
8410 | represents the imaginary number @expr{i}. Here's a derivation: | |
d7b8e6c6 | 8411 | @samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}. |
a4231b04 | 8412 | The first part is, by definition, @expr{i}; the second is @code{inf} |
d7b8e6c6 EZ |
8413 | because, once again, all infinities are the same size. |
8414 | ||
8415 | @samp{sqrt(uinf) = uinf}. In fact, we do know something about the | |
8416 | direction because @code{sqrt} is defined to return a value in the | |
8417 | right half of the complex plane. But Calc has no notation for this, | |
8418 | so it settles for the conservative answer @code{uinf}. | |
8419 | ||
a4231b04 | 8420 | @samp{abs(uinf) = inf}. No matter which direction @expr{x} points, |
d7b8e6c6 EZ |
8421 | @samp{abs(x)} always points along the positive real axis. |
8422 | ||
8423 | @samp{ln(0) = -inf}. Here we have an infinite answer to a finite | |
a4231b04 | 8424 | input. As in the @expr{1 / 0} case, Calc will only use infinities |
07ce2eb3 | 8425 | here if you have turned on Infinite mode. Otherwise, it will |
d7b8e6c6 EZ |
8426 | treat @samp{ln(0)} as an error. |
8427 | ||
8428 | @node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises | |
8429 | @subsection Types Tutorial Exercise 3 | |
8430 | ||
8431 | @noindent | |
8432 | We can make @samp{inf - inf} be any real number we like, say, | |
a4231b04 | 8433 | @expr{a}, just by claiming that we added @expr{a} to the first |
d7b8e6c6 | 8434 | infinity but not to the second. This is just as true for complex |
a4231b04 | 8435 | values of @expr{a}, so @code{nan} can stand for a complex number. |
d7b8e6c6 EZ |
8436 | (And, similarly, @code{uinf} can stand for an infinity that points |
8437 | in any direction in the complex plane, such as @samp{(0, 1) inf}). | |
8438 | ||
8439 | In fact, we can multiply the first @code{inf} by two. Surely | |
8440 | @w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}. | |
8441 | So @code{nan} can even stand for infinity. Obviously it's just | |
8442 | as easy to make it stand for minus infinity as for plus infinity. | |
8443 | ||
8444 | The moral of this story is that ``infinity'' is a slippery fish | |
8445 | indeed, and Calc tries to handle it by having a very simple model | |
8446 | for infinities (only the direction counts, not the ``size''); but | |
8447 | Calc is careful to write @code{nan} any time this simple model is | |
8448 | unable to tell what the true answer is. | |
8449 | ||
8450 | @node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises | |
8451 | @subsection Types Tutorial Exercise 4 | |
8452 | ||
d7b8e6c6 | 8453 | @smallexample |
5d67986c | 8454 | @group |
d7b8e6c6 EZ |
8455 | 2: 0@@ 47' 26" 1: 0@@ 2' 47.411765" |
8456 | 1: 17 . | |
8457 | . | |
8458 | ||
5d67986c | 8459 | 0@@ 47' 26" @key{RET} 17 / |
d7b8e6c6 | 8460 | @end group |
5d67986c | 8461 | @end smallexample |
d7b8e6c6 EZ |
8462 | |
8463 | @noindent | |
8464 | The average song length is two minutes and 47.4 seconds. | |
8465 | ||
d7b8e6c6 | 8466 | @smallexample |
5d67986c | 8467 | @group |
d7b8e6c6 EZ |
8468 | 2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005" |
8469 | 1: 0@@ 0' 20" . . | |
8470 | . | |
8471 | ||
8472 | 20" + 17 * | |
d7b8e6c6 | 8473 | @end group |
5d67986c | 8474 | @end smallexample |
d7b8e6c6 EZ |
8475 | |
8476 | @noindent | |
8477 | The album would be 53 minutes and 6 seconds long. | |
8478 | ||
8479 | @node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises | |
8480 | @subsection Types Tutorial Exercise 5 | |
8481 | ||
8482 | @noindent | |
8483 | Let's suppose it's January 14, 1991. The easiest thing to do is | |
8484 | to keep trying 13ths of months until Calc reports a Friday. | |
8485 | We can do this by manually entering dates, or by using @kbd{t I}: | |
8486 | ||
d7b8e6c6 | 8487 | @smallexample |
5d67986c | 8488 | @group |
d7b8e6c6 EZ |
8489 | 1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991> |
8490 | . . . | |
8491 | ||
5d67986c | 8492 | ' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I |
d7b8e6c6 | 8493 | @end group |
5d67986c | 8494 | @end smallexample |
d7b8e6c6 EZ |
8495 | |
8496 | @noindent | |
8497 | (Calc assumes the current year if you don't say otherwise.) | |
8498 | ||
8499 | This is getting tedious---we can keep advancing the date by typing | |
8500 | @kbd{t I} over and over again, but let's automate the job by using | |
8501 | vector mapping. The @kbd{t I} command actually takes a second | |
8502 | ``how-many-months'' argument, which defaults to one. This | |
8503 | argument is exactly what we want to map over: | |
8504 | ||
d7b8e6c6 | 8505 | @smallexample |
5d67986c | 8506 | @group |
d7b8e6c6 EZ |
8507 | 2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>, |
8508 | 1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>, | |
8509 | . <Fri Sep 13, 1991>, <Sun Oct 13, 1991>] | |
8510 | . | |
8511 | ||
5d67986c | 8512 | v x 6 @key{RET} V M t I |
d7b8e6c6 | 8513 | @end group |
5d67986c | 8514 | @end smallexample |
d7b8e6c6 | 8515 | |
d7b8e6c6 | 8516 | @noindent |
28665d46 | 8517 | Et voil@`a, September 13, 1991 is a Friday. |
d7b8e6c6 | 8518 | |
d7b8e6c6 | 8519 | @smallexample |
5d67986c | 8520 | @group |
d7b8e6c6 EZ |
8521 | 1: 242 |
8522 | . | |
8523 | ||
5d67986c | 8524 | ' <sep 13> - <jan 14> @key{RET} |
d7b8e6c6 | 8525 | @end group |
5d67986c | 8526 | @end smallexample |
d7b8e6c6 EZ |
8527 | |
8528 | @noindent | |
8529 | And the answer to our original question: 242 days to go. | |
8530 | ||
8531 | @node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises | |
8532 | @subsection Types Tutorial Exercise 6 | |
8533 | ||
8534 | @noindent | |
8535 | The full rule for leap years is that they occur in every year divisible | |
8536 | by four, except that they don't occur in years divisible by 100, except | |
8537 | that they @emph{do} in years divisible by 400. We could work out the | |
8538 | answer by carefully counting the years divisible by four and the | |
8539 | exceptions, but there is a much simpler way that works even if we | |
8540 | don't know the leap year rule. | |
8541 | ||
8542 | Let's assume the present year is 1991. Years have 365 days, except | |
8543 | that leap years (whenever they occur) have 366 days. So let's count | |
8544 | the number of days between now and then, and compare that to the | |
8545 | number of years times 365. The number of extra days we find must be | |
8546 | equal to the number of leap years there were. | |
8547 | ||
d7b8e6c6 | 8548 | @smallexample |
5d67986c | 8549 | @group |
d7b8e6c6 EZ |
8550 | 1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593 |
8551 | . 1: <Tue Jan 1, 1991> . | |
8552 | . | |
8553 | ||
5d67986c | 8554 | ' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} - |
d7b8e6c6 | 8555 | |
d7b8e6c6 | 8556 | @end group |
5d67986c | 8557 | @end smallexample |
d7b8e6c6 | 8558 | @noindent |
d7b8e6c6 | 8559 | @smallexample |
5d67986c | 8560 | @group |
d7b8e6c6 EZ |
8561 | 3: 2925593 2: 2925593 2: 2925593 1: 1943 |
8562 | 2: 10001 1: 8010 1: 2923650 . | |
8563 | 1: 1991 . . | |
8564 | . | |
8565 | ||
5d67986c | 8566 | 10001 @key{RET} 1991 - 365 * - |
d7b8e6c6 | 8567 | @end group |
5d67986c | 8568 | @end smallexample |
d7b8e6c6 EZ |
8569 | |
8570 | @c [fix-ref Date Forms] | |
8571 | @noindent | |
8572 | There will be 1943 leap years before the year 10001. (Assuming, | |
8573 | of course, that the algorithm for computing leap years remains | |
8574 | unchanged for that long. @xref{Date Forms}, for some interesting | |
8575 | background information in that regard.) | |
8576 | ||
8577 | @node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises | |
8578 | @subsection Types Tutorial Exercise 7 | |
8579 | ||
8580 | @noindent | |
8581 | The relative errors must be converted to absolute errors so that | |
8582 | @samp{+/-} notation may be used. | |
8583 | ||
d7b8e6c6 | 8584 | @smallexample |
5d67986c | 8585 | @group |
d7b8e6c6 EZ |
8586 | 1: 1. 2: 1. |
8587 | . 1: 0.2 | |
8588 | . | |
8589 | ||
5d67986c | 8590 | 20 @key{RET} .05 * 4 @key{RET} .05 * |
d7b8e6c6 | 8591 | @end group |
5d67986c | 8592 | @end smallexample |
d7b8e6c6 EZ |
8593 | |
8594 | Now we simply chug through the formula. | |
8595 | ||
d7b8e6c6 | 8596 | @smallexample |
5d67986c | 8597 | @group |
d7b8e6c6 EZ |
8598 | 1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21 |
8599 | . . . | |
8600 | ||
5d67986c | 8601 | 2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ * |
d7b8e6c6 | 8602 | @end group |
5d67986c | 8603 | @end smallexample |
d7b8e6c6 EZ |
8604 | |
8605 | It turns out the @kbd{v u} command will unpack an error form as | |
8606 | well as a vector. This saves us some retyping of numbers. | |
8607 | ||
d7b8e6c6 | 8608 | @smallexample |
5d67986c | 8609 | @group |
d7b8e6c6 EZ |
8610 | 3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21 |
8611 | 2: 6316.5 1: 0.1118 | |
8612 | 1: 706.21 . | |
8613 | . | |
8614 | ||
5d67986c | 8615 | @key{RET} v u @key{TAB} / |
d7b8e6c6 | 8616 | @end group |
5d67986c | 8617 | @end smallexample |
d7b8e6c6 EZ |
8618 | |
8619 | @noindent | |
8620 | Thus the volume is 6316 cubic centimeters, within about 11 percent. | |
8621 | ||
8622 | @node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises | |
8623 | @subsection Types Tutorial Exercise 8 | |
8624 | ||
8625 | @noindent | |
8626 | The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}. | |
8627 | Since a number in the interval @samp{(0 .. 10)} can get arbitrarily | |
8628 | close to zero, its reciprocal can get arbitrarily large, so the answer | |
8629 | is an interval that effectively means, ``any number greater than 0.1'' | |
8630 | but with no upper bound. | |
8631 | ||
8632 | The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}. | |
8633 | ||
8634 | Calc normally treats division by zero as an error, so that the formula | |
8635 | @w{@samp{1 / 0}} is left unsimplified. Our third problem, | |
8636 | @w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero | |
8637 | is now a member of the interval. So Calc leaves this one unevaluated, too. | |
8638 | ||
07ce2eb3 | 8639 | If you turn on Infinite mode by pressing @kbd{m i}, you will |
d7b8e6c6 EZ |
8640 | instead get the answer @samp{[0.1 .. inf]}, which includes infinity |
8641 | as a possible value. | |
8642 | ||
8643 | The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem. | |
8644 | Zero is buried inside the interval, but it's still a possible value. | |
8645 | It's not hard to see that the actual result of @samp{1 / (-10 .. 10)} | |
8e04863e | 8646 | will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus |
d7b8e6c6 | 8647 | the interval goes from minus infinity to plus infinity, with a ``hole'' |
8e04863e | 8648 | in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to |
d7b8e6c6 EZ |
8649 | represent this, so it just reports @samp{[-inf .. inf]} as the answer. |
8650 | It may be disappointing to hear ``the answer lies somewhere between | |
8651 | minus infinity and plus infinity, inclusive,'' but that's the best | |
8652 | that interval arithmetic can do in this case. | |
8653 | ||
8654 | @node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises | |
8655 | @subsection Types Tutorial Exercise 9 | |
8656 | ||
d7b8e6c6 | 8657 | @smallexample |
5d67986c | 8658 | @group |
d7b8e6c6 EZ |
8659 | 1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9] |
8660 | . 1: [0 .. 9] 1: [-9 .. 9] | |
8661 | . . | |
8662 | ||
5d67986c | 8663 | [ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} * |
d7b8e6c6 | 8664 | @end group |
5d67986c | 8665 | @end smallexample |
d7b8e6c6 EZ |
8666 | |
8667 | @noindent | |
8e04863e | 8668 | In the first case the result says, ``if a number is between @mathit{-3} and |
d7b8e6c6 | 8669 | 3, its square is between 0 and 9.'' The second case says, ``the product |
8e04863e | 8670 | of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.'' |
d7b8e6c6 EZ |
8671 | |
8672 | An interval form is not a number; it is a symbol that can stand for | |
8673 | many different numbers. Two identical-looking interval forms can stand | |
8674 | for different numbers. | |
8675 | ||
8676 | The same issue arises when you try to square an error form. | |
8677 | ||
8678 | @node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises | |
8679 | @subsection Types Tutorial Exercise 10 | |
8680 | ||
8681 | @noindent | |
a4231b04 | 8682 | Testing the first number, we might arbitrarily choose 17 for @expr{x}. |
d7b8e6c6 | 8683 | |
d7b8e6c6 | 8684 | @smallexample |
5d67986c | 8685 | @group |
d7b8e6c6 EZ |
8686 | 1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613 |
8687 | . 811749612 . | |
8688 | . | |
8689 | ||
5d67986c | 8690 | 17 M 811749613 @key{RET} 811749612 ^ |
d7b8e6c6 | 8691 | @end group |
5d67986c | 8692 | @end smallexample |
d7b8e6c6 EZ |
8693 | |
8694 | @noindent | |
8695 | Since 533694123 is (considerably) different from 1, the number 811749613 | |
8696 | must not be prime. | |
8697 | ||
8698 | It's awkward to type the number in twice as we did above. There are | |
8699 | various ways to avoid this, and algebraic entry is one. In fact, using | |
8700 | a vector mapping operation we can perform several tests at once. Let's | |
8701 | use this method to test the second number. | |
8702 | ||
d7b8e6c6 | 8703 | @smallexample |
5d67986c | 8704 | @group |
d7b8e6c6 EZ |
8705 | 2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ] |
8706 | 1: 15485863 . | |
8707 | . | |
8708 | ||
5d67986c | 8709 | [17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET} |
d7b8e6c6 | 8710 | @end group |
5d67986c | 8711 | @end smallexample |
d7b8e6c6 EZ |
8712 | |
8713 | @noindent | |
a4231b04 | 8714 | The result is three ones (modulo @expr{n}), so it's very probable that |
d7b8e6c6 EZ |
8715 | 15485863 is prime. (In fact, this number is the millionth prime.) |
8716 | ||
8717 | Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $} | |
8718 | would have been hopelessly inefficient, since they would have calculated | |
8719 | the power using full integer arithmetic. | |
8720 | ||
8721 | Calc has a @kbd{k p} command that does primality testing. For small | |
8722 | numbers it does an exact test; for large numbers it uses a variant | |
8723 | of the Fermat test we used here. You can use @kbd{k p} repeatedly | |
8724 | to prove that a large integer is prime with any desired probability. | |
8725 | ||
8726 | @node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises | |
8727 | @subsection Types Tutorial Exercise 11 | |
8728 | ||
8729 | @noindent | |
8730 | There are several ways to insert a calculated number into an HMS form. | |
8731 | One way to convert a number of seconds to an HMS form is simply to | |
8732 | multiply the number by an HMS form representing one second: | |
8733 | ||
d7b8e6c6 | 8734 | @smallexample |
5d67986c | 8735 | @group |
d7b8e6c6 EZ |
8736 | 1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359" |
8737 | . 1: 0@@ 0' 1" . | |
8738 | . | |
8739 | ||
8740 | P 1e7 * 0@@ 0' 1" * | |
8741 | ||
d7b8e6c6 | 8742 | @end group |
5d67986c | 8743 | @end smallexample |
d7b8e6c6 | 8744 | @noindent |
d7b8e6c6 | 8745 | @smallexample |
5d67986c | 8746 | @group |
d7b8e6c6 EZ |
8747 | 2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0" |
8748 | 1: 15@@ 27' 16" mod 24@@ 0' 0" . | |
8749 | . | |
8750 | ||
5d67986c | 8751 | x time @key{RET} + |
d7b8e6c6 | 8752 | @end group |
5d67986c | 8753 | @end smallexample |
d7b8e6c6 EZ |
8754 | |
8755 | @noindent | |
8756 | It will be just after six in the morning. | |
8757 | ||
8758 | The algebraic @code{hms} function can also be used to build an | |
8759 | HMS form: | |
8760 | ||
d7b8e6c6 | 8761 | @smallexample |
5d67986c | 8762 | @group |
d7b8e6c6 EZ |
8763 | 1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359" |
8764 | . . | |
8765 | ||
5d67986c | 8766 | ' hms(0, 0, 1e7 pi) @key{RET} = |
d7b8e6c6 | 8767 | @end group |
5d67986c | 8768 | @end smallexample |
d7b8e6c6 EZ |
8769 | |
8770 | @noindent | |
8771 | The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to | |
8772 | the actual number 3.14159... | |
8773 | ||
8774 | @node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises | |
8775 | @subsection Types Tutorial Exercise 12 | |
8776 | ||
8777 | @noindent | |
8778 | As we recall, there are 17 songs of about 2 minutes and 47 seconds | |
8779 | each. | |
8780 | ||
d7b8e6c6 | 8781 | @smallexample |
5d67986c | 8782 | @group |
d7b8e6c6 EZ |
8783 | 2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"] |
8784 | 1: [0@@ 0' 20" .. 0@@ 1' 0"] . | |
8785 | . | |
8786 | ||
8787 | [ 0@@ 20" .. 0@@ 1' ] + | |
8788 | ||
d7b8e6c6 | 8789 | @end group |
5d67986c | 8790 | @end smallexample |
d7b8e6c6 | 8791 | @noindent |
d7b8e6c6 | 8792 | @smallexample |
5d67986c | 8793 | @group |
d7b8e6c6 EZ |
8794 | 1: [0@@ 52' 59." .. 1@@ 4' 19."] |
8795 | . | |
8796 | ||
8797 | 17 * | |
d7b8e6c6 | 8798 | @end group |
5d67986c | 8799 | @end smallexample |
d7b8e6c6 EZ |
8800 | |
8801 | @noindent | |
8802 | No matter how long it is, the album will fit nicely on one CD. | |
8803 | ||
8804 | @node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises | |
8805 | @subsection Types Tutorial Exercise 13 | |
8806 | ||
8807 | @noindent | |
5d67986c | 8808 | Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds. |
d7b8e6c6 EZ |
8809 | |
8810 | @node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises | |
8811 | @subsection Types Tutorial Exercise 14 | |
8812 | ||
8813 | @noindent | |
8814 | How long will it take for a signal to get from one end of the computer | |
8815 | to the other? | |
8816 | ||
d7b8e6c6 | 8817 | @smallexample |
5d67986c | 8818 | @group |
d7b8e6c6 EZ |
8819 | 1: m / c 1: 3.3356 ns |
8820 | . . | |
8821 | ||
5d67986c | 8822 | ' 1 m / c @key{RET} u c ns @key{RET} |
d7b8e6c6 | 8823 | @end group |
5d67986c | 8824 | @end smallexample |
d7b8e6c6 EZ |
8825 | |
8826 | @noindent | |
8827 | (Recall, @samp{c} is a ``unit'' corresponding to the speed of light.) | |
8828 | ||
d7b8e6c6 | 8829 | @smallexample |
5d67986c | 8830 | @group |
d7b8e6c6 EZ |
8831 | 1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356 |
8832 | 2: 4.1 ns . . | |
8833 | . | |
8834 | ||
5d67986c | 8835 | ' 4.1 ns @key{RET} / u s |
d7b8e6c6 | 8836 | @end group |
5d67986c | 8837 | @end smallexample |
d7b8e6c6 EZ |
8838 | |
8839 | @noindent | |
8840 | Thus a signal could take up to 81 percent of a clock cycle just to | |
8841 | go from one place to another inside the computer, assuming the signal | |
8842 | could actually attain the full speed of light. Pretty tight! | |
8843 | ||
8844 | @node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises | |
8845 | @subsection Types Tutorial Exercise 15 | |
8846 | ||
8847 | @noindent | |
8848 | The speed limit is 55 miles per hour on most highways. We want to | |
8849 | find the ratio of Sam's speed to the US speed limit. | |
8850 | ||
d7b8e6c6 | 8851 | @smallexample |
5d67986c | 8852 | @group |
d7b8e6c6 EZ |
8853 | 1: 55 mph 2: 55 mph 3: 11 hr mph / yd |
8854 | . 1: 5 yd / hr . | |
8855 | . | |
8856 | ||
5d67986c | 8857 | ' 55 mph @key{RET} ' 5 yd/hr @key{RET} / |
d7b8e6c6 | 8858 | @end group |
5d67986c | 8859 | @end smallexample |
d7b8e6c6 EZ |
8860 | |
8861 | The @kbd{u s} command cancels out these units to get a plain | |
8862 | number. Now we take the logarithm base two to find the final | |
8863 | answer, assuming that each successive pill doubles his speed. | |
8864 | ||
d7b8e6c6 | 8865 | @smallexample |
5d67986c | 8866 | @group |
d7b8e6c6 EZ |
8867 | 1: 19360. 2: 19360. 1: 14.24 |
8868 | . 1: 2 . | |
8869 | . | |
8870 | ||
8871 | u s 2 B | |
d7b8e6c6 | 8872 | @end group |
5d67986c | 8873 | @end smallexample |
d7b8e6c6 EZ |
8874 | |
8875 | @noindent | |
8876 | Thus Sam can take up to 14 pills without a worry. | |
8877 | ||
8878 | @node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises | |
8879 | @subsection Algebra Tutorial Exercise 1 | |
8880 | ||
8881 | @noindent | |
8882 | @c [fix-ref Declarations] | |
a4231b04 | 8883 | The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the |
d7b8e6c6 | 8884 | Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens |
a4231b04 | 8885 | if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be |
d7b8e6c6 EZ |
8886 | simplified to @samp{abs(x)}, but for general complex arguments even |
8887 | that is not safe. (@xref{Declarations}, for a way to tell Calc | |
a4231b04 | 8888 | that @expr{x} is known to be real.) |
d7b8e6c6 EZ |
8889 | |
8890 | @node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises | |
8891 | @subsection Algebra Tutorial Exercise 2 | |
8892 | ||
8893 | @noindent | |
a4231b04 JB |
8894 | Suppose our roots are @expr{[a, b, c]}. We want a polynomial which |
8895 | is zero when @expr{x} is any of these values. The trivial polynomial | |
8896 | @expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)} | |
d7b8e6c6 EZ |
8897 | will do the job. We can use @kbd{a c x} to write this in a more |
8898 | familiar form. | |
8899 | ||
d7b8e6c6 | 8900 | @smallexample |
5d67986c | 8901 | @group |
d7b8e6c6 EZ |
8902 | 1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0] |
8903 | . . | |
8904 | ||
5d67986c | 8905 | r 2 a P x @key{RET} |
d7b8e6c6 | 8906 | |
d7b8e6c6 | 8907 | @end group |
5d67986c | 8908 | @end smallexample |
d7b8e6c6 | 8909 | @noindent |
d7b8e6c6 | 8910 | @smallexample |
5d67986c | 8911 | @group |
d7b8e6c6 EZ |
8912 | 1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x |
8913 | . . | |
8914 | ||
5d67986c | 8915 | V M ' x-$ @key{RET} V R * |
d7b8e6c6 | 8916 | |
d7b8e6c6 | 8917 | @end group |
5d67986c | 8918 | @end smallexample |
d7b8e6c6 | 8919 | @noindent |
d7b8e6c6 | 8920 | @smallexample |
5d67986c | 8921 | @group |
d7b8e6c6 EZ |
8922 | 1: x^3 - 1.41666 x 1: 34 x - 24 x^3 |
8923 | . . | |
8924 | ||
5d67986c | 8925 | a c x @key{RET} 24 n * a x |
d7b8e6c6 | 8926 | @end group |
5d67986c | 8927 | @end smallexample |
d7b8e6c6 EZ |
8928 | |
8929 | @noindent | |
8930 | Sure enough, our answer (multiplied by a suitable constant) is the | |
8931 | same as the original polynomial. | |
8932 | ||
8933 | @node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises | |
8934 | @subsection Algebra Tutorial Exercise 3 | |
8935 | ||
d7b8e6c6 | 8936 | @smallexample |
5d67986c | 8937 | @group |
d7b8e6c6 EZ |
8938 | 1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2 |
8939 | . . | |
8940 | ||
5d67986c | 8941 | ' x sin(pi x) @key{RET} m r a i x @key{RET} |
d7b8e6c6 | 8942 | |
d7b8e6c6 | 8943 | @end group |
5d67986c | 8944 | @end smallexample |
d7b8e6c6 | 8945 | @noindent |
d7b8e6c6 | 8946 | @smallexample |
5d67986c | 8947 | @group |
d7b8e6c6 EZ |
8948 | 1: [y, 1] |
8949 | 2: (sin(pi x) - pi x cos(pi x)) / pi^2 | |
8950 | . | |
8951 | ||
5d67986c | 8952 | ' [y,1] @key{RET} @key{TAB} |
d7b8e6c6 | 8953 | |
d7b8e6c6 | 8954 | @end group |
5d67986c | 8955 | @end smallexample |
d7b8e6c6 | 8956 | @noindent |
d7b8e6c6 | 8957 | @smallexample |
5d67986c | 8958 | @group |
d7b8e6c6 EZ |
8959 | 1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2] |
8960 | . | |
8961 | ||
5d67986c | 8962 | V M $ @key{RET} |
d7b8e6c6 | 8963 | |
d7b8e6c6 | 8964 | @end group |
5d67986c | 8965 | @end smallexample |
d7b8e6c6 | 8966 | @noindent |
d7b8e6c6 | 8967 | @smallexample |
5d67986c | 8968 | @group |
d7b8e6c6 EZ |
8969 | 1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2 |
8970 | . | |
8971 | ||
8972 | V R - | |
8973 | ||
d7b8e6c6 | 8974 | @end group |
5d67986c | 8975 | @end smallexample |
d7b8e6c6 | 8976 | @noindent |
d7b8e6c6 | 8977 | @smallexample |
5d67986c | 8978 | @group |
d7b8e6c6 EZ |
8979 | 1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183 |
8980 | . | |
8981 | ||
8982 | = | |
8983 | ||
d7b8e6c6 | 8984 | @end group |
5d67986c | 8985 | @end smallexample |
d7b8e6c6 | 8986 | @noindent |
d7b8e6c6 | 8987 | @smallexample |
5d67986c | 8988 | @group |
d7b8e6c6 EZ |
8989 | 1: [0., -0.95493, 0.63662, -1.5915, 1.2732] |
8990 | . | |
8991 | ||
5d67986c | 8992 | v x 5 @key{RET} @key{TAB} V M $ @key{RET} |
d7b8e6c6 | 8993 | @end group |
5d67986c | 8994 | @end smallexample |
d7b8e6c6 EZ |
8995 | |
8996 | @node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises | |
8997 | @subsection Algebra Tutorial Exercise 4 | |
8998 | ||
8999 | @noindent | |
9000 | The hard part is that @kbd{V R +} is no longer sufficient to add up all | |
9001 | the contributions from the slices, since the slices have varying | |
9002 | coefficients. So first we must come up with a vector of these | |
9003 | coefficients. Here's one way: | |
9004 | ||
d7b8e6c6 | 9005 | @smallexample |
5d67986c | 9006 | @group |
d7b8e6c6 EZ |
9007 | 2: -1 2: 3 1: [4, 2, ..., 4] |
9008 | 1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] . | |
9009 | . . | |
9010 | ||
5d67986c | 9011 | 1 n v x 9 @key{RET} V M ^ 3 @key{TAB} - |
d7b8e6c6 | 9012 | |
d7b8e6c6 | 9013 | @end group |
5d67986c | 9014 | @end smallexample |
d7b8e6c6 | 9015 | @noindent |
d7b8e6c6 | 9016 | @smallexample |
5d67986c | 9017 | @group |
d7b8e6c6 EZ |
9018 | 1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1] |
9019 | . . | |
9020 | ||
5d67986c | 9021 | 1 | 1 @key{TAB} | |
d7b8e6c6 | 9022 | @end group |
5d67986c | 9023 | @end smallexample |
d7b8e6c6 EZ |
9024 | |
9025 | @noindent | |
9026 | Now we compute the function values. Note that for this method we need | |
9027 | eleven values, including both endpoints of the desired interval. | |
9028 | ||
d7b8e6c6 | 9029 | @smallexample |
5d67986c | 9030 | @group |
d7b8e6c6 EZ |
9031 | 2: [1, 4, 2, ..., 4, 1] |
9032 | 1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.] | |
9033 | . | |
9034 | ||
5d67986c | 9035 | 11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x |
d7b8e6c6 | 9036 | |
d7b8e6c6 | 9037 | @end group |
5d67986c | 9038 | @end smallexample |
d7b8e6c6 | 9039 | @noindent |
d7b8e6c6 | 9040 | @smallexample |
5d67986c | 9041 | @group |
d7b8e6c6 EZ |
9042 | 2: [1, 4, 2, ..., 4, 1] |
9043 | 1: [0., 0.084941, 0.16993, ... ] | |
9044 | . | |
9045 | ||
5d67986c | 9046 | ' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET} |
d7b8e6c6 | 9047 | @end group |
5d67986c | 9048 | @end smallexample |
d7b8e6c6 EZ |
9049 | |
9050 | @noindent | |
9051 | Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the | |
9052 | same thing. | |
9053 | ||
d7b8e6c6 | 9054 | @smallexample |
5d67986c | 9055 | @group |
d7b8e6c6 EZ |
9056 | 1: 11.22 1: 1.122 1: 0.374 |
9057 | . . . | |
9058 | ||
9059 | * .1 * 3 / | |
d7b8e6c6 | 9060 | @end group |
5d67986c | 9061 | @end smallexample |
d7b8e6c6 EZ |
9062 | |
9063 | @noindent | |
9064 | Wow! That's even better than the result from the Taylor series method. | |
9065 | ||
9066 | @node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises | |
9067 | @subsection Rewrites Tutorial Exercise 1 | |
9068 | ||
9069 | @noindent | |
9070 | We'll use Big mode to make the formulas more readable. | |
9071 | ||
d7b8e6c6 | 9072 | @smallexample |
5d67986c | 9073 | @group |
d7b8e6c6 EZ |
9074 | ___ |
9075 | 2 + V 2 | |
9076 | 1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: -------- | |
9077 | . ___ | |
9078 | 1 + V 2 | |
9079 | ||
9080 | . | |
9081 | ||
5d67986c | 9082 | ' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B |
d7b8e6c6 | 9083 | @end group |
5d67986c | 9084 | @end smallexample |
d7b8e6c6 EZ |
9085 | |
9086 | @noindent | |
a4231b04 | 9087 | Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}. |
d7b8e6c6 | 9088 | |
d7b8e6c6 | 9089 | @smallexample |
5d67986c | 9090 | @group |
d7b8e6c6 EZ |
9091 | ___ ___ |
9092 | 1: (2 + V 2 ) (V 2 - 1) | |
9093 | . | |
9094 | ||
5d67986c | 9095 | a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET} |
d7b8e6c6 | 9096 | |
d7b8e6c6 | 9097 | @end group |
5d67986c | 9098 | @end smallexample |
d7b8e6c6 | 9099 | @noindent |
d7b8e6c6 | 9100 | @smallexample |
5d67986c | 9101 | @group |
d7b8e6c6 EZ |
9102 | ___ ___ |
9103 | 1: 2 + V 2 - 2 1: V 2 | |
9104 | . . | |
9105 | ||
9106 | a r a*(b+c) := a*b + a*c a s | |
d7b8e6c6 | 9107 | @end group |
5d67986c | 9108 | @end smallexample |
d7b8e6c6 EZ |
9109 | |
9110 | @noindent | |
9111 | (We could have used @kbd{a x} instead of a rewrite rule for the | |
9112 | second step.) | |
9113 | ||
9114 | The multiply-by-conjugate rule turns out to be useful in many | |
9115 | different circumstances, such as when the denominator involves | |
9116 | sines and cosines or the imaginary constant @code{i}. | |
9117 | ||
9118 | @node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises | |
9119 | @subsection Rewrites Tutorial Exercise 2 | |
9120 | ||
9121 | @noindent | |
9122 | Here is the rule set: | |
9123 | ||
d7b8e6c6 | 9124 | @smallexample |
5d67986c | 9125 | @group |
d7b8e6c6 EZ |
9126 | [ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1, |
9127 | fib(1, x, y) := x, | |
9128 | fib(n, x, y) := fib(n-1, y, x+y) ] | |
d7b8e6c6 | 9129 | @end group |
5d67986c | 9130 | @end smallexample |
d7b8e6c6 EZ |
9131 | |
9132 | @noindent | |
9133 | The first rule turns a one-argument @code{fib} that people like to write | |
9134 | into a three-argument @code{fib} that makes computation easier. The | |
9135 | second rule converts back from three-argument form once the computation | |
9136 | is done. The third rule does the computation itself. It basically | |
a4231b04 JB |
9137 | says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers, |
9138 | then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci | |
d7b8e6c6 EZ |
9139 | numbers. |
9140 | ||
a4231b04 | 9141 | Notice that because the number @expr{n} was ``validated'' by the |
d7b8e6c6 EZ |
9142 | conditions on the first rule, there is no need to put conditions on |
9143 | the other rules because the rule set would never get that far unless | |
9144 | the input were valid. That further speeds computation, since no | |
9145 | extra conditions need to be checked at every step. | |
9146 | ||
9147 | Actually, a user with a nasty sense of humor could enter a bad | |
9148 | three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)}, | |
9149 | which would get the rules into an infinite loop. One thing that would | |
9150 | help keep this from happening by accident would be to use something like | |
9151 | @samp{ZzFib} instead of @code{fib} as the name of the three-argument | |
9152 | function. | |
9153 | ||
9154 | @node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises | |
9155 | @subsection Rewrites Tutorial Exercise 3 | |
9156 | ||
9157 | @noindent | |
9158 | He got an infinite loop. First, Calc did as expected and rewrote | |
9159 | @w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to | |
9160 | apply the rule again, and found that @samp{f(2, 3, x)} looks like | |
9161 | @samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to | |
9162 | @samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)} | |
9163 | around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r} | |
9164 | to make sure the rule applied only once. | |
9165 | ||
9166 | (Actually, even the first step didn't work as he expected. What Calc | |
9167 | really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)}, | |
9168 | treating 2 as the ``variable,'' and @samp{3 x} as a constant being added | |
9169 | to it. While this may seem odd, it's just as valid a solution as the | |
9170 | ``obvious'' one. One way to fix this would be to add the condition | |
9171 | @samp{:: variable(x)} to the rule, to make sure the thing that matches | |
9172 | @samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)} | |
9173 | on the lefthand side, so that the rule matches the actual variable | |
9174 | @samp{x} rather than letting @samp{x} stand for something else.) | |
9175 | ||
9176 | @node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises | |
9177 | @subsection Rewrites Tutorial Exercise 4 | |
9178 | ||
9179 | @noindent | |
5d67986c RS |
9180 | @ignore |
9181 | @starindex | |
9182 | @end ignore | |
d7b8e6c6 EZ |
9183 | @tindex seq |
9184 | Here is a suitable set of rules to solve the first part of the problem: | |
9185 | ||
d7b8e6c6 | 9186 | @smallexample |
5d67986c | 9187 | @group |
d7b8e6c6 EZ |
9188 | [ seq(n, c) := seq(n/2, c+1) :: n%2 = 0, |
9189 | seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ] | |
d7b8e6c6 | 9190 | @end group |
5d67986c | 9191 | @end smallexample |
d7b8e6c6 EZ |
9192 | |
9193 | Given the initial formula @samp{seq(6, 0)}, application of these | |
9194 | rules produces the following sequence of formulas: | |
9195 | ||
9196 | @example | |
9197 | seq( 3, 1) | |
9198 | seq(10, 2) | |
9199 | seq( 5, 3) | |
9200 | seq(16, 4) | |
9201 | seq( 8, 5) | |
9202 | seq( 4, 6) | |
9203 | seq( 2, 7) | |
9204 | seq( 1, 8) | |
9205 | @end example | |
9206 | ||
9207 | @noindent | |
9208 | whereupon neither of the rules match, and rewriting stops. | |
9209 | ||
9210 | We can pretty this up a bit with a couple more rules: | |
9211 | ||
d7b8e6c6 | 9212 | @smallexample |
5d67986c | 9213 | @group |
d7b8e6c6 EZ |
9214 | [ seq(n) := seq(n, 0), |
9215 | seq(1, c) := c, | |
9216 | ... ] | |
d7b8e6c6 | 9217 | @end group |
5d67986c | 9218 | @end smallexample |
d7b8e6c6 EZ |
9219 | |
9220 | @noindent | |
9221 | Now, given @samp{seq(6)} as the starting configuration, we get 8 | |
9222 | as the result. | |
9223 | ||
9224 | The change to return a vector is quite simple: | |
9225 | ||
d7b8e6c6 | 9226 | @smallexample |
5d67986c | 9227 | @group |
d7b8e6c6 EZ |
9228 | [ seq(n) := seq(n, []) :: integer(n) :: n > 0, |
9229 | seq(1, v) := v | 1, | |
9230 | seq(n, v) := seq(n/2, v | n) :: n%2 = 0, | |
9231 | seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ] | |
d7b8e6c6 | 9232 | @end group |
5d67986c | 9233 | @end smallexample |
d7b8e6c6 EZ |
9234 | |
9235 | @noindent | |
9236 | Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}. | |
9237 | ||
a4231b04 JB |
9238 | Notice that the @expr{n > 1} guard is no longer necessary on the last |
9239 | rule since the @expr{n = 1} case is now detected by another rule. | |
d7b8e6c6 EZ |
9240 | But a guard has been added to the initial rule to make sure the |
9241 | initial value is suitable before the computation begins. | |
9242 | ||
9243 | While still a good idea, this guard is not as vitally important as it | |
9244 | was for the @code{fib} function, since calling, say, @samp{seq(x, [])} | |
9245 | will not get into an infinite loop. Calc will not be able to prove | |
9246 | the symbol @samp{x} is either even or odd, so none of the rules will | |
9247 | apply and the rewrites will stop right away. | |
9248 | ||
9249 | @node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises | |
9250 | @subsection Rewrites Tutorial Exercise 5 | |
9251 | ||
9252 | @noindent | |
5d67986c RS |
9253 | @ignore |
9254 | @starindex | |
9255 | @end ignore | |
d7b8e6c6 | 9256 | @tindex nterms |
bd712b70 JB |
9257 | If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must |
9258 | be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x} | |
9259 | is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1. | |
d7b8e6c6 | 9260 | |
d7b8e6c6 | 9261 | @smallexample |
5d67986c | 9262 | @group |
d7b8e6c6 EZ |
9263 | [ nterms(a + b) := nterms(a) + nterms(b), |
9264 | nterms(x) := 1 ] | |
d7b8e6c6 | 9265 | @end group |
5d67986c | 9266 | @end smallexample |
d7b8e6c6 EZ |
9267 | |
9268 | @noindent | |
9269 | Here we have taken advantage of the fact that earlier rules always | |
9270 | match before later rules; @samp{nterms(x)} will only be tried if we | |
9271 | already know that @samp{x} is not a sum. | |
9272 | ||
8c399bc1 | 9273 | @node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises |
d7b8e6c6 EZ |
9274 | @subsection Rewrites Tutorial Exercise 6 |
9275 | ||
d7b8e6c6 EZ |
9276 | @noindent |
9277 | Here is a rule set that will do the job: | |
9278 | ||
d7b8e6c6 | 9279 | @smallexample |
5d67986c | 9280 | @group |
d7b8e6c6 EZ |
9281 | [ a*(b + c) := a*b + a*c, |
9282 | opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m | |
9283 | :: constant(a) :: constant(b), | |
9284 | opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m | |
9285 | :: constant(a) :: constant(b), | |
9286 | a O(x^n) := O(x^n) :: constant(a), | |
9287 | x^opt(m) O(x^n) := O(x^(n+m)), | |
9288 | O(x^n) O(x^m) := O(x^(n+m)) ] | |
d7b8e6c6 | 9289 | @end group |
5d67986c | 9290 | @end smallexample |
d7b8e6c6 EZ |
9291 | |
9292 | If we really want the @kbd{+} and @kbd{*} keys to operate naturally | |
9293 | on power series, we should put these rules in @code{EvalRules}. For | |
9294 | testing purposes, it is better to put them in a different variable, | |
9295 | say, @code{O}, first. | |
9296 | ||
9297 | The first rule just expands products of sums so that the rest of the | |
9298 | rules can assume they have an expanded-out polynomial to work with. | |
9299 | Note that this rule does not mention @samp{O} at all, so it will | |
9300 | apply to any product-of-sum it encounters---this rule may surprise | |
9301 | you if you put it into @code{EvalRules}! | |
9302 | ||
9303 | In the second rule, the sum of two O's is changed to the smaller O. | |
9304 | The optional constant coefficients are there mostly so that | |
9305 | @samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled | |
9306 | as well as @samp{O(x^2) + O(x^3)}. | |
9307 | ||
9308 | The third rule absorbs higher powers of @samp{x} into O's. | |
9309 | ||
9310 | The fourth rule says that a constant times a negligible quantity | |
9311 | is still negligible. (This rule will also match @samp{O(x^3) / 4}, | |
9312 | with @samp{a = 1/4}.) | |
9313 | ||
9314 | The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}. | |
9315 | (It is easy to see that if one of these forms is negligible, the other | |
9316 | is, too.) Notice the @samp{x^opt(m)} to pick up terms like | |
9317 | @w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1} | |
9318 | but not 1 as @samp{x^0}. This turns out to be exactly what we want here. | |
9319 | ||
9320 | The sixth rule is the corresponding rule for products of two O's. | |
9321 | ||
9322 | Another way to solve this problem would be to create a new ``data type'' | |
9323 | that represents truncated power series. We might represent these as | |
9324 | function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is | |
a4231b04 | 9325 | a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so |
d7b8e6c6 EZ |
9326 | on. Rules would exist for sums and products of such @code{series} |
9327 | objects, and as an optional convenience could also know how to combine a | |
9328 | @code{series} object with a normal polynomial. (With this, and with a | |
9329 | rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form, | |
9330 | you could still enter power series in exactly the same notation as | |
9331 | before.) Operations on such objects would probably be more efficient, | |
9332 | although the objects would be a bit harder to read. | |
9333 | ||
9334 | @c [fix-ref Compositions] | |
9335 | Some other symbolic math programs provide a power series data type | |
9336 | similar to this. Mathematica, for example, has an object that looks | |
9337 | like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin}, | |
9338 | @var{nmax}, @var{den}]}, where @var{x0} is the point about which the | |
9339 | power series is taken (we've been assuming this was always zero), | |
9340 | and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series | |
9341 | with fractional or negative powers. Also, the @code{PowerSeries} | |
9342 | objects have a special display format that makes them look like | |
9343 | @samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions}, | |
9344 | for a way to do this in Calc, although for something as involved as | |
9345 | this it would probably be better to write the formatting routine | |
9346 | in Lisp.) | |
9347 | ||
8c399bc1 | 9348 | @node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises |
d7b8e6c6 EZ |
9349 | @subsection Programming Tutorial Exercise 1 |
9350 | ||
9351 | @noindent | |
9352 | Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type | |
9353 | @kbd{Z F}, and answer the questions. Since this formula contains two | |
9354 | variables, the default argument list will be @samp{(t x)}. We want to | |
a4231b04 | 9355 | change this to @samp{(x)} since @expr{t} is really a dummy variable |
d7b8e6c6 EZ |
9356 | to be used within @code{ninteg}. |
9357 | ||
5d67986c RS |
9358 | The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}. |
9359 | (The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.) | |
d7b8e6c6 EZ |
9360 | |
9361 | @node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises | |
9362 | @subsection Programming Tutorial Exercise 2 | |
9363 | ||
9364 | @noindent | |
9365 | One way is to move the number to the top of the stack, operate on | |
5d67986c | 9366 | it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}. |
d7b8e6c6 EZ |
9367 | |
9368 | Another way is to negate the top three stack entries, then negate | |
9369 | again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}. | |
9370 | ||
9371 | Finally, it turns out that a negative prefix argument causes a | |
9372 | command like @kbd{n} to operate on the specified stack entry only, | |
9373 | which is just what we want: @kbd{C-x ( M-- 3 n C-x )}. | |
9374 | ||
9375 | Just for kicks, let's also do it algebraically: | |
5d67986c | 9376 | @w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}. |
d7b8e6c6 EZ |
9377 | |
9378 | @node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises | |
9379 | @subsection Programming Tutorial Exercise 3 | |
9380 | ||
9381 | @noindent | |
9382 | Each of these functions can be computed using the stack, or using | |
9383 | algebraic entry, whichever way you prefer: | |
9384 | ||
9385 | @noindent | |
a4231b04 | 9386 | Computing |
8e04863e | 9387 | @texline @math{\displaystyle{\sin x \over x}}: |
a4231b04 | 9388 | @infoline @expr{sin(x) / x}: |
d7b8e6c6 | 9389 | |
5d67986c | 9390 | Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}. |
d7b8e6c6 | 9391 | |
5d67986c | 9392 | Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}. |
d7b8e6c6 EZ |
9393 | |
9394 | @noindent | |
9395 | Computing the logarithm: | |
9396 | ||
5d67986c | 9397 | Using the stack: @kbd{C-x ( @key{TAB} B C-x )} |
d7b8e6c6 | 9398 | |
5d67986c | 9399 | Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}. |
d7b8e6c6 EZ |
9400 | |
9401 | @noindent | |
9402 | Computing the vector of integers: | |
9403 | ||
5d67986c | 9404 | Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that |
d7b8e6c6 EZ |
9405 | @kbd{C-u v x} takes the vector size, starting value, and increment |
9406 | from the stack.) | |
9407 | ||
9408 | Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a | |
9409 | number from the stack and uses it as the prefix argument for the | |
9410 | next command.) | |
9411 | ||
5d67986c | 9412 | Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}. |
d7b8e6c6 EZ |
9413 | |
9414 | @node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises | |
9415 | @subsection Programming Tutorial Exercise 4 | |
9416 | ||
9417 | @noindent | |
5d67986c | 9418 | Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}. |
d7b8e6c6 EZ |
9419 | |
9420 | @node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises | |
9421 | @subsection Programming Tutorial Exercise 5 | |
9422 | ||
d7b8e6c6 | 9423 | @smallexample |
5d67986c | 9424 | @group |
d7b8e6c6 EZ |
9425 | 2: 1 1: 1.61803398502 2: 1.61803398502 |
9426 | 1: 20 . 1: 1.61803398875 | |
9427 | . . | |
9428 | ||
5d67986c | 9429 | 1 @key{RET} 20 Z < & 1 + Z > I H P |
d7b8e6c6 | 9430 | @end group |
5d67986c | 9431 | @end smallexample |
d7b8e6c6 EZ |
9432 | |
9433 | @noindent | |
9434 | This answer is quite accurate. | |
9435 | ||
9436 | @node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises | |
9437 | @subsection Programming Tutorial Exercise 6 | |
9438 | ||
9439 | @noindent | |
9440 | Here is the matrix: | |
9441 | ||
9442 | @example | |
9443 | [ [ 0, 1 ] * [a, b] = [b, a + b] | |
9444 | [ 1, 1 ] ] | |
9445 | @end example | |
9446 | ||
9447 | @noindent | |
a4231b04 JB |
9448 | Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1} |
9449 | and @expr{n+2}. Here's one program that does the job: | |
d7b8e6c6 EZ |
9450 | |
9451 | @example | |
5d67986c | 9452 | C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x ) |
d7b8e6c6 EZ |
9453 | @end example |
9454 | ||
9455 | @noindent | |
9456 | This program is quite efficient because Calc knows how to raise a | |
a4231b04 | 9457 | matrix (or other value) to the power @expr{n} in only |
8e04863e | 9458 | @texline @math{\log_2 n} |
a4231b04 | 9459 | @infoline @expr{log(n,2)} |
d7b8e6c6 EZ |
9460 | steps. For example, this program can compute the 1000th Fibonacci |
9461 | number (a 209-digit integer!) in about 10 steps; even though the | |
9462 | @kbd{Z < ... Z >} solution had much simpler steps, it would have | |
9463 | required so many steps that it would not have been practical. | |
9464 | ||
9465 | @node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises | |
9466 | @subsection Programming Tutorial Exercise 7 | |
9467 | ||
9468 | @noindent | |
9469 | The trick here is to compute the harmonic numbers differently, so that | |
9470 | the loop counter itself accumulates the sum of reciprocals. We use | |
9471 | a separate variable to hold the integer counter. | |
9472 | ||
d7b8e6c6 | 9473 | @smallexample |
5d67986c | 9474 | @group |
d7b8e6c6 EZ |
9475 | 1: 1 2: 1 1: . |
9476 | . 1: 4 | |
9477 | . | |
9478 | ||
5d67986c | 9479 | 1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z ) |
d7b8e6c6 | 9480 | @end group |
5d67986c | 9481 | @end smallexample |
d7b8e6c6 EZ |
9482 | |
9483 | @noindent | |
9484 | The body of the loop goes as follows: First save the harmonic sum | |
9485 | so far in variable 2. Then delete it from the stack; the for loop | |
9486 | itself will take care of remembering it for us. Next, recall the | |
9487 | count from variable 1, add one to it, and feed its reciprocal to | |
9488 | the for loop to use as the step value. The for loop will increase | |
9489 | the ``loop counter'' by that amount and keep going until the | |
9490 | loop counter exceeds 4. | |
9491 | ||
d7b8e6c6 | 9492 | @smallexample |
5d67986c | 9493 | @group |
d7b8e6c6 EZ |
9494 | 2: 31 3: 31 |
9495 | 1: 3.99498713092 2: 3.99498713092 | |
9496 | . 1: 4.02724519544 | |
9497 | . | |
9498 | ||
5d67986c | 9499 | r 1 r 2 @key{RET} 31 & + |
d7b8e6c6 | 9500 | @end group |
5d67986c | 9501 | @end smallexample |
d7b8e6c6 EZ |
9502 | |
9503 | Thus we find that the 30th harmonic number is 3.99, and the 31st | |
9504 | harmonic number is 4.02. | |
9505 | ||
9506 | @node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises | |
9507 | @subsection Programming Tutorial Exercise 8 | |
9508 | ||
9509 | @noindent | |
a4231b04 JB |
9510 | The first step is to compute the derivative @expr{f'(x)} and thus |
9511 | the formula | |
8e04863e | 9512 | @texline @math{\displaystyle{x - {f(x) \over f'(x)}}}. |
a4231b04 | 9513 | @infoline @expr{x - f(x)/f'(x)}. |
d7b8e6c6 EZ |
9514 | |
9515 | (Because this definition is long, it will be repeated in concise form | |
58547c3e | 9516 | below. You can use @w{@kbd{C-x * m}} to load it from there. While you are |
d7b8e6c6 EZ |
9517 | entering a @kbd{Z ` Z '} body in a macro, Calc simply collects |
9518 | keystrokes without executing them. In the following diagrams we'll | |
9519 | pretend Calc actually executed the keystrokes as you typed them, | |
9520 | just for purposes of illustration.) | |
9521 | ||
d7b8e6c6 | 9522 | @smallexample |
5d67986c | 9523 | @group |
d7b8e6c6 EZ |
9524 | 2: sin(cos(x)) - 0.5 3: 4.5 |
9525 | 1: 4.5 2: sin(cos(x)) - 0.5 | |
9526 | . 1: -(sin(x) cos(cos(x))) | |
9527 | . | |
9528 | ||
5d67986c | 9529 | ' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} |
d7b8e6c6 | 9530 | |
d7b8e6c6 | 9531 | @end group |
5d67986c | 9532 | @end smallexample |
d7b8e6c6 | 9533 | @noindent |
d7b8e6c6 | 9534 | @smallexample |
5d67986c | 9535 | @group |
d7b8e6c6 EZ |
9536 | 2: 4.5 |
9537 | 1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x)) | |
9538 | . | |
9539 | ||
5d67986c | 9540 | / ' x @key{RET} @key{TAB} - t 1 |
d7b8e6c6 | 9541 | @end group |
5d67986c | 9542 | @end smallexample |
d7b8e6c6 EZ |
9543 | |
9544 | Now, we enter the loop. We'll use a repeat loop with a 20-repetition | |
9545 | limit just in case the method fails to converge for some reason. | |
9546 | (Normally, the @w{@kbd{Z /}} command will stop the loop before all 20 | |
9547 | repetitions are done.) | |
9548 | ||
d7b8e6c6 | 9549 | @smallexample |
5d67986c | 9550 | @group |
d7b8e6c6 EZ |
9551 | 1: 4.5 3: 4.5 2: 4.5 |
9552 | . 2: x + (sin(cos(x)) ... 1: 5.24196456928 | |
9553 | 1: 4.5 . | |
9554 | . | |
9555 | ||
5d67986c | 9556 | 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET} |
d7b8e6c6 | 9557 | @end group |
5d67986c | 9558 | @end smallexample |
d7b8e6c6 | 9559 | |
a4231b04 | 9560 | This is the new guess for @expr{x}. Now we compare it with the |
d7b8e6c6 EZ |
9561 | old one to see if we've converged. |
9562 | ||
d7b8e6c6 | 9563 | @smallexample |
5d67986c | 9564 | @group |
d7b8e6c6 EZ |
9565 | 3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348 |
9566 | 2: 5.24196 1: 0 . . | |
9567 | 1: 4.5 . | |
9568 | . | |
9569 | ||
5d67986c | 9570 | @key{RET} M-@key{TAB} a = Z / Z > Z ' C-x ) |
d7b8e6c6 | 9571 | @end group |
5d67986c | 9572 | @end smallexample |
d7b8e6c6 EZ |
9573 | |
9574 | The loop converges in just a few steps to this value. To check | |
9575 | the result, we can simply substitute it back into the equation. | |
9576 | ||
d7b8e6c6 | 9577 | @smallexample |
5d67986c | 9578 | @group |
d7b8e6c6 EZ |
9579 | 2: 5.26345856348 |
9580 | 1: 0.499999999997 | |
9581 | . | |
9582 | ||
5d67986c | 9583 | @key{RET} ' sin(cos($)) @key{RET} |
d7b8e6c6 | 9584 | @end group |
5d67986c | 9585 | @end smallexample |
d7b8e6c6 EZ |
9586 | |
9587 | Let's test the new definition again: | |
9588 | ||
d7b8e6c6 | 9589 | @smallexample |
5d67986c | 9590 | @group |
d7b8e6c6 EZ |
9591 | 2: x^2 - 9 1: 3. |
9592 | 1: 1 . | |
9593 | . | |
9594 | ||
5d67986c | 9595 | ' x^2-9 @key{RET} 1 X |
d7b8e6c6 | 9596 | @end group |
5d67986c | 9597 | @end smallexample |
d7b8e6c6 EZ |
9598 | |
9599 | Once again, here's the full Newton's Method definition: | |
9600 | ||
d7b8e6c6 | 9601 | @example |
5d67986c RS |
9602 | @group |
9603 | C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1 | |
9604 | 20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET} | |
9605 | @key{RET} M-@key{TAB} a = Z / | |
d7b8e6c6 EZ |
9606 | Z > |
9607 | Z ' | |
9608 | C-x ) | |
d7b8e6c6 | 9609 | @end group |
5d67986c | 9610 | @end example |
d7b8e6c6 EZ |
9611 | |
9612 | @c [fix-ref Nesting and Fixed Points] | |
9613 | It turns out that Calc has a built-in command for applying a formula | |
9614 | repeatedly until it converges to a number. @xref{Nesting and Fixed Points}, | |
9615 | to see how to use it. | |
9616 | ||
9617 | @c [fix-ref Root Finding] | |
9618 | Also, of course, @kbd{a R} is a built-in command that uses Newton's | |
9619 | method (among others) to look for numerical solutions to any equation. | |
9620 | @xref{Root Finding}. | |
9621 | ||
9622 | @node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises | |
9623 | @subsection Programming Tutorial Exercise 9 | |
9624 | ||
9625 | @noindent | |
a4231b04 JB |
9626 | The first step is to adjust @expr{z} to be greater than 5. A simple |
9627 | ``for'' loop will do the job here. If @expr{z} is less than 5, we | |
9628 | reduce the problem using | |
8e04863e | 9629 | @texline @math{\psi(z) = \psi(z+1) - 1/z}. |
a4231b04 JB |
9630 | @infoline @expr{psi(z) = psi(z+1) - 1/z}. We go |
9631 | on to compute | |
8e04863e | 9632 | @texline @math{\psi(z+1)}, |
a4231b04 JB |
9633 | @infoline @expr{psi(z+1)}, |
9634 | and remember to add back a factor of @expr{-1/z} when we're done. This | |
9635 | step is repeated until @expr{z > 5}. | |
d7b8e6c6 EZ |
9636 | |
9637 | (Because this definition is long, it will be repeated in concise form | |
58547c3e | 9638 | below. You can use @w{@kbd{C-x * m}} to load it from there. While you are |
d7b8e6c6 EZ |
9639 | entering a @kbd{Z ` Z '} body in a macro, Calc simply collects |
9640 | keystrokes without executing them. In the following diagrams we'll | |
9641 | pretend Calc actually executed the keystrokes as you typed them, | |
9642 | just for purposes of illustration.) | |
9643 | ||
d7b8e6c6 | 9644 | @smallexample |
5d67986c | 9645 | @group |
d7b8e6c6 EZ |
9646 | 1: 1. 1: 1. |
9647 | . . | |
9648 | ||
5d67986c | 9649 | 1.0 @key{RET} C-x ( Z ` s 1 0 t 2 |
d7b8e6c6 | 9650 | @end group |
5d67986c | 9651 | @end smallexample |
d7b8e6c6 | 9652 | |
a4231b04 JB |
9653 | Here, variable 1 holds @expr{z} and variable 2 holds the adjustment |
9654 | factor. If @expr{z < 5}, we use a loop to increase it. | |
d7b8e6c6 EZ |
9655 | |
9656 | (By the way, we started with @samp{1.0} instead of the integer 1 because | |
9657 | otherwise the calculation below will try to do exact fractional arithmetic, | |
9658 | and will never converge because fractions compare equal only if they | |
9659 | are exactly equal, not just equal to within the current precision.) | |
9660 | ||
d7b8e6c6 | 9661 | @smallexample |
5d67986c | 9662 | @group |
d7b8e6c6 EZ |
9663 | 3: 1. 2: 1. 1: 6. |
9664 | 2: 1. 1: 1 . | |
9665 | 1: 5 . | |
9666 | . | |
9667 | ||
5d67986c | 9668 | @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] |
d7b8e6c6 | 9669 | @end group |
5d67986c | 9670 | @end smallexample |
d7b8e6c6 | 9671 | |
a4231b04 | 9672 | Now we compute the initial part of the sum: |
8e04863e | 9673 | @texline @math{\ln z - {1 \over 2z}} |
a4231b04 | 9674 | @infoline @expr{ln(z) - 1/2z} |
d7b8e6c6 EZ |
9675 | minus the adjustment factor. |
9676 | ||
d7b8e6c6 | 9677 | @smallexample |
5d67986c | 9678 | @group |
d7b8e6c6 EZ |
9679 | 2: 1.79175946923 2: 1.7084261359 1: -0.57490719743 |
9680 | 1: 0.0833333333333 1: 2.28333333333 . | |
9681 | . . | |
9682 | ||
9683 | L r 1 2 * & - r 2 - | |
d7b8e6c6 | 9684 | @end group |
5d67986c | 9685 | @end smallexample |
d7b8e6c6 EZ |
9686 | |
9687 | Now we evaluate the series. We'll use another ``for'' loop counting | |
a4231b04 | 9688 | up the value of @expr{2 n}. (Calc does have a summation command, |
d7b8e6c6 EZ |
9689 | @kbd{a +}, but we'll use loops just to get more practice with them.) |
9690 | ||
d7b8e6c6 | 9691 | @smallexample |
5d67986c | 9692 | @group |
d7b8e6c6 EZ |
9693 | 3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749 |
9694 | 2: 2 2: 1:6 3: 1:6 1: 2.3148e-3 | |
9695 | 1: 40 1: 2 2: 2 . | |
9696 | . . 1: 36. | |
9697 | . | |
9698 | ||
5d67986c | 9699 | 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * / |
d7b8e6c6 | 9700 | |
d7b8e6c6 | 9701 | @end group |
5d67986c | 9702 | @end smallexample |
d7b8e6c6 | 9703 | @noindent |
d7b8e6c6 | 9704 | @smallexample |
5d67986c | 9705 | @group |
d7b8e6c6 EZ |
9706 | 3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892 |
9707 | 2: -0.5749 2: -0.5772 1: 0 . | |
9708 | 1: 2.3148e-3 1: -0.5749 . | |
9709 | . . | |
9710 | ||
5d67986c | 9711 | @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x ) |
d7b8e6c6 | 9712 | @end group |
5d67986c | 9713 | @end smallexample |
d7b8e6c6 | 9714 | |
a4231b04 | 9715 | This is the value of |
8e04863e | 9716 | @texline @math{-\gamma}, |
a4231b04 JB |
9717 | @infoline @expr{- gamma}, |
9718 | with a slight bit of roundoff error. To get a full 12 digits, let's use | |
9719 | a higher precision: | |
d7b8e6c6 | 9720 | |
d7b8e6c6 | 9721 | @smallexample |
5d67986c | 9722 | @group |
d7b8e6c6 EZ |
9723 | 2: -0.577215664892 2: -0.577215664892 |
9724 | 1: 1. 1: -0.577215664901532 | |
9725 | ||
5d67986c | 9726 | 1. @key{RET} p 16 @key{RET} X |
d7b8e6c6 | 9727 | @end group |
5d67986c | 9728 | @end smallexample |
d7b8e6c6 EZ |
9729 | |
9730 | Here's the complete sequence of keystrokes: | |
9731 | ||
d7b8e6c6 | 9732 | @example |
5d67986c | 9733 | @group |
d7b8e6c6 | 9734 | C-x ( Z ` s 1 0 t 2 |
5d67986c | 9735 | @key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ] |
d7b8e6c6 | 9736 | L r 1 2 * & - r 2 - |
5d67986c RS |
9737 | 2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * / |
9738 | @key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / | |
d7b8e6c6 EZ |
9739 | 2 Z ) |
9740 | Z ' | |
9741 | C-x ) | |
d7b8e6c6 | 9742 | @end group |
5d67986c | 9743 | @end example |
d7b8e6c6 EZ |
9744 | |
9745 | @node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises | |
9746 | @subsection Programming Tutorial Exercise 10 | |
9747 | ||
9748 | @noindent | |
a4231b04 JB |
9749 | Taking the derivative of a term of the form @expr{x^n} will produce |
9750 | a term like | |
8e04863e | 9751 | @texline @math{n x^{n-1}}. |
a4231b04 JB |
9752 | @infoline @expr{n x^(n-1)}. |
9753 | Taking the derivative of a constant | |
9754 | produces zero. From this it is easy to see that the @expr{n}th | |
9755 | derivative of a polynomial, evaluated at @expr{x = 0}, will equal the | |
9756 | coefficient on the @expr{x^n} term times @expr{n!}. | |
d7b8e6c6 EZ |
9757 | |
9758 | (Because this definition is long, it will be repeated in concise form | |
58547c3e | 9759 | below. You can use @w{@kbd{C-x * m}} to load it from there. While you are |
d7b8e6c6 EZ |
9760 | entering a @kbd{Z ` Z '} body in a macro, Calc simply collects |
9761 | keystrokes without executing them. In the following diagrams we'll | |
9762 | pretend Calc actually executed the keystrokes as you typed them, | |
9763 | just for purposes of illustration.) | |
9764 | ||
d7b8e6c6 | 9765 | @smallexample |
5d67986c | 9766 | @group |
d7b8e6c6 EZ |
9767 | 2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2 |
9768 | 1: 6 2: 0 | |
9769 | . 1: 6 | |
9770 | . | |
9771 | ||
5d67986c | 9772 | ' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB} |
d7b8e6c6 | 9773 | @end group |
5d67986c | 9774 | @end smallexample |
d7b8e6c6 EZ |
9775 | |
9776 | @noindent | |
9777 | Variable 1 will accumulate the vector of coefficients. | |
9778 | ||
d7b8e6c6 | 9779 | @smallexample |
5d67986c | 9780 | @group |
d7b8e6c6 EZ |
9781 | 2: 0 3: 0 2: 5 x^4 + ... |
9782 | 1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1 | |
9783 | . 1: 1 . | |
9784 | . | |
9785 | ||
5d67986c | 9786 | Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1 |
d7b8e6c6 | 9787 | @end group |
5d67986c | 9788 | @end smallexample |
d7b8e6c6 EZ |
9789 | |
9790 | @noindent | |
9791 | Note that @kbd{s | 1} appends the top-of-stack value to the vector | |
9792 | in a variable; it is completely analogous to @kbd{s + 1}. We could | |
5d67986c | 9793 | have written instead, @kbd{r 1 @key{TAB} | t 1}. |
d7b8e6c6 | 9794 | |
d7b8e6c6 | 9795 | @smallexample |
5d67986c | 9796 | @group |
d7b8e6c6 EZ |
9797 | 1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0] |
9798 | . . . | |
9799 | ||
5d67986c | 9800 | a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x ) |
d7b8e6c6 | 9801 | @end group |
5d67986c | 9802 | @end smallexample |
d7b8e6c6 EZ |
9803 | |
9804 | To convert back, a simple method is just to map the coefficients | |
a4231b04 | 9805 | against a table of powers of @expr{x}. |
d7b8e6c6 | 9806 | |
d7b8e6c6 | 9807 | @smallexample |
5d67986c | 9808 | @group |
d7b8e6c6 EZ |
9809 | 2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0] |
9810 | 1: 6 1: [0, 1, 2, 3, 4, 5, 6] | |
9811 | . . | |
9812 | ||
5d67986c | 9813 | 6 @key{RET} 1 + 0 @key{RET} 1 C-u v x |
d7b8e6c6 | 9814 | |
d7b8e6c6 | 9815 | @end group |
5d67986c | 9816 | @end smallexample |
d7b8e6c6 | 9817 | @noindent |
d7b8e6c6 | 9818 | @smallexample |
5d67986c | 9819 | @group |
d7b8e6c6 EZ |
9820 | 2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4 |
9821 | 1: [1, x, x^2, x^3, ... ] . | |
9822 | . | |
9823 | ||
5d67986c | 9824 | ' x @key{RET} @key{TAB} V M ^ * |
d7b8e6c6 | 9825 | @end group |
5d67986c | 9826 | @end smallexample |
d7b8e6c6 EZ |
9827 | |
9828 | Once again, here are the whole polynomial to/from vector programs: | |
9829 | ||
d7b8e6c6 | 9830 | @example |
5d67986c RS |
9831 | @group |
9832 | C-x ( Z ` [ ] t 1 0 @key{TAB} | |
9833 | Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1 | |
9834 | a d x @key{RET} | |
d7b8e6c6 EZ |
9835 | 1 Z ) r 1 |
9836 | Z ' | |
9837 | C-x ) | |
9838 | ||
5d67986c | 9839 | C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x ) |
d7b8e6c6 | 9840 | @end group |
5d67986c | 9841 | @end example |
d7b8e6c6 EZ |
9842 | |
9843 | @node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises | |
9844 | @subsection Programming Tutorial Exercise 11 | |
9845 | ||
9846 | @noindent | |
9847 | First we define a dummy program to go on the @kbd{z s} key. The true | |
9848 | @w{@kbd{z s}} key is supposed to take two numbers from the stack and | |
5d67986c | 9849 | return one number, so @key{DEL} as a dummy definition will make |
d7b8e6c6 EZ |
9850 | sure the stack comes out right. |
9851 | ||
d7b8e6c6 | 9852 | @smallexample |
5d67986c | 9853 | @group |
d7b8e6c6 EZ |
9854 | 2: 4 1: 4 2: 4 |
9855 | 1: 2 . 1: 2 | |
9856 | . . | |
9857 | ||
5d67986c | 9858 | 4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2 |
d7b8e6c6 | 9859 | @end group |
5d67986c | 9860 | @end smallexample |
d7b8e6c6 EZ |
9861 | |
9862 | The last step replaces the 2 that was eaten during the creation | |
9863 | of the dummy @kbd{z s} command. Now we move on to the real | |
9864 | definition. The recurrence needs to be rewritten slightly, | |
a4231b04 | 9865 | to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}. |
d7b8e6c6 EZ |
9866 | |
9867 | (Because this definition is long, it will be repeated in concise form | |
58547c3e | 9868 | below. You can use @kbd{C-x * m} to load it from there.) |
d7b8e6c6 | 9869 | |
d7b8e6c6 | 9870 | @smallexample |
5d67986c | 9871 | @group |
d7b8e6c6 EZ |
9872 | 2: 4 4: 4 3: 4 2: 4 |
9873 | 1: 2 3: 2 2: 2 1: 2 | |
9874 | . 2: 4 1: 0 . | |
9875 | 1: 2 . | |
9876 | . | |
9877 | ||
5d67986c | 9878 | C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z : |
d7b8e6c6 | 9879 | |
d7b8e6c6 | 9880 | @end group |
5d67986c | 9881 | @end smallexample |
d7b8e6c6 | 9882 | @noindent |
d7b8e6c6 | 9883 | @smallexample |
5d67986c | 9884 | @group |
d7b8e6c6 EZ |
9885 | 4: 4 2: 4 2: 3 4: 3 4: 3 3: 3 |
9886 | 3: 2 1: 2 1: 2 3: 2 3: 2 2: 2 | |
9887 | 2: 2 . . 2: 3 2: 3 1: 3 | |
9888 | 1: 0 1: 2 1: 1 . | |
9889 | . . . | |
9890 | ||
5d67986c | 9891 | @key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s |
d7b8e6c6 | 9892 | @end group |
5d67986c | 9893 | @end smallexample |
d7b8e6c6 EZ |
9894 | |
9895 | @noindent | |
9896 | (Note that the value 3 that our dummy @kbd{z s} produces is not correct; | |
9897 | it is merely a placeholder that will do just as well for now.) | |
9898 | ||
d7b8e6c6 | 9899 | @smallexample |
5d67986c | 9900 | @group |
d7b8e6c6 EZ |
9901 | 3: 3 4: 3 3: 3 2: 3 1: -6 |
9902 | 2: 3 3: 3 2: 3 1: 9 . | |
9903 | 1: 2 2: 3 1: 3 . | |
9904 | . 1: 2 . | |
9905 | . | |
9906 | ||
5d67986c | 9907 | M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * - |
d7b8e6c6 | 9908 | |
d7b8e6c6 | 9909 | @end group |
5d67986c | 9910 | @end smallexample |
d7b8e6c6 | 9911 | @noindent |
d7b8e6c6 | 9912 | @smallexample |
5d67986c | 9913 | @group |
d7b8e6c6 EZ |
9914 | 1: -6 2: 4 1: 11 2: 11 |
9915 | . 1: 2 . 1: 11 | |
9916 | . . | |
9917 | ||
5d67986c | 9918 | Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s |
d7b8e6c6 | 9919 | @end group |
5d67986c | 9920 | @end smallexample |
d7b8e6c6 EZ |
9921 | |
9922 | Even though the result that we got during the definition was highly | |
9923 | bogus, once the definition is complete the @kbd{z s} command gets | |
9924 | the right answers. | |
9925 | ||
9926 | Here's the full program once again: | |
9927 | ||
d7b8e6c6 | 9928 | @example |
5d67986c RS |
9929 | @group |
9930 | C-x ( M-2 @key{RET} a = | |
9931 | Z [ @key{DEL} @key{DEL} 1 | |
9932 | Z : @key{RET} 0 a = | |
9933 | Z [ @key{DEL} @key{DEL} 0 | |
9934 | Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s | |
9935 | M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * - | |
d7b8e6c6 EZ |
9936 | Z ] |
9937 | Z ] | |
9938 | C-x ) | |
d7b8e6c6 | 9939 | @end group |
5d67986c | 9940 | @end example |
d7b8e6c6 | 9941 | |
58547c3e | 9942 | You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro}) |
d7b8e6c6 EZ |
9943 | followed by @kbd{Z K s}, without having to make a dummy definition |
9944 | first, because @code{read-kbd-macro} doesn't need to execute the | |
58547c3e | 9945 | definition as it reads it in. For this reason, @code{C-x * m} is often |
d7b8e6c6 EZ |
9946 | the easiest way to create recursive programs in Calc. |
9947 | ||
9948 | @node Programming Answer 12, , Programming Answer 11, Answers to Exercises | |
9949 | @subsection Programming Tutorial Exercise 12 | |
9950 | ||
9951 | @noindent | |
9952 | This turns out to be a much easier way to solve the problem. Let's | |
9953 | denote Stirling numbers as calls of the function @samp{s}. | |
9954 | ||
9955 | First, we store the rewrite rules corresponding to the definition of | |
9956 | Stirling numbers in a convenient variable: | |
9957 | ||
9958 | @smallexample | |
5d67986c | 9959 | s e StirlingRules @key{RET} |
d7b8e6c6 EZ |
9960 | [ s(n,n) := 1 :: n >= 0, |
9961 | s(n,0) := 0 :: n > 0, | |
9962 | s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ] | |
9963 | C-c C-c | |
9964 | @end smallexample | |
9965 | ||
9966 | Now, it's just a matter of applying the rules: | |
9967 | ||
d7b8e6c6 | 9968 | @smallexample |
5d67986c | 9969 | @group |
d7b8e6c6 EZ |
9970 | 2: 4 1: s(4, 2) 1: 11 |
9971 | 1: 2 . . | |
9972 | . | |
9973 | ||
5d67986c | 9974 | 4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x ) |
d7b8e6c6 | 9975 | @end group |
5d67986c | 9976 | @end smallexample |
d7b8e6c6 EZ |
9977 | |
9978 | As in the case of the @code{fib} rules, it would be useful to put these | |
9979 | rules in @code{EvalRules} and to add a @samp{:: remember} condition to | |
9980 | the last rule. | |
9981 | ||
9982 | @c This ends the table-of-contents kludge from above: | |
9983 | @tex | |
9984 | \global\let\chapternofonts=\oldchapternofonts | |
9985 | @end tex | |
9986 | ||
9987 | @c [reference] | |
9988 | ||
9989 | @node Introduction, Data Types, Tutorial, Top | |
9990 | @chapter Introduction | |
9991 | ||
9992 | @noindent | |
9993 | This chapter is the beginning of the Calc reference manual. | |
9994 | It covers basic concepts such as the stack, algebraic and | |
9995 | numeric entry, undo, numeric prefix arguments, etc. | |
9996 | ||
9997 | @c [when-split] | |
9998 | @c (Chapter 2, the Tutorial, has been printed in a separate volume.) | |
9999 | ||
10000 | @menu | |
10001 | * Basic Commands:: | |
10002 | * Help Commands:: | |
10003 | * Stack Basics:: | |
10004 | * Numeric Entry:: | |
10005 | * Algebraic Entry:: | |
10006 | * Quick Calculator:: | |
d7b8e6c6 EZ |
10007 | * Prefix Arguments:: |
10008 | * Undo:: | |
10009 | * Error Messages:: | |
10010 | * Multiple Calculators:: | |
10011 | * Troubleshooting Commands:: | |
10012 | @end menu | |
10013 | ||
10014 | @node Basic Commands, Help Commands, Introduction, Introduction | |
10015 | @section Basic Commands | |
10016 | ||
10017 | @noindent | |
10018 | @pindex calc | |
10019 | @pindex calc-mode | |
10020 | @cindex Starting the Calculator | |
10021 | @cindex Running the Calculator | |
10022 | To start the Calculator in its standard interface, type @kbd{M-x calc}. | |
10023 | By default this creates a pair of small windows, @samp{*Calculator*} | |
10024 | and @samp{*Calc Trail*}. The former displays the contents of the | |
10025 | Calculator stack and is manipulated exclusively through Calc commands. | |
10026 | It is possible (though not usually necessary) to create several Calc | |
07ce2eb3 | 10027 | mode buffers each of which has an independent stack, undo list, and |
d7b8e6c6 EZ |
10028 | mode settings. There is exactly one Calc Trail buffer; it records a |
10029 | list of the results of all calculations that have been done. The | |
07ce2eb3 | 10030 | Calc Trail buffer uses a variant of Calc mode, so Calculator commands |
d7b8e6c6 EZ |
10031 | still work when the trail buffer's window is selected. It is possible |
10032 | to turn the trail window off, but the @samp{*Calc Trail*} buffer itself | |
a4231b04 | 10033 | still exists and is updated silently. @xref{Trail Commands}. |
d7b8e6c6 | 10034 | |
58547c3e JB |
10035 | @kindex C-x * c |
10036 | @kindex C-x * * | |
5d67986c RS |
10037 | @ignore |
10038 | @mindex @null | |
10039 | @end ignore | |
58547c3e JB |
10040 | In most installations, the @kbd{C-x * c} key sequence is a more |
10041 | convenient way to start the Calculator. Also, @kbd{C-x * *} | |
10042 | is a synonym for @kbd{C-x * c} unless you last used Calc | |
07ce2eb3 | 10043 | in its Keypad mode. |
d7b8e6c6 EZ |
10044 | |
10045 | @kindex x | |
10046 | @kindex M-x | |
10047 | @pindex calc-execute-extended-command | |
10048 | Most Calc commands use one or two keystrokes. Lower- and upper-case | |
10049 | letters are distinct. Commands may also be entered in full @kbd{M-x} form; | |
10050 | for some commands this is the only form. As a convenience, the @kbd{x} | |
10051 | key (@code{calc-execute-extended-command}) | |
10052 | is like @kbd{M-x} except that it enters the initial string @samp{calc-} | |
10053 | for you. For example, the following key sequences are equivalent: | |
a4231b04 | 10054 | @kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}. |
d7b8e6c6 EZ |
10055 | |
10056 | @cindex Extensions module | |
10057 | @cindex @file{calc-ext} module | |
58547c3e | 10058 | The Calculator exists in many parts. When you type @kbd{C-x * c}, the |
d7b8e6c6 EZ |
10059 | Emacs ``auto-load'' mechanism will bring in only the first part, which |
10060 | contains the basic arithmetic functions. The other parts will be | |
10061 | auto-loaded the first time you use the more advanced commands like trig | |
10062 | functions or matrix operations. This is done to improve the response time | |
10063 | of the Calculator in the common case when all you need to do is a | |
10064 | little arithmetic. If for some reason the Calculator fails to load an | |
10065 | extension module automatically, you can force it to load all the | |
58547c3e | 10066 | extensions by using the @kbd{C-x * L} (@code{calc-load-everything}) |
a4231b04 | 10067 | command. @xref{Mode Settings}. |
d7b8e6c6 | 10068 | |
58547c3e | 10069 | If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument, |
d7b8e6c6 EZ |
10070 | the Calculator is loaded if necessary, but it is not actually started. |
10071 | If the argument is positive, the @file{calc-ext} extensions are also | |
10072 | loaded if necessary. User-written Lisp code that wishes to make use | |
10073 | of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)} | |
a4231b04 | 10074 | to auto-load the Calculator. |
d7b8e6c6 | 10075 | |
58547c3e | 10076 | @kindex C-x * b |
d7b8e6c6 | 10077 | @pindex full-calc |
58547c3e | 10078 | If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you |
d7b8e6c6 | 10079 | will get a Calculator that uses the full height of the Emacs screen. |
58547c3e | 10080 | When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc} |
d7b8e6c6 EZ |
10081 | command instead of @code{calc}. From the Unix shell you can type |
10082 | @samp{emacs -f full-calc} to start a new Emacs specifically for use | |
10083 | as a calculator. When Calc is started from the Emacs command line | |
10084 | like this, Calc's normal ``quit'' commands actually quit Emacs itself. | |
10085 | ||
58547c3e | 10086 | @kindex C-x * o |
d7b8e6c6 | 10087 | @pindex calc-other-window |
58547c3e | 10088 | The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc |
d7b8e6c6 | 10089 | window is not actually selected. If you are already in the Calc |
58547c3e | 10090 | window, @kbd{C-x * o} switches you out of it. (The regular Emacs |
d7b8e6c6 EZ |
10091 | @kbd{C-x o} command would also work for this, but it has a |
10092 | tendency to drop you into the Calc Trail window instead, which | |
58547c3e | 10093 | @kbd{C-x * o} takes care not to do.) |
d7b8e6c6 | 10094 | |
5d67986c | 10095 | @ignore |
58547c3e | 10096 | @mindex C-x * q |
5d67986c | 10097 | @end ignore |
58547c3e | 10098 | For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc}) |
d7b8e6c6 EZ |
10099 | which prompts you for a formula (like @samp{2+3/4}). The result is |
10100 | displayed at the bottom of the Emacs screen without ever creating | |
10101 | any special Calculator windows. @xref{Quick Calculator}. | |
10102 | ||
5d67986c | 10103 | @ignore |
58547c3e | 10104 | @mindex C-x * k |
5d67986c | 10105 | @end ignore |
d7b8e6c6 | 10106 | Finally, if you are using the X window system you may want to try |
58547c3e | 10107 | @kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a |
d7b8e6c6 EZ |
10108 | ``calculator keypad'' picture as well as a stack display. Click on |
10109 | the keys with the mouse to operate the calculator. @xref{Keypad Mode}. | |
10110 | ||
10111 | @kindex q | |
10112 | @pindex calc-quit | |
10113 | @cindex Quitting the Calculator | |
10114 | @cindex Exiting the Calculator | |
07ce2eb3 | 10115 | The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the |
d7b8e6c6 EZ |
10116 | Calculator's window(s). It does not delete the Calculator buffers. |
10117 | If you type @kbd{M-x calc} again, the Calculator will reappear with the | |
58547c3e | 10118 | contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *} |
d7b8e6c6 | 10119 | again from inside the Calculator buffer is equivalent to executing |
58547c3e | 10120 | @code{calc-quit}; you can think of @kbd{C-x * *} as toggling the |
a4231b04 | 10121 | Calculator on and off. |
d7b8e6c6 | 10122 | |
58547c3e JB |
10123 | @kindex C-x * x |
10124 | The @kbd{C-x * x} command also turns the Calculator off, no matter which | |
d7b8e6c6 EZ |
10125 | user interface (standard, Keypad, or Embedded) is currently active. |
10126 | It also cancels @code{calc-edit} mode if used from there. | |
10127 | ||
5d67986c | 10128 | @kindex d @key{SPC} |
d7b8e6c6 EZ |
10129 | @pindex calc-refresh |
10130 | @cindex Refreshing a garbled display | |
10131 | @cindex Garbled displays, refreshing | |
5d67986c | 10132 | The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents |
d7b8e6c6 EZ |
10133 | of the Calculator buffer from memory. Use this if the contents of the |
10134 | buffer have been damaged somehow. | |
10135 | ||
5d67986c RS |
10136 | @ignore |
10137 | @mindex o | |
10138 | @end ignore | |
d7b8e6c6 EZ |
10139 | The @kbd{o} key (@code{calc-realign}) moves the cursor back to its |
10140 | ``home'' position at the bottom of the Calculator buffer. | |
10141 | ||
10142 | @kindex < | |
10143 | @kindex > | |
10144 | @pindex calc-scroll-left | |
10145 | @pindex calc-scroll-right | |
10146 | @cindex Horizontal scrolling | |
10147 | @cindex Scrolling | |
10148 | @cindex Wide text, scrolling | |
10149 | The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and | |
10150 | @code{calc-scroll-right}. These are just like the normal horizontal | |
10151 | scrolling commands except that they scroll one half-screen at a time by | |
10152 | default. (Calc formats its output to fit within the bounds of the | |
a4231b04 | 10153 | window whenever it can.) |
d7b8e6c6 EZ |
10154 | |
10155 | @kindex @{ | |
10156 | @kindex @} | |
10157 | @pindex calc-scroll-down | |
10158 | @pindex calc-scroll-up | |
10159 | @cindex Vertical scrolling | |
10160 | The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down} | |
10161 | and @code{calc-scroll-up}. They scroll up or down by one-half the | |
a4231b04 | 10162 | height of the Calc window. |
d7b8e6c6 | 10163 | |
58547c3e | 10164 | @kindex C-x * 0 |
d7b8e6c6 | 10165 | @pindex calc-reset |
58547c3e | 10166 | The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed |
d7347600 JB |
10167 | by a zero) resets the Calculator to its initial state. This clears |
10168 | the stack, resets all the modes to their initial values (the values | |
10169 | that were saved with @kbd{m m} (@code{calc-save-modes})), clears the | |
10170 | caches (@pxref{Caches}), and so on. (It does @emph{not} erase the | |
10171 | values of any variables.) With an argument of 0, Calc will be reset to | |
10172 | its default state; namely, the modes will be given their default values. | |
58547c3e | 10173 | With a positive prefix argument, @kbd{C-x * 0} preserves the contents of |
d7347600 | 10174 | the stack but resets everything else to its initial state; with a |
58547c3e | 10175 | negative prefix argument, @kbd{C-x * 0} preserves the contents of the |
d7347600 | 10176 | stack but resets everything else to its default state. |
d7b8e6c6 EZ |
10177 | |
10178 | @pindex calc-version | |
10179 | The @kbd{M-x calc-version} command displays the current version number | |
10180 | of Calc and the name of the person who installed it on your system. | |
10181 | (This information is also present in the @samp{*Calc Trail*} buffer, | |
10182 | and in the output of the @kbd{h h} command.) | |
10183 | ||
10184 | @node Help Commands, Stack Basics, Basic Commands, Introduction | |
10185 | @section Help Commands | |
10186 | ||
10187 | @noindent | |
10188 | @cindex Help commands | |
10189 | @kindex ? | |
10190 | @pindex calc-help | |
10191 | The @kbd{?} key (@code{calc-help}) displays a series of brief help messages. | |
10192 | Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs' | |
10193 | @key{ESC} and @kbd{C-x} prefixes. You can type | |
10194 | @kbd{?} after a prefix to see a list of commands beginning with that | |
10195 | prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again | |
10196 | to see additional commands for that prefix.) | |
10197 | ||
10198 | @kindex h h | |
10199 | @pindex calc-full-help | |
10200 | The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?} | |
10201 | responses at once. When printed, this makes a nice, compact (three pages) | |
10202 | summary of Calc keystrokes. | |
10203 | ||
10204 | In general, the @kbd{h} key prefix introduces various commands that | |
10205 | provide help within Calc. Many of the @kbd{h} key functions are | |
10206 | Calc-specific analogues to the @kbd{C-h} functions for Emacs help. | |
10207 | ||
10208 | @kindex h i | |
58547c3e | 10209 | @kindex C-x * i |
d7b8e6c6 EZ |
10210 | @kindex i |
10211 | @pindex calc-info | |
10212 | The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system | |
10213 | to read this manual on-line. This is basically the same as typing | |
10214 | @kbd{C-h i} (the regular way to run the Info system), then, if Info | |
10215 | is not already in the Calc manual, selecting the beginning of the | |
58547c3e | 10216 | manual. The @kbd{C-x * i} command is another way to read the Calc |
d7b8e6c6 EZ |
10217 | manual; it is different from @kbd{h i} in that it works any time, |
10218 | not just inside Calc. The plain @kbd{i} key is also equivalent to | |
10219 | @kbd{h i}, though this key is obsolete and may be replaced with a | |
10220 | different command in a future version of Calc. | |
10221 | ||
10222 | @kindex h t | |
58547c3e | 10223 | @kindex C-x * t |
d7b8e6c6 EZ |
10224 | @pindex calc-tutorial |
10225 | The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on | |
10226 | the Tutorial section of the Calc manual. It is like @kbd{h i}, | |
10227 | except that it selects the starting node of the tutorial rather | |
10228 | than the beginning of the whole manual. (It actually selects the | |
10229 | node ``Interactive Tutorial'' which tells a few things about | |
10230 | using the Info system before going on to the actual tutorial.) | |
58547c3e | 10231 | The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at |
d7b8e6c6 EZ |
10232 | all times). |
10233 | ||
10234 | @kindex h s | |
58547c3e | 10235 | @kindex C-x * s |
d7b8e6c6 EZ |
10236 | @pindex calc-info-summary |
10237 | The @kbd{h s} (@code{calc-info-summary}) command runs the Info system | |
58547c3e | 10238 | on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s} |
d7b8e6c6 EZ |
10239 | key is equivalent to @kbd{h s}. |
10240 | ||
10241 | @kindex h k | |
10242 | @pindex calc-describe-key | |
10243 | The @kbd{h k} (@code{calc-describe-key}) command looks up a key | |
10244 | sequence in the Calc manual. For example, @kbd{h k H a S} looks | |
10245 | up the documentation on the @kbd{H a S} (@code{calc-solve-for}) | |
10246 | command. This works by looking up the textual description of | |
10247 | the key(s) in the Key Index of the manual, then jumping to the | |
10248 | node indicated by the index. | |
10249 | ||
10250 | Most Calc commands do not have traditional Emacs documentation | |
10251 | strings, since the @kbd{h k} command is both more convenient and | |
10252 | more instructive. This means the regular Emacs @kbd{C-h k} | |
10253 | (@code{describe-key}) command will not be useful for Calc keystrokes. | |
10254 | ||
10255 | @kindex h c | |
10256 | @pindex calc-describe-key-briefly | |
10257 | The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a | |
10258 | key sequence and displays a brief one-line description of it at | |
10259 | the bottom of the screen. It looks for the key sequence in the | |
10260 | Summary node of the Calc manual; if it doesn't find the sequence | |
10261 | there, it acts just like its regular Emacs counterpart @kbd{C-h c} | |
10262 | (@code{describe-key-briefly}). For example, @kbd{h c H a S} | |
10263 | gives the description: | |
10264 | ||
10265 | @smallexample | |
10266 | H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes) | |
10267 | @end smallexample | |
10268 | ||
10269 | @noindent | |
10270 | which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for} | |
a4231b04 | 10271 | takes a value @expr{a} from the stack, prompts for a value @expr{v}, |
d7b8e6c6 EZ |
10272 | then applies the algebraic function @code{fsolve} to these values. |
10273 | The @samp{?=notes} message means you can now type @kbd{?} to see | |
10274 | additional notes from the summary that apply to this command. | |
10275 | ||
10276 | @kindex h f | |
10277 | @pindex calc-describe-function | |
10278 | The @kbd{h f} (@code{calc-describe-function}) command looks up an | |
b1848006 | 10279 | algebraic function or a command name in the Calc manual. Enter an |
d7b8e6c6 | 10280 | algebraic function name to look up that function in the Function |
b1848006 JB |
10281 | Index or enter a command name beginning with @samp{calc-} to look it |
10282 | up in the Command Index. This command will also look up operator | |
10283 | symbols that can appear in algebraic formulas, like @samp{%} and | |
10284 | @samp{=>}. | |
d7b8e6c6 EZ |
10285 | |
10286 | @kindex h v | |
10287 | @pindex calc-describe-variable | |
10288 | The @kbd{h v} (@code{calc-describe-variable}) command looks up a | |
b1848006 | 10289 | variable in the Calc manual. Enter a variable name like @code{pi} or |
d7b8e6c6 EZ |
10290 | @code{PlotRejects}. |
10291 | ||
10292 | @kindex h b | |
10293 | @pindex describe-bindings | |
10294 | The @kbd{h b} (@code{calc-describe-bindings}) command is just like | |
10295 | @kbd{C-h b}, except that only local (Calc-related) key bindings are | |
10296 | listed. | |
10297 | ||
10298 | @kindex h n | |
10299 | The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays | |
10300 | the ``news'' or change history of Calc. This is kept in the file | |
10301 | @file{README}, which Calc looks for in the same directory as the Calc | |
10302 | source files. | |
10303 | ||
10304 | @kindex h C-c | |
10305 | @kindex h C-d | |
10306 | @kindex h C-w | |
10307 | The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying, | |
10308 | distribution, and warranty information about Calc. These work by | |
10309 | pulling up the appropriate parts of the ``Copying'' or ``Reporting | |
10310 | Bugs'' sections of the manual. | |
10311 | ||
10312 | @node Stack Basics, Numeric Entry, Help Commands, Introduction | |
10313 | @section Stack Basics | |
10314 | ||
10315 | @noindent | |
10316 | @cindex Stack basics | |
10317 | @c [fix-tut RPN Calculations and the Stack] | |
28665d46 | 10318 | Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN |
d7b8e6c6 EZ |
10319 | Tutorial}. |
10320 | ||
10321 | To add the numbers 1 and 2 in Calc you would type the keys: | |
10322 | @kbd{1 @key{RET} 2 +}. | |
10323 | (@key{RET} corresponds to the @key{ENTER} key on most calculators.) | |
10324 | The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The | |
10325 | @kbd{+} key always ``pops'' the top two numbers from the stack, adds them, | |
10326 | and pushes the result (3) back onto the stack. This number is ready for | |
10327 | further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the | |
8e04863e | 10328 | 3 and 5, subtracts them, and pushes the result (@mathit{-2}). |
d7b8e6c6 EZ |
10329 | |
10330 | Note that the ``top'' of the stack actually appears at the @emph{bottom} | |
10331 | of the buffer. A line containing a single @samp{.} character signifies | |
10332 | the end of the buffer; Calculator commands operate on the number(s) | |
10333 | directly above this line. The @kbd{d t} (@code{calc-truncate-stack}) | |
10334 | command allows you to move the @samp{.} marker up and down in the stack; | |
10335 | @pxref{Truncating the Stack}. | |
10336 | ||
10337 | @kindex d l | |
10338 | @pindex calc-line-numbering | |
10339 | Stack elements are numbered consecutively, with number 1 being the top of | |
10340 | the stack. These line numbers are ordinarily displayed on the lefthand side | |
10341 | of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls | |
10342 | whether these numbers appear. (Line numbers may be turned off since they | |
10343 | slow the Calculator down a bit and also clutter the display.) | |
10344 | ||
10345 | @kindex o | |
10346 | @pindex calc-realign | |
10347 | The unshifted letter @kbd{o} (@code{calc-realign}) command repositions | |
10348 | the cursor to its top-of-stack ``home'' position. It also undoes any | |
10349 | horizontal scrolling in the window. If you give it a numeric prefix | |
10350 | argument, it instead moves the cursor to the specified stack element. | |
10351 | ||
10352 | The @key{RET} (or equivalent @key{SPC}) key is only required to separate | |
10353 | two consecutive numbers. | |
10354 | (After all, if you typed @kbd{1 2} by themselves the Calculator | |
5d67986c | 10355 | would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not} |
d7b8e6c6 | 10356 | right after typing a number, the key duplicates the number on the top of |
a4231b04 | 10357 | the stack. @kbd{@key{RET} *} is thus a handy way to square a number. |
d7b8e6c6 EZ |
10358 | |
10359 | The @key{DEL} key pops and throws away the top number on the stack. | |
10360 | The @key{TAB} key swaps the top two objects on the stack. | |
10361 | @xref{Stack and Trail}, for descriptions of these and other stack-related | |
a4231b04 | 10362 | commands. |
d7b8e6c6 EZ |
10363 | |
10364 | @node Numeric Entry, Algebraic Entry, Stack Basics, Introduction | |
10365 | @section Numeric Entry | |
10366 | ||
10367 | @noindent | |
10368 | @kindex 0-9 | |
10369 | @kindex . | |
10370 | @kindex e | |
10371 | @cindex Numeric entry | |
10372 | @cindex Entering numbers | |
10373 | Pressing a digit or other numeric key begins numeric entry using the | |
10374 | minibuffer. The number is pushed on the stack when you press the @key{RET} | |
10375 | or @key{SPC} keys. If you press any other non-numeric key, the number is | |
10376 | pushed onto the stack and the appropriate operation is performed. If | |
10377 | you press a numeric key which is not valid, the key is ignored. | |
10378 | ||
10379 | @cindex Minus signs | |
10380 | @cindex Negative numbers, entering | |
10381 | @kindex _ | |
10382 | There are three different concepts corresponding to the word ``minus,'' | |
a4231b04 JB |
10383 | typified by @expr{a-b} (subtraction), @expr{-x} |
10384 | (change-sign), and @expr{-5} (negative number). Calc uses three | |
d7b8e6c6 EZ |
10385 | different keys for these operations, respectively: |
10386 | @kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts | |
10387 | the two numbers on the top of the stack. The @kbd{n} key changes the sign | |
10388 | of the number on the top of the stack or the number currently being entered. | |
10389 | The @kbd{_} key begins entry of a negative number or changes the sign of | |
10390 | the number currently being entered. The following sequences all enter the | |
8e04863e | 10391 | number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}}, |
a4231b04 | 10392 | @kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}. |
d7b8e6c6 EZ |
10393 | |
10394 | Some other keys are active during numeric entry, such as @kbd{#} for | |
10395 | non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms. | |
10396 | These notations are described later in this manual with the corresponding | |
10397 | data types. @xref{Data Types}. | |
10398 | ||
5d67986c | 10399 | During numeric entry, the only editing key available is @key{DEL}. |
d7b8e6c6 EZ |
10400 | |
10401 | @node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction | |
10402 | @section Algebraic Entry | |
10403 | ||
10404 | @noindent | |
10405 | @kindex ' | |
10406 | @pindex calc-algebraic-entry | |
10407 | @cindex Algebraic notation | |
10408 | @cindex Formulas, entering | |
10409 | Calculations can also be entered in algebraic form. This is accomplished | |
10410 | by typing the apostrophe key, @kbd{'}, followed by the expression in | |
10411 | standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes | |
8e04863e | 10412 | @texline @math{2+(3\times4) = 14} |
a4231b04 JB |
10413 | @infoline @expr{2+(3*4) = 14} |
10414 | and pushes that on the stack. If you wish you can | |
d7b8e6c6 EZ |
10415 | ignore the RPN aspect of Calc altogether and simply enter algebraic |
10416 | expressions in this way. You may want to use @key{DEL} every so often to | |
a4231b04 | 10417 | clear previous results off the stack. |
d7b8e6c6 EZ |
10418 | |
10419 | You can press the apostrophe key during normal numeric entry to switch | |
07ce2eb3 | 10420 | the half-entered number into Algebraic entry mode. One reason to do this |
d7b8e6c6 EZ |
10421 | would be to use the full Emacs cursor motion and editing keys, which are |
10422 | available during algebraic entry but not during numeric entry. | |
10423 | ||
10424 | In the same vein, during either numeric or algebraic entry you can | |
10425 | press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where | |
10426 | you complete your half-finished entry in a separate buffer. | |
10427 | @xref{Editing Stack Entries}. | |
10428 | ||
10429 | @kindex m a | |
10430 | @pindex calc-algebraic-mode | |
07ce2eb3 | 10431 | @cindex Algebraic Mode |
d7b8e6c6 EZ |
10432 | If you prefer algebraic entry, you can use the command @kbd{m a} |
10433 | (@code{calc-algebraic-mode}) to set Algebraic mode. In this mode, | |
10434 | digits and other keys that would normally start numeric entry instead | |
10435 | start full algebraic entry; as long as your formula begins with a digit | |
10436 | you can omit the apostrophe. Open parentheses and square brackets also | |
10437 | begin algebraic entry. You can still do RPN calculations in this mode, | |
10438 | but you will have to press @key{RET} to terminate every number: | |
10439 | @kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same | |
a4231b04 | 10440 | thing as @kbd{2*3+4 @key{RET}}. |
d7b8e6c6 | 10441 | |
07ce2eb3 | 10442 | @cindex Incomplete Algebraic Mode |
d7b8e6c6 EZ |
10443 | If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a} |
10444 | command, it enables Incomplete Algebraic mode; this is like regular | |
10445 | Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys | |
10446 | only. Numeric keys still begin a numeric entry in this mode. | |
10447 | ||
10448 | @kindex m t | |
10449 | @pindex calc-total-algebraic-mode | |
07ce2eb3 | 10450 | @cindex Total Algebraic Mode |
d7b8e6c6 EZ |
10451 | The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even |
10452 | stronger algebraic-entry mode, in which @emph{all} regular letter and | |
10453 | punctuation keys begin algebraic entry. Use this if you prefer typing | |
10454 | @w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of | |
10455 | @kbd{a f}, and so on. To type regular Calc commands when you are in | |
07ce2eb3 | 10456 | Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q} |
d7b8e6c6 | 10457 | is the command to quit Calc, @kbd{M-p} sets the precision, and |
07ce2eb3 | 10458 | @kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic |
d7b8e6c6 | 10459 | mode back off again. Meta keys also terminate algebraic entry, so |
5d67986c | 10460 | that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol |
d7b8e6c6 EZ |
10461 | @samp{Alg*} will appear in the mode line whenever you are in this mode. |
10462 | ||
10463 | Pressing @kbd{'} (the apostrophe) a second time re-enters the previous | |
10464 | algebraic formula. You can then use the normal Emacs editing keys to | |
10465 | modify this formula to your liking before pressing @key{RET}. | |
10466 | ||
10467 | @kindex $ | |
10468 | @cindex Formulas, referring to stack | |
10469 | Within a formula entered from the keyboard, the symbol @kbd{$} | |
10470 | represents the number on the top of the stack. If an entered formula | |
10471 | contains any @kbd{$} characters, the Calculator replaces the top of | |
10472 | stack with that formula rather than simply pushing the formula onto the | |
10473 | stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2 | |
10474 | @key{RET}} replaces it with 6. Note that the @kbd{$} key always | |
10475 | initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the | |
a4231b04 | 10476 | first character in the new formula. |
d7b8e6c6 EZ |
10477 | |
10478 | Higher stack elements can be accessed from an entered formula with the | |
10479 | symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements | |
10480 | removed (to be replaced by the entered values) equals the number of dollar | |
10481 | signs in the longest such symbol in the formula. For example, @samp{$$+$$$} | |
10482 | adds the second and third stack elements, replacing the top three elements | |
10483 | with the answer. (All information about the top stack element is thus lost | |
a4231b04 | 10484 | since no single @samp{$} appears in this formula.) |
d7b8e6c6 EZ |
10485 | |
10486 | A slightly different way to refer to stack elements is with a dollar | |
10487 | sign followed by a number: @samp{$1}, @samp{$2}, and so on are much | |
10488 | like @samp{$}, @samp{$$}, etc., except that stack entries referred | |
10489 | to numerically are not replaced by the algebraic entry. That is, while | |
10490 | @samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5 | |
10491 | on the stack and pushes an additional 6. | |
10492 | ||
10493 | If a sequence of formulas are entered separated by commas, each formula | |
10494 | is pushed onto the stack in turn. For example, @samp{1,2,3} pushes | |
10495 | those three numbers onto the stack (leaving the 3 at the top), and | |
10496 | @samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also, | |
10497 | @samp{$,$$} exchanges the top two elements of the stack, just like the | |
10498 | @key{TAB} key. | |
10499 | ||
5d67986c | 10500 | You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead |
d7b8e6c6 EZ |
10501 | of @key{RET}. This uses @kbd{=} to evaluate the variables in each |
10502 | formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes | |
5d67986c | 10503 | the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.) |
d7b8e6c6 | 10504 | |
5d67986c | 10505 | If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j}) |
d7b8e6c6 EZ |
10506 | instead of @key{RET}, Calc disables the default simplifications |
10507 | (as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry | |
10508 | is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3 | |
a4231b04 | 10509 | on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2}; |
d7b8e6c6 EZ |
10510 | you might then press @kbd{=} when it is time to evaluate this formula. |
10511 | ||
10512 | @node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction | |
10513 | @section ``Quick Calculator'' Mode | |
10514 | ||
10515 | @noindent | |
58547c3e | 10516 | @kindex C-x * q |
d7b8e6c6 EZ |
10517 | @pindex quick-calc |
10518 | @cindex Quick Calculator | |
10519 | There is another way to invoke the Calculator if all you need to do | |
58547c3e | 10520 | is make one or two quick calculations. Type @kbd{C-x * q} (or |
d7b8e6c6 EZ |
10521 | @kbd{M-x quick-calc}), then type any formula as an algebraic entry. |
10522 | The Calculator will compute the result and display it in the echo | |
10523 | area, without ever actually putting up a Calc window. | |
10524 | ||
10525 | You can use the @kbd{$} character in a Quick Calculator formula to | |
10526 | refer to the previous Quick Calculator result. Older results are | |
10527 | not retained; the Quick Calculator has no effect on the full | |
10528 | Calculator's stack or trail. If you compute a result and then | |
58547c3e | 10529 | forget what it was, just run @code{C-x * q} again and enter |
d7b8e6c6 EZ |
10530 | @samp{$} as the formula. |
10531 | ||
10532 | If this is the first time you have used the Calculator in this Emacs | |
58547c3e | 10533 | session, the @kbd{C-x * q} command will create the @code{*Calculator*} |
d7b8e6c6 EZ |
10534 | buffer and perform all the usual initializations; it simply will |
10535 | refrain from putting that buffer up in a new window. The Quick | |
10536 | Calculator refers to the @code{*Calculator*} buffer for all mode | |
10537 | settings. Thus, for example, to set the precision that the Quick | |
10538 | Calculator uses, simply run the full Calculator momentarily and use | |
10539 | the regular @kbd{p} command. | |
10540 | ||
58547c3e | 10541 | If you use @code{C-x * q} from inside the Calculator buffer, the |
d7b8e6c6 EZ |
10542 | effect is the same as pressing the apostrophe key (algebraic entry). |
10543 | ||
10544 | The result of a Quick calculation is placed in the Emacs ``kill ring'' | |
10545 | as well as being displayed. A subsequent @kbd{C-y} command will | |
10546 | yank the result into the editing buffer. You can also use this | |
58547c3e | 10547 | to yank the result into the next @kbd{C-x * q} input line as a more |
d7b8e6c6 | 10548 | explicit alternative to @kbd{$} notation, or to yank the result |
58547c3e | 10549 | into the Calculator stack after typing @kbd{C-x * c}. |
d7b8e6c6 EZ |
10550 | |
10551 | If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead | |
10552 | of @key{RET}, the result is inserted immediately into the current | |
10553 | buffer rather than going into the kill ring. | |
10554 | ||
10555 | Quick Calculator results are actually evaluated as if by the @kbd{=} | |
10556 | key (which replaces variable names by their stored values, if any). | |
10557 | If the formula you enter is an assignment to a variable using the | |
10558 | @samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1}, | |
10559 | then the result of the evaluation is stored in that Calc variable. | |
10560 | @xref{Store and Recall}. | |
10561 | ||
10562 | If the result is an integer and the current display radix is decimal, | |
10563 | the number will also be displayed in hex and octal formats. If the | |
10564 | integer is in the range from 1 to 126, it will also be displayed as | |
10565 | an ASCII character. | |
10566 | ||
10567 | For example, the quoted character @samp{"x"} produces the vector | |
10568 | result @samp{[120]} (because 120 is the ASCII code of the lower-case | |
10569 | `x'; @pxref{Strings}). Since this is a vector, not an integer, it | |
10570 | is displayed only according to the current mode settings. But | |
10571 | running Quick Calc again and entering @samp{120} will produce the | |
10572 | result @samp{120 (16#78, 8#170, x)} which shows the number in its | |
10573 | decimal, hexadecimal, octal, and ASCII forms. | |
10574 | ||
10575 | Please note that the Quick Calculator is not any faster at loading | |
10576 | or computing the answer than the full Calculator; the name ``quick'' | |
10577 | merely refers to the fact that it's much less hassle to use for | |
10578 | small calculations. | |
10579 | ||
10580 | @node Prefix Arguments, Undo, Quick Calculator, Introduction | |
10581 | @section Numeric Prefix Arguments | |
10582 | ||
10583 | @noindent | |
10584 | Many Calculator commands use numeric prefix arguments. Some, such as | |
10585 | @kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of | |
10586 | the prefix argument or use a default if you don't use a prefix. | |
10587 | Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument | |
a4231b04 | 10588 | and prompt for a number if you don't give one as a prefix. |
d7b8e6c6 EZ |
10589 | |
10590 | As a rule, stack-manipulation commands accept a numeric prefix argument | |
10591 | which is interpreted as an index into the stack. A positive argument | |
10592 | operates on the top @var{n} stack entries; a negative argument operates | |
10593 | on the @var{n}th stack entry in isolation; and a zero argument operates | |
10594 | on the entire stack. | |
10595 | ||
10596 | Most commands that perform computations (such as the arithmetic and | |
10597 | scientific functions) accept a numeric prefix argument that allows the | |
10598 | operation to be applied across many stack elements. For unary operations | |
10599 | (that is, functions of one argument like absolute value or complex | |
10600 | conjugate), a positive prefix argument applies that function to the top | |
10601 | @var{n} stack entries simultaneously, and a negative argument applies it | |
10602 | to the @var{n}th stack entry only. For binary operations (functions of | |
10603 | two arguments like addition, GCD, and vector concatenation), a positive | |
10604 | prefix argument ``reduces'' the function across the top @var{n} | |
10605 | stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries; | |
10606 | @pxref{Reducing and Mapping}), and a negative argument maps the next-to-top | |
10607 | @var{n} stack elements with the top stack element as a second argument | |
10608 | (for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements). | |
10609 | This feature is not available for operations which use the numeric prefix | |
10610 | argument for some other purpose. | |
10611 | ||
10612 | Numeric prefixes are specified the same way as always in Emacs: Press | |
10613 | a sequence of @key{META}-digits, or press @key{ESC} followed by digits, | |
10614 | or press @kbd{C-u} followed by digits. Some commands treat plain | |
a4231b04 | 10615 | @kbd{C-u} (without any actual digits) specially. |
d7b8e6c6 EZ |
10616 | |
10617 | @kindex ~ | |
10618 | @pindex calc-num-prefix | |
10619 | You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the | |
10620 | top of the stack and enter it as the numeric prefix for the next command. | |
10621 | For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate | |
10622 | (silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2 | |
a4231b04 | 10623 | to the fourth power and set the precision to that value. |
d7b8e6c6 EZ |
10624 | |
10625 | Conversely, if you have typed a numeric prefix argument the @kbd{~} key | |
10626 | pushes it onto the stack in the form of an integer. | |
10627 | ||
10628 | @node Undo, Error Messages, Prefix Arguments, Introduction | |
10629 | @section Undoing Mistakes | |
10630 | ||
10631 | @noindent | |
10632 | @kindex U | |
10633 | @kindex C-_ | |
10634 | @pindex calc-undo | |
10635 | @cindex Mistakes, undoing | |
10636 | @cindex Undoing mistakes | |
10637 | @cindex Errors, undoing | |
10638 | The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation. | |
10639 | If that operation added or dropped objects from the stack, those objects | |
10640 | are removed or restored. If it was a ``store'' operation, you are | |
10641 | queried whether or not to restore the variable to its original value. | |
10642 | The @kbd{U} key may be pressed any number of times to undo successively | |
10643 | farther back in time; with a numeric prefix argument it undoes a | |
10644 | specified number of operations. The undo history is cleared only by the | |
58547c3e | 10645 | @kbd{q} (@code{calc-quit}) command. (Recall that @kbd{C-x * c} is |
d7b8e6c6 EZ |
10646 | synonymous with @code{calc-quit} while inside the Calculator; this |
10647 | also clears the undo history.) | |
10648 | ||
10649 | Currently the mode-setting commands (like @code{calc-precision}) are not | |
10650 | undoable. You can undo past a point where you changed a mode, but you | |
10651 | will need to reset the mode yourself. | |
10652 | ||
10653 | @kindex D | |
10654 | @pindex calc-redo | |
10655 | @cindex Redoing after an Undo | |
10656 | The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was | |
10657 | mistakenly undone. Pressing @kbd{U} with a negative prefix argument is | |
10658 | equivalent to executing @code{calc-redo}. You can redo any number of | |
10659 | times, up to the number of recent consecutive undo commands. Redo | |
10660 | information is cleared whenever you give any command that adds new undo | |
10661 | information, i.e., if you undo, then enter a number on the stack or make | |
10662 | any other change, then it will be too late to redo. | |
10663 | ||
5d67986c | 10664 | @kindex M-@key{RET} |
d7b8e6c6 EZ |
10665 | @pindex calc-last-args |
10666 | @cindex Last-arguments feature | |
10667 | @cindex Arguments, restoring | |
10668 | The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that | |
10669 | it restores the arguments of the most recent command onto the stack; | |
10670 | however, it does not remove the result of that command. Given a numeric | |
a4231b04 | 10671 | prefix argument, this command applies to the @expr{n}th most recent |
d7b8e6c6 EZ |
10672 | command which removed items from the stack; it pushes those items back |
10673 | onto the stack. | |
10674 | ||
10675 | The @kbd{K} (@code{calc-keep-args}) command provides a related function | |
10676 | to @kbd{M-@key{RET}}. @xref{Stack and Trail}. | |
10677 | ||
10678 | It is also possible to recall previous results or inputs using the trail. | |
10679 | @xref{Trail Commands}. | |
10680 | ||
10681 | The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}. | |
10682 | ||
10683 | @node Error Messages, Multiple Calculators, Undo, Introduction | |
10684 | @section Error Messages | |
10685 | ||
10686 | @noindent | |
10687 | @kindex w | |
10688 | @pindex calc-why | |
10689 | @cindex Errors, messages | |
10690 | @cindex Why did an error occur? | |
10691 | Many situations that would produce an error message in other calculators | |
10692 | simply create unsimplified formulas in the Emacs Calculator. For example, | |
a4231b04 | 10693 | @kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes |
d7b8e6c6 EZ |
10694 | the formula @samp{ln(0)}. Floating-point overflow and underflow are also |
10695 | reasons for this to happen. | |
10696 | ||
10697 | When a function call must be left in symbolic form, Calc usually | |
10698 | produces a message explaining why. Messages that are probably | |
10699 | surprising or indicative of user errors are displayed automatically. | |
10700 | Other messages are simply kept in Calc's memory and are displayed only | |
10701 | if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if | |
10702 | the same computation results in several messages. (The first message | |
10703 | will end with @samp{[w=more]} in this case.) | |
10704 | ||
10705 | @kindex d w | |
10706 | @pindex calc-auto-why | |
10707 | The @kbd{d w} (@code{calc-auto-why}) command controls when error messages | |
10708 | are displayed automatically. (Calc effectively presses @kbd{w} for you | |
10709 | after your computation finishes.) By default, this occurs only for | |
10710 | ``important'' messages. The other possible modes are to report | |
10711 | @emph{all} messages automatically, or to report none automatically (so | |
10712 | that you must always press @kbd{w} yourself to see the messages). | |
10713 | ||
10714 | @node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction | |
10715 | @section Multiple Calculators | |
10716 | ||
10717 | @noindent | |
10718 | @pindex another-calc | |
07ce2eb3 | 10719 | It is possible to have any number of Calc mode buffers at once. |
d7b8e6c6 | 10720 | Usually this is done by executing @kbd{M-x another-calc}, which |
58547c3e | 10721 | is similar to @kbd{C-x * c} except that if a @samp{*Calculator*} |
d7b8e6c6 EZ |
10722 | buffer already exists, a new, independent one with a name of the |
10723 | form @samp{*Calculator*<@var{n}>} is created. You can also use the | |
10724 | command @code{calc-mode} to put any buffer into Calculator mode, but | |
10725 | this would ordinarily never be done. | |
10726 | ||
10727 | The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer; | |
10728 | it only closes its window. Use @kbd{M-x kill-buffer} to destroy a | |
10729 | Calculator buffer. | |
10730 | ||
10731 | Each Calculator buffer keeps its own stack, undo list, and mode settings | |
10732 | such as precision, angular mode, and display formats. In Emacs terms, | |
10733 | variables such as @code{calc-stack} are buffer-local variables. The | |
10734 | global default values of these variables are used only when a new | |
10735 | Calculator buffer is created. The @code{calc-quit} command saves | |
10736 | the stack and mode settings of the buffer being quit as the new defaults. | |
10737 | ||
10738 | There is only one trail buffer, @samp{*Calc Trail*}, used by all | |
10739 | Calculator buffers. | |
10740 | ||
10741 | @node Troubleshooting Commands, , Multiple Calculators, Introduction | |
10742 | @section Troubleshooting Commands | |
10743 | ||
10744 | @noindent | |
10745 | This section describes commands you can use in case a computation | |
10746 | incorrectly fails or gives the wrong answer. | |
10747 | ||
10748 | @xref{Reporting Bugs}, if you find a problem that appears to be due | |
10749 | to a bug or deficiency in Calc. | |
10750 | ||
10751 | @menu | |
10752 | * Autoloading Problems:: | |
10753 | * Recursion Depth:: | |
10754 | * Caches:: | |
10755 | * Debugging Calc:: | |
10756 | @end menu | |
10757 | ||
10758 | @node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands | |
10759 | @subsection Autoloading Problems | |
10760 | ||
10761 | @noindent | |
10762 | The Calc program is split into many component files; components are | |
10763 | loaded automatically as you use various commands that require them. | |
10764 | Occasionally Calc may lose track of when a certain component is | |
10765 | necessary; typically this means you will type a command and it won't | |
10766 | work because some function you've never heard of was undefined. | |
10767 | ||
58547c3e | 10768 | @kindex C-x * L |
d7b8e6c6 | 10769 | @pindex calc-load-everything |
58547c3e | 10770 | If this happens, the easiest workaround is to type @kbd{C-x * L} |
d7b8e6c6 EZ |
10771 | (@code{calc-load-everything}) to force all the parts of Calc to be |
10772 | loaded right away. This will cause Emacs to take up a lot more | |
10773 | memory than it would otherwise, but it's guaranteed to fix the problem. | |
10774 | ||
d7b8e6c6 EZ |
10775 | @node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands |
10776 | @subsection Recursion Depth | |
10777 | ||
10778 | @noindent | |
10779 | @kindex M | |
10780 | @kindex I M | |
10781 | @pindex calc-more-recursion-depth | |
10782 | @pindex calc-less-recursion-depth | |
10783 | @cindex Recursion depth | |
10784 | @cindex ``Computation got stuck'' message | |
10785 | @cindex @code{max-lisp-eval-depth} | |
10786 | @cindex @code{max-specpdl-size} | |
10787 | Calc uses recursion in many of its calculations. Emacs Lisp keeps a | |
10788 | variable @code{max-lisp-eval-depth} which limits the amount of recursion | |
10789 | possible in an attempt to recover from program bugs. If a calculation | |
10790 | ever halts incorrectly with the message ``Computation got stuck or | |
10791 | ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth}) | |
10792 | to increase this limit. (Of course, this will not help if the | |
a4231b04 | 10793 | calculation really did get stuck due to some problem inside Calc.) |
d7b8e6c6 EZ |
10794 | |
10795 | The limit is always increased (multiplied) by a factor of two. There | |
10796 | is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which | |
10797 | decreases this limit by a factor of two, down to a minimum value of 200. | |
10798 | The default value is 1000. | |
10799 | ||
10800 | These commands also double or halve @code{max-specpdl-size}, another | |
10801 | internal Lisp recursion limit. The minimum value for this limit is 600. | |
10802 | ||
10803 | @node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands | |
10804 | @subsection Caches | |
10805 | ||
10806 | @noindent | |
10807 | @cindex Caches | |
10808 | @cindex Flushing caches | |
10809 | Calc saves certain values after they have been computed once. For | |
10810 | example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the | |
a4231b04 JB |
10811 | constant @cpi{} to about 20 decimal places; if the current precision |
10812 | is greater than this, it will recompute @cpi{} using a series | |
d7b8e6c6 EZ |
10813 | approximation. This value will not need to be recomputed ever again |
10814 | unless you raise the precision still further. Many operations such as | |
10815 | logarithms and sines make use of similarly cached values such as | |
a4231b04 | 10816 | @cpiover{4} and |
8e04863e | 10817 | @texline @math{\ln 2}. |
a4231b04 JB |
10818 | @infoline @expr{ln(2)}. |
10819 | The visible effect of caching is that | |
d7b8e6c6 EZ |
10820 | high-precision computations may seem to do extra work the first time. |
10821 | Other things cached include powers of two (for the binary arithmetic | |
10822 | functions), matrix inverses and determinants, symbolic integrals, and | |
10823 | data points computed by the graphing commands. | |
10824 | ||
10825 | @pindex calc-flush-caches | |
10826 | If you suspect a Calculator cache has become corrupt, you can use the | |
10827 | @code{calc-flush-caches} command to reset all caches to the empty state. | |
10828 | (This should only be necessary in the event of bugs in the Calculator.) | |
58547c3e | 10829 | The @kbd{C-x * 0} (with the zero key) command also resets caches along |
d7b8e6c6 EZ |
10830 | with all other aspects of the Calculator's state. |
10831 | ||
10832 | @node Debugging Calc, , Caches, Troubleshooting Commands | |
10833 | @subsection Debugging Calc | |
10834 | ||
10835 | @noindent | |
10836 | A few commands exist to help in the debugging of Calc commands. | |
10837 | @xref{Programming}, to see the various ways that you can write | |
10838 | your own Calc commands. | |
10839 | ||
10840 | @kindex Z T | |
10841 | @pindex calc-timing | |
10842 | The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode | |
10843 | in which the timing of slow commands is reported in the Trail. | |
10844 | Any Calc command that takes two seconds or longer writes a line | |
10845 | to the Trail showing how many seconds it took. This value is | |
10846 | accurate only to within one second. | |
10847 | ||
10848 | All steps of executing a command are included; in particular, time | |
10849 | taken to format the result for display in the stack and trail is | |
10850 | counted. Some prompts also count time taken waiting for them to | |
10851 | be answered, while others do not; this depends on the exact | |
10852 | implementation of the command. For best results, if you are timing | |
10853 | a sequence that includes prompts or multiple commands, define a | |
10854 | keyboard macro to run the whole sequence at once. Calc's @kbd{X} | |
10855 | command (@pxref{Keyboard Macros}) will then report the time taken | |
10856 | to execute the whole macro. | |
10857 | ||
10858 | Another advantage of the @kbd{X} command is that while it is | |
10859 | executing, the stack and trail are not updated from step to step. | |
10860 | So if you expect the output of your test sequence to leave a result | |
10861 | that may take a long time to format and you don't wish to count | |
10862 | this formatting time, end your sequence with a @key{DEL} keystroke | |
10863 | to clear the result from the stack. When you run the sequence with | |
10864 | @kbd{X}, Calc will never bother to format the large result. | |
10865 | ||
10866 | Another thing @kbd{Z T} does is to increase the Emacs variable | |
10867 | @code{gc-cons-threshold} to a much higher value (two million; the | |
10868 | usual default in Calc is 250,000) for the duration of each command. | |
10869 | This generally prevents garbage collection during the timing of | |
10870 | the command, though it may cause your Emacs process to grow | |
10871 | abnormally large. (Garbage collection time is a major unpredictable | |
10872 | factor in the timing of Emacs operations.) | |
10873 | ||
10874 | Another command that is useful when debugging your own Lisp | |
10875 | extensions to Calc is @kbd{M-x calc-pass-errors}, which disables | |
10876 | the error handler that changes the ``@code{max-lisp-eval-depth} | |
10877 | exceeded'' message to the much more friendly ``Computation got | |
10878 | stuck or ran too long.'' This handler interferes with the Emacs | |
10879 | Lisp debugger's @code{debug-on-error} mode. Errors are reported | |
10880 | in the handler itself rather than at the true location of the | |
10881 | error. After you have executed @code{calc-pass-errors}, Lisp | |
10882 | errors will be reported correctly but the user-friendly message | |
10883 | will be lost. | |
10884 | ||
10885 | @node Data Types, Stack and Trail, Introduction, Top | |
10886 | @chapter Data Types | |
10887 | ||
10888 | @noindent | |
10889 | This chapter discusses the various types of objects that can be placed | |
10890 | on the Calculator stack, how they are displayed, and how they are | |
10891 | entered. (@xref{Data Type Formats}, for information on how these data | |
a4231b04 | 10892 | types are represented as underlying Lisp objects.) |
d7b8e6c6 EZ |
10893 | |
10894 | Integers, fractions, and floats are various ways of describing real | |
10895 | numbers. HMS forms also for many purposes act as real numbers. These | |
10896 | types can be combined to form complex numbers, modulo forms, error forms, | |
10897 | or interval forms. (But these last four types cannot be combined | |
10898 | arbitrarily:@: error forms may not contain modulo forms, for example.) | |
10899 | Finally, all these types of numbers may be combined into vectors, | |
10900 | matrices, or algebraic formulas. | |
10901 | ||
10902 | @menu | |
10903 | * Integers:: The most basic data type. | |
10904 | * Fractions:: This and above are called @dfn{rationals}. | |
10905 | * Floats:: This and above are called @dfn{reals}. | |
10906 | * Complex Numbers:: This and above are called @dfn{numbers}. | |
10907 | * Infinities:: | |
10908 | * Vectors and Matrices:: | |
10909 | * Strings:: | |
10910 | * HMS Forms:: | |
10911 | * Date Forms:: | |
10912 | * Modulo Forms:: | |
10913 | * Error Forms:: | |
10914 | * Interval Forms:: | |
10915 | * Incomplete Objects:: | |
10916 | * Variables:: | |
10917 | * Formulas:: | |
10918 | @end menu | |
10919 | ||
10920 | @node Integers, Fractions, Data Types, Data Types | |
10921 | @section Integers | |
10922 | ||
10923 | @noindent | |
10924 | @cindex Integers | |
10925 | The Calculator stores integers to arbitrary precision. Addition, | |
10926 | subtraction, and multiplication of integers always yields an exact | |
10927 | integer result. (If the result of a division or exponentiation of | |
10928 | integers is not an integer, it is expressed in fractional or | |
07ce2eb3 | 10929 | floating-point form according to the current Fraction mode. |
d7b8e6c6 EZ |
10930 | @xref{Fraction Mode}.) |
10931 | ||
10932 | A decimal integer is represented as an optional sign followed by a | |
10933 | sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to | |
10934 | insert a comma at every third digit for display purposes, but you | |
a4231b04 | 10935 | must not type commas during the entry of numbers. |
d7b8e6c6 EZ |
10936 | |
10937 | @kindex # | |
10938 | A non-decimal integer is represented as an optional sign, a radix | |
10939 | between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11 | |
10940 | and above, the letters A through Z (upper- or lower-case) count as | |
10941 | digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how | |
10942 | to set the default radix for display of integers. Numbers of any radix | |
10943 | may be entered at any time. If you press @kbd{#} at the beginning of a | |
a4231b04 | 10944 | number, the current display radix is used. |
d7b8e6c6 EZ |
10945 | |
10946 | @node Fractions, Floats, Integers, Data Types | |
10947 | @section Fractions | |
10948 | ||
10949 | @noindent | |
10950 | @cindex Fractions | |
10951 | A @dfn{fraction} is a ratio of two integers. Fractions are traditionally | |
10952 | written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key | |
10953 | performs RPN division; the following two sequences push the number | |
10954 | @samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /} | |
07ce2eb3 | 10955 | assuming Fraction mode has been enabled.) |
d7b8e6c6 | 10956 | When the Calculator produces a fractional result it always reduces it to |
a4231b04 | 10957 | simplest form, which may in fact be an integer. |
d7b8e6c6 EZ |
10958 | |
10959 | Fractions may also be entered in a three-part form, where @samp{2:3:4} | |
10960 | represents two-and-three-quarters. @xref{Fraction Formats}, for fraction | |
a4231b04 | 10961 | display formats. |
d7b8e6c6 EZ |
10962 | |
10963 | Non-decimal fractions are entered and displayed as | |
10964 | @samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part | |
a4231b04 | 10965 | form). The numerator and denominator always use the same radix. |
d7b8e6c6 EZ |
10966 | |
10967 | @node Floats, Complex Numbers, Fractions, Data Types | |
10968 | @section Floats | |
10969 | ||
10970 | @noindent | |
10971 | @cindex Floating-point numbers | |
10972 | A floating-point number or @dfn{float} is a number stored in scientific | |
10973 | notation. The number of significant digits in the fractional part is | |
10974 | governed by the current floating precision (@pxref{Precision}). The | |
a4231b04 | 10975 | range of acceptable values is from |
8e04863e | 10976 | @texline @math{10^{-3999999}} |
a4231b04 JB |
10977 | @infoline @expr{10^-3999999} |
10978 | (inclusive) to | |
8e04863e | 10979 | @texline @math{10^{4000000}} |
a4231b04 JB |
10980 | @infoline @expr{10^4000000} |
10981 | (exclusive), plus the corresponding negative values and zero. | |
d7b8e6c6 EZ |
10982 | |
10983 | Calculations that would exceed the allowable range of values (such | |
10984 | as @samp{exp(exp(20))}) are left in symbolic form by Calc. The | |
10985 | messages ``floating-point overflow'' or ``floating-point underflow'' | |
10986 | indicate that during the calculation a number would have been produced | |
10987 | that was too large or too close to zero, respectively, to be represented | |
10988 | by Calc. This does not necessarily mean the final result would have | |
10989 | overflowed, just that an overflow occurred while computing the result. | |
10990 | (In fact, it could report an underflow even though the final result | |
10991 | would have overflowed!) | |
10992 | ||
10993 | If a rational number and a float are mixed in a calculation, the result | |
10994 | will in general be expressed as a float. Commands that require an integer | |
10995 | value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued | |
10996 | floats, i.e., floating-point numbers with nothing after the decimal point. | |
10997 | ||
10998 | Floats are identified by the presence of a decimal point and/or an | |
10999 | exponent. In general a float consists of an optional sign, digits | |
11000 | including an optional decimal point, and an optional exponent consisting | |
11001 | of an @samp{e}, an optional sign, and up to seven exponent digits. | |
11002 | For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power, | |
11003 | or 0.235. | |
11004 | ||
11005 | Floating-point numbers are normally displayed in decimal notation with | |
11006 | all significant figures shown. Exceedingly large or small numbers are | |
11007 | displayed in scientific notation. Various other display options are | |
11008 | available. @xref{Float Formats}. | |
11009 | ||
11010 | @cindex Accuracy of calculations | |
11011 | Floating-point numbers are stored in decimal, not binary. The result | |
11012 | of each operation is rounded to the nearest value representable in the | |
11013 | number of significant digits specified by the current precision, | |
11014 | rounding away from zero in the case of a tie. Thus (in the default | |
11015 | display mode) what you see is exactly what you get. Some operations such | |
11016 | as square roots and transcendental functions are performed with several | |
11017 | digits of extra precision and then rounded down, in an effort to make the | |
11018 | final result accurate to the full requested precision. However, | |
11019 | accuracy is not rigorously guaranteed. If you suspect the validity of a | |
11020 | result, try doing the same calculation in a higher precision. The | |
11021 | Calculator's arithmetic is not intended to be IEEE-conformant in any | |
a4231b04 | 11022 | way. |
d7b8e6c6 EZ |
11023 | |
11024 | While floats are always @emph{stored} in decimal, they can be entered | |
11025 | and displayed in any radix just like integers and fractions. The | |
11026 | notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point | |
11027 | number whose digits are in the specified radix. Note that the @samp{.} | |
11028 | is more aptly referred to as a ``radix point'' than as a decimal | |
11029 | point in this case. The number @samp{8#123.4567} is defined as | |
11030 | @samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use | |
11031 | @samp{e} notation to write a non-decimal number in scientific notation. | |
11032 | The exponent is written in decimal, and is considered to be a power | |
11033 | of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the | |
11034 | letter @samp{e} is a digit, so scientific notation must be written | |
11035 | out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the | |
11036 | Modes Tutorial explore some of the properties of non-decimal floats. | |
11037 | ||
11038 | @node Complex Numbers, Infinities, Floats, Data Types | |
11039 | @section Complex Numbers | |
11040 | ||
11041 | @noindent | |
11042 | @cindex Complex numbers | |
11043 | There are two supported formats for complex numbers: rectangular and | |
11044 | polar. The default format is rectangular, displayed in the form | |
11045 | @samp{(@var{real},@var{imag})} where @var{real} is the real part and | |
11046 | @var{imag} is the imaginary part, each of which may be any real number. | |
11047 | Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i} | |
a4231b04 JB |
11048 | notation; @pxref{Complex Formats}. |
11049 | ||
11050 | Polar complex numbers are displayed in the form | |
bd712b70 JB |
11051 | @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}' |
11052 | @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}' | |
a4231b04 | 11053 | where @var{r} is the nonnegative magnitude and |
8e04863e | 11054 | @texline @math{\theta} |
a4231b04 JB |
11055 | @infoline @var{theta} |
11056 | is the argument or phase angle. The range of | |
8e04863e | 11057 | @texline @math{\theta} |
a4231b04 JB |
11058 | @infoline @var{theta} |
11059 | depends on the current angular mode (@pxref{Angular Modes}); it is | |
8e04863e | 11060 | generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range |
a4231b04 | 11061 | in radians. |
d7b8e6c6 EZ |
11062 | |
11063 | Complex numbers are entered in stages using incomplete objects. | |
11064 | @xref{Incomplete Objects}. | |
11065 | ||
11066 | Operations on rectangular complex numbers yield rectangular complex | |
11067 | results, and similarly for polar complex numbers. Where the two types | |
11068 | are mixed, or where new complex numbers arise (as for the square root of | |
07ce2eb3 | 11069 | a negative real), the current @dfn{Polar mode} is used to determine the |
d7b8e6c6 EZ |
11070 | type. @xref{Polar Mode}. |
11071 | ||
11072 | A complex result in which the imaginary part is zero (or the phase angle | |
a4231b04 | 11073 | is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real |
d7b8e6c6 EZ |
11074 | number. |
11075 | ||
11076 | @node Infinities, Vectors and Matrices, Complex Numbers, Data Types | |
11077 | @section Infinities | |
11078 | ||
11079 | @noindent | |
11080 | @cindex Infinity | |
11081 | @cindex @code{inf} variable | |
11082 | @cindex @code{uinf} variable | |
11083 | @cindex @code{nan} variable | |
11084 | @vindex inf | |
11085 | @vindex uinf | |
11086 | @vindex nan | |
11087 | The word @code{inf} represents the mathematical concept of @dfn{infinity}. | |
11088 | Calc actually has three slightly different infinity-like values: | |
11089 | @code{inf}, @code{uinf}, and @code{nan}. These are just regular | |
11090 | variable names (@pxref{Variables}); you should avoid using these | |
11091 | names for your own variables because Calc gives them special | |
11092 | treatment. Infinities, like all variable names, are normally | |
11093 | entered using algebraic entry. | |
11094 | ||
11095 | Mathematically speaking, it is not rigorously correct to treat | |
11096 | ``infinity'' as if it were a number, but mathematicians often do | |
11097 | so informally. When they say that @samp{1 / inf = 0}, what they | |
a4231b04 | 11098 | really mean is that @expr{1 / x}, as @expr{x} becomes larger and |
d7b8e6c6 | 11099 | larger, becomes arbitrarily close to zero. So you can imagine |
a4231b04 | 11100 | that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x} |
d7b8e6c6 | 11101 | would go all the way to zero. Similarly, when they say that |
a4231b04 | 11102 | @samp{exp(inf) = inf}, they mean that |
8e04863e | 11103 | @texline @math{e^x} |
a4231b04 JB |
11104 | @infoline @expr{exp(x)} |
11105 | grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise | |
11106 | stands for an infinitely negative real value; for example, we say that | |
d7b8e6c6 EZ |
11107 | @samp{exp(-inf) = 0}. You can have an infinity pointing in any |
11108 | direction on the complex plane: @samp{sqrt(-inf) = i inf}. | |
11109 | ||
a4231b04 JB |
11110 | The same concept of limits can be used to define @expr{1 / 0}. We |
11111 | really want the value that @expr{1 / x} approaches as @expr{x} | |
11112 | approaches zero. But if all we have is @expr{1 / 0}, we can't | |
11113 | tell which direction @expr{x} was coming from. If @expr{x} was | |
d7b8e6c6 | 11114 | positive and decreasing toward zero, then we should say that |
a4231b04 JB |
11115 | @samp{1 / 0 = inf}. But if @expr{x} was negative and increasing |
11116 | toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x} | |
d7b8e6c6 EZ |
11117 | could be an imaginary number, giving the answer @samp{i inf} or |
11118 | @samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean | |
11119 | @dfn{undirected infinity}, i.e., a value which is infinitely | |
11120 | large but with an unknown sign (or direction on the complex plane). | |
11121 | ||
11122 | Calc actually has three modes that say how infinities are handled. | |
11123 | Normally, infinities never arise from calculations that didn't | |
a4231b04 | 11124 | already have them. Thus, @expr{1 / 0} is treated simply as an |
d7b8e6c6 EZ |
11125 | error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode}) |
11126 | command (@pxref{Infinite Mode}) enables a mode in which | |
a4231b04 | 11127 | @expr{1 / 0} evaluates to @code{uinf} instead. There is also |
d7b8e6c6 EZ |
11128 | an alternative type of infinite mode which says to treat zeros |
11129 | as if they were positive, so that @samp{1 / 0 = inf}. While this | |
11130 | is less mathematically correct, it may be the answer you want in | |
11131 | some cases. | |
11132 | ||
11133 | Since all infinities are ``as large'' as all others, Calc simplifies, | |
11134 | e.g., @samp{5 inf} to @samp{inf}. Another example is | |
11135 | @samp{5 - inf = -inf}, where the @samp{-inf} is so large that | |
11136 | adding a finite number like five to it does not affect it. | |
11137 | Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes | |
11138 | that variables like @code{a} always stand for finite quantities. | |
11139 | Just to show that infinities really are all the same size, | |
11140 | note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's | |
11141 | notation. | |
11142 | ||
11143 | It's not so easy to define certain formulas like @samp{0 * inf} and | |
11144 | @samp{inf / inf}. Depending on where these zeros and infinities | |
11145 | came from, the answer could be literally anything. The latter | |
a4231b04 JB |
11146 | formula could be the limit of @expr{x / x} (giving a result of one), |
11147 | or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}), | |
11148 | or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan} | |
d7b8e6c6 EZ |
11149 | to represent such an @dfn{indeterminate} value. (The name ``nan'' |
11150 | comes from analogy with the ``NAN'' concept of IEEE standard | |
11151 | arithmetic; it stands for ``Not A Number.'' This is somewhat of a | |
11152 | misnomer, since @code{nan} @emph{does} stand for some number or | |
11153 | infinity, it's just that @emph{which} number it stands for | |
11154 | cannot be determined.) In Calc's notation, @samp{0 * inf = nan} | |
11155 | and @samp{inf / inf = nan}. A few other common indeterminate | |
11156 | expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also, | |
07ce2eb3 | 11157 | @samp{0 / 0 = nan} if you have turned on Infinite mode |
d7b8e6c6 EZ |
11158 | (as described above). |
11159 | ||
11160 | Infinities are especially useful as parts of @dfn{intervals}. | |
11161 | @xref{Interval Forms}. | |
11162 | ||
11163 | @node Vectors and Matrices, Strings, Infinities, Data Types | |
11164 | @section Vectors and Matrices | |
11165 | ||
11166 | @noindent | |
11167 | @cindex Vectors | |
11168 | @cindex Plain vectors | |
11169 | @cindex Matrices | |
11170 | The @dfn{vector} data type is flexible and general. A vector is simply a | |
11171 | list of zero or more data objects. When these objects are numbers, the | |
11172 | whole is a vector in the mathematical sense. When these objects are | |
11173 | themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}. | |
11174 | A vector which is not a matrix is referred to here as a @dfn{plain vector}. | |
11175 | ||
11176 | A vector is displayed as a list of values separated by commas and enclosed | |
11177 | in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by | |
11178 | 3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex | |
11179 | numbers, are entered as incomplete objects. @xref{Incomplete Objects}. | |
11180 | During algebraic entry, vectors are entered all at once in the usual | |
11181 | brackets-and-commas form. Matrices may be entered algebraically as nested | |
11182 | vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}}, | |
11183 | with rows separated by semicolons. The commas may usually be omitted | |
11184 | when entering vectors: @samp{[1 2 3]}. Curly braces may be used in | |
11185 | place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in | |
11186 | this case. | |
11187 | ||
11188 | Traditional vector and matrix arithmetic is also supported; | |
11189 | @pxref{Basic Arithmetic} and @pxref{Matrix Functions}. | |
11190 | Many other operations are applied to vectors element-wise. For example, | |
11191 | the complex conjugate of a vector is a vector of the complex conjugates | |
a4231b04 | 11192 | of its elements. |
d7b8e6c6 | 11193 | |
5d67986c RS |
11194 | @ignore |
11195 | @starindex | |
11196 | @end ignore | |
d7b8e6c6 EZ |
11197 | @tindex vec |
11198 | Algebraic functions for building vectors include @samp{vec(a, b, c)} | |
a4231b04 | 11199 | to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an |
8e04863e | 11200 | @texline @math{n\times m} |
a4231b04 | 11201 | @infoline @var{n}x@var{m} |
d7b8e6c6 EZ |
11202 | matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers |
11203 | from 1 to @samp{n}. | |
11204 | ||
11205 | @node Strings, HMS Forms, Vectors and Matrices, Data Types | |
11206 | @section Strings | |
11207 | ||
11208 | @noindent | |
11209 | @kindex " | |
11210 | @cindex Strings | |
11211 | @cindex Character strings | |
11212 | Character strings are not a special data type in the Calculator. | |
11213 | Rather, a string is represented simply as a vector all of whose | |
11214 | elements are integers in the range 0 to 255 (ASCII codes). You can | |
11215 | enter a string at any time by pressing the @kbd{"} key. Quotation | |
11216 | marks and backslashes are written @samp{\"} and @samp{\\}, respectively, | |
11217 | inside strings. Other notations introduced by backslashes are: | |
11218 | ||
d7b8e6c6 | 11219 | @example |
5d67986c | 11220 | @group |
d7b8e6c6 EZ |
11221 | \a 7 \^@@ 0 |
11222 | \b 8 \^a-z 1-26 | |
11223 | \e 27 \^[ 27 | |
11224 | \f 12 \^\\ 28 | |
11225 | \n 10 \^] 29 | |
11226 | \r 13 \^^ 30 | |
11227 | \t 9 \^_ 31 | |
11228 | \^? 127 | |
d7b8e6c6 | 11229 | @end group |
5d67986c | 11230 | @end example |
d7b8e6c6 EZ |
11231 | |
11232 | @noindent | |
11233 | Finally, a backslash followed by three octal digits produces any | |
11234 | character from its ASCII code. | |
11235 | ||
11236 | @kindex d " | |
11237 | @pindex calc-display-strings | |
11238 | Strings are normally displayed in vector-of-integers form. The | |
11239 | @w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in | |
11240 | which any vectors of small integers are displayed as quoted strings | |
11241 | instead. | |
11242 | ||
11243 | The backslash notations shown above are also used for displaying | |
11244 | strings. Characters 128 and above are not translated by Calc; unless | |
11245 | you have an Emacs modified for 8-bit fonts, these will show up in | |
11246 | backslash-octal-digits notation. For characters below 32, and | |
11247 | for character 127, Calc uses the backslash-letter combination if | |
11248 | there is one, or otherwise uses a @samp{\^} sequence. | |
11249 | ||
11250 | The only Calc feature that uses strings is @dfn{compositions}; | |
11251 | @pxref{Compositions}. Strings also provide a convenient | |
11252 | way to do conversions between ASCII characters and integers. | |
11253 | ||
5d67986c RS |
11254 | @ignore |
11255 | @starindex | |
11256 | @end ignore | |
d7b8e6c6 EZ |
11257 | @tindex string |
11258 | There is a @code{string} function which provides a different display | |
11259 | format for strings. Basically, @samp{string(@var{s})}, where @var{s} | |
11260 | is a vector of integers in the proper range, is displayed as the | |
11261 | corresponding string of characters with no surrounding quotation | |
11262 | marks or other modifications. Thus @samp{string("ABC")} (or | |
11263 | @samp{string([65 66 67])}) will look like @samp{ABC} on the stack. | |
11264 | This happens regardless of whether @w{@kbd{d "}} has been used. The | |
11265 | only way to turn it off is to use @kbd{d U} (unformatted language | |
11266 | mode) which will display @samp{string("ABC")} instead. | |
11267 | ||
11268 | Control characters are displayed somewhat differently by @code{string}. | |
11269 | Characters below 32, and character 127, are shown using @samp{^} notation | |
11270 | (same as shown above, but without the backslash). The quote and | |
11271 | backslash characters are left alone, as are characters 128 and above. | |
11272 | ||
5d67986c RS |
11273 | @ignore |
11274 | @starindex | |
11275 | @end ignore | |
d7b8e6c6 EZ |
11276 | @tindex bstring |
11277 | The @code{bstring} function is just like @code{string} except that | |
11278 | the resulting string is breakable across multiple lines if it doesn't | |
11279 | fit all on one line. Potential break points occur at every space | |
11280 | character in the string. | |
11281 | ||
11282 | @node HMS Forms, Date Forms, Strings, Data Types | |
11283 | @section HMS Forms | |
11284 | ||
11285 | @noindent | |
11286 | @cindex Hours-minutes-seconds forms | |
11287 | @cindex Degrees-minutes-seconds forms | |
11288 | @dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular | |
11289 | argument, the interpretation is Degrees-Minutes-Seconds. All functions | |
11290 | that operate on angles accept HMS forms. These are interpreted as | |
11291 | degrees regardless of the current angular mode. It is also possible to | |
11292 | use HMS as the angular mode so that calculated angles are expressed in | |
11293 | degrees, minutes, and seconds. | |
11294 | ||
11295 | @kindex @@ | |
5d67986c RS |
11296 | @ignore |
11297 | @mindex @null | |
11298 | @end ignore | |
d7b8e6c6 | 11299 | @kindex ' (HMS forms) |
5d67986c RS |
11300 | @ignore |
11301 | @mindex @null | |
11302 | @end ignore | |
d7b8e6c6 | 11303 | @kindex " (HMS forms) |
5d67986c RS |
11304 | @ignore |
11305 | @mindex @null | |
11306 | @end ignore | |
d7b8e6c6 | 11307 | @kindex h (HMS forms) |
5d67986c RS |
11308 | @ignore |
11309 | @mindex @null | |
11310 | @end ignore | |
d7b8e6c6 | 11311 | @kindex o (HMS forms) |
5d67986c RS |
11312 | @ignore |
11313 | @mindex @null | |
11314 | @end ignore | |
d7b8e6c6 | 11315 | @kindex m (HMS forms) |
5d67986c RS |
11316 | @ignore |
11317 | @mindex @null | |
11318 | @end ignore | |
d7b8e6c6 EZ |
11319 | @kindex s (HMS forms) |
11320 | The default format for HMS values is | |
11321 | @samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters | |
11322 | @samp{h} (for ``hours'') or | |
11323 | @samp{o} (approximating the ``degrees'' symbol) are accepted as well as | |
11324 | @samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is | |
11325 | accepted in place of @samp{"}. | |
11326 | The @var{hours} value is an integer (or integer-valued float). | |
11327 | The @var{mins} value is an integer or integer-valued float between 0 and 59. | |
11328 | The @var{secs} value is a real number between 0 (inclusive) and 60 | |
11329 | (exclusive). A positive HMS form is interpreted as @var{hours} + | |
11330 | @var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted | |
8e04863e | 11331 | as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600. |
a4231b04 | 11332 | Display format for HMS forms is quite flexible. @xref{HMS Formats}. |
d7b8e6c6 EZ |
11333 | |
11334 | HMS forms can be added and subtracted. When they are added to numbers, | |
11335 | the numbers are interpreted according to the current angular mode. HMS | |
11336 | forms can also be multiplied and divided by real numbers. Dividing | |
11337 | two HMS forms produces a real-valued ratio of the two angles. | |
11338 | ||
11339 | @pindex calc-time | |
11340 | @cindex Time of day | |
11341 | Just for kicks, @kbd{M-x calc-time} pushes the current time of day on | |
11342 | the stack as an HMS form. | |
11343 | ||
11344 | @node Date Forms, Modulo Forms, HMS Forms, Data Types | |
11345 | @section Date Forms | |
11346 | ||
11347 | @noindent | |
11348 | @cindex Date forms | |
11349 | A @dfn{date form} represents a date and possibly an associated time. | |
11350 | Simple date arithmetic is supported: Adding a number to a date | |
11351 | produces a new date shifted by that many days; adding an HMS form to | |
11352 | a date shifts it by that many hours. Subtracting two date forms | |
11353 | computes the number of days between them (represented as a simple | |
11354 | number). Many other operations, such as multiplying two date forms, | |
11355 | are nonsensical and are not allowed by Calc. | |
11356 | ||
11357 | Date forms are entered and displayed enclosed in @samp{< >} brackets. | |
11358 | The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates, | |
11359 | or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times. | |
11360 | Input is flexible; date forms can be entered in any of the usual | |
11361 | notations for dates and times. @xref{Date Formats}. | |
11362 | ||
11363 | Date forms are stored internally as numbers, specifically the number | |
11364 | of days since midnight on the morning of January 1 of the year 1 AD. | |
11365 | If the internal number is an integer, the form represents a date only; | |
11366 | if the internal number is a fraction or float, the form represents | |
11367 | a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>} | |
11368 | is represented by the number 726842.25. The standard precision of | |
11369 | 12 decimal digits is enough to ensure that a (reasonable) date and | |
11370 | time can be stored without roundoff error. | |
11371 | ||
11372 | If the current precision is greater than 12, date forms will keep | |
11373 | additional digits in the seconds position. For example, if the | |
11374 | precision is 15, the seconds will keep three digits after the | |
11375 | decimal point. Decreasing the precision below 12 may cause the | |
11376 | time part of a date form to become inaccurate. This can also happen | |
11377 | if astronomically high years are used, though this will not be an | |
28665d46 | 11378 | issue in everyday (or even everymillennium) use. Note that date |
d7b8e6c6 EZ |
11379 | forms without times are stored as exact integers, so roundoff is |
11380 | never an issue for them. | |
11381 | ||
11382 | You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u} | |
11383 | (@code{calc-unpack}) commands to get at the numerical representation | |
11384 | of a date form. @xref{Packing and Unpacking}. | |
11385 | ||
11386 | Date forms can go arbitrarily far into the future or past. Negative | |
11387 | year numbers represent years BC. Calc uses a combination of the | |
11388 | Gregorian and Julian calendars, following the history of Great | |
11389 | Britain and the British colonies. This is the same calendar that | |
11390 | is used by the @code{cal} program in most Unix implementations. | |
11391 | ||
11392 | @cindex Julian calendar | |
11393 | @cindex Gregorian calendar | |
11394 | Some historical background: The Julian calendar was created by | |
11395 | Julius Caesar in the year 46 BC as an attempt to fix the gradual | |
11396 | drift caused by the lack of leap years in the calendar used | |
11397 | until that time. The Julian calendar introduced an extra day in | |
11398 | all years divisible by four. After some initial confusion, the | |
11399 | calendar was adopted around the year we call 8 AD. Some centuries | |
11400 | later it became apparent that the Julian year of 365.25 days was | |
11401 | itself not quite right. In 1582 Pope Gregory XIII introduced the | |
11402 | Gregorian calendar, which added the new rule that years divisible | |
11403 | by 100, but not by 400, were not to be considered leap years | |
11404 | despite being divisible by four. Many countries delayed adoption | |
11405 | of the Gregorian calendar because of religious differences; | |
11406 | in Britain it was put off until the year 1752, by which time | |
11407 | the Julian calendar had fallen eleven days behind the true | |
11408 | seasons. So the switch to the Gregorian calendar in early | |
11409 | September 1752 introduced a discontinuity: The day after | |
11410 | Sep 2, 1752 is Sep 14, 1752. Calc follows this convention. | |
11411 | To take another example, Russia waited until 1918 before | |
11412 | adopting the new calendar, and thus needed to remove thirteen | |
11413 | days (between Feb 1, 1918 and Feb 14, 1918). This means that | |
11414 | Calc's reckoning will be inconsistent with Russian history between | |
11415 | 1752 and 1918, and similarly for various other countries. | |
11416 | ||
11417 | Today's timekeepers introduce an occasional ``leap second'' as | |
11418 | well, but Calc does not take these minor effects into account. | |
11419 | (If it did, it would have to report a non-integer number of days | |
11420 | between, say, @samp{<12:00am Mon Jan 1, 1900>} and | |
11421 | @samp{<12:00am Sat Jan 1, 2000>}.) | |
11422 | ||
11423 | Calc uses the Julian calendar for all dates before the year 1752, | |
11424 | including dates BC when the Julian calendar technically had not | |
8e04863e | 11425 | yet been invented. Thus the claim that day number @mathit{-10000} is |
d7b8e6c6 EZ |
11426 | called ``August 16, 28 BC'' should be taken with a grain of salt. |
11427 | ||
11428 | Please note that there is no ``year 0''; the day before | |
11429 | @samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are | |
8e04863e | 11430 | days 0 and @mathit{-1} respectively in Calc's internal numbering scheme. |
d7b8e6c6 EZ |
11431 | |
11432 | @cindex Julian day counting | |
11433 | Another day counting system in common use is, confusingly, also | |
11434 | called ``Julian.'' It was invented in 1583 by Joseph Justus | |
11435 | Scaliger, who named it in honor of his father Julius Caesar | |
11436 | Scaliger. For obscure reasons he chose to start his day | |
11437 | numbering on Jan 1, 4713 BC at noon, which in Calc's scheme | |
8e04863e | 11438 | is @mathit{-1721423.5} (recall that Calc starts at midnight instead |
d7b8e6c6 EZ |
11439 | of noon). Thus to convert a Calc date code obtained by |
11440 | unpacking a date form into a Julian day number, simply add | |
11441 | 1721423.5. The Julian code for @samp{6:00am Jan 9, 1991} | |
11442 | is 2448265.75. The built-in @kbd{t J} command performs | |
11443 | this conversion for you. | |
11444 | ||
11445 | @cindex Unix time format | |
11446 | The Unix operating system measures time as an integer number of | |
11447 | seconds since midnight, Jan 1, 1970. To convert a Calc date | |
11448 | value into a Unix time stamp, first subtract 719164 (the code | |
11449 | for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of | |
11450 | seconds in a day) and press @kbd{R} to round to the nearest | |
11451 | integer. If you have a date form, you can simply subtract the | |
11452 | day @samp{<Jan 1, 1970>} instead of unpacking and subtracting | |
11453 | 719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>} | |
11454 | to convert from Unix time to a Calc date form. (Note that | |
11455 | Unix normally maintains the time in the GMT time zone; you may | |
11456 | need to subtract five hours to get New York time, or eight hours | |
11457 | for California time. The same is usually true of Julian day | |
11458 | counts.) The built-in @kbd{t U} command performs these | |
11459 | conversions. | |
11460 | ||
11461 | @node Modulo Forms, Error Forms, Date Forms, Data Types | |
11462 | @section Modulo Forms | |
11463 | ||
11464 | @noindent | |
11465 | @cindex Modulo forms | |
11466 | A @dfn{modulo form} is a real number which is taken modulo (i.e., within | |
5d67986c | 11467 | an integer multiple of) some value @var{M}. Arithmetic modulo @var{M} |
d7b8e6c6 | 11468 | often arises in number theory. Modulo forms are written |
bd712b70 | 11469 | `@var{a} @tfn{mod} @var{M}', |
5d67986c | 11470 | where @var{a} and @var{M} are real numbers or HMS forms, and |
8e04863e | 11471 | @texline @math{0 \le a < M}. |
a4231b04 JB |
11472 | @infoline @expr{0 <= a < @var{M}}. |
11473 | In many applications @expr{a} and @expr{M} will be | |
11474 | integers but this is not required. | |
d7b8e6c6 | 11475 | |
029b2a44 JB |
11476 | @ignore |
11477 | @mindex M | |
11478 | @end ignore | |
11479 | @kindex M (modulo forms) | |
11480 | @ignore | |
11481 | @mindex mod | |
11482 | @end ignore | |
11483 | @tindex mod (operator) | |
11484 | To create a modulo form during numeric entry, press the shift-@kbd{M} | |
11485 | key to enter the word @samp{mod}. As a special convenience, pressing | |
11486 | shift-@kbd{M} a second time automatically enters the value of @expr{M} | |
11487 | that was most recently used before. During algebraic entry, either | |
11488 | type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}). | |
11489 | Once again, pressing this a second time enters the current modulo. | |
11490 | ||
d7b8e6c6 EZ |
11491 | Modulo forms are not to be confused with the modulo operator @samp{%}. |
11492 | The expression @samp{27 % 10} means to compute 27 modulo 10 to produce | |
11493 | the result 7. Further computations treat this 7 as just a regular integer. | |
11494 | The expression @samp{27 mod 10} produces the result @samp{7 mod 10}; | |
11495 | further computations with this value are again reduced modulo 10 so that | |
11496 | the result always lies in the desired range. | |
11497 | ||
a4231b04 | 11498 | When two modulo forms with identical @expr{M}'s are added or multiplied, |
d7b8e6c6 | 11499 | the Calculator simply adds or multiplies the values, then reduces modulo |
a4231b04 | 11500 | @expr{M}. If one argument is a modulo form and the other a plain number, |
d7b8e6c6 EZ |
11501 | the plain number is treated like a compatible modulo form. It is also |
11502 | possible to raise modulo forms to powers; the result is the value raised | |
a4231b04 | 11503 | to the power, then reduced modulo @expr{M}. (When all values involved |
d7b8e6c6 EZ |
11504 | are integers, this calculation is done much more efficiently than |
11505 | actually computing the power and then reducing.) | |
11506 | ||
11507 | @cindex Modulo division | |
bd712b70 | 11508 | Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}' |
a4231b04 | 11509 | can be divided if @expr{a}, @expr{b}, and @expr{M} are all |
d7b8e6c6 | 11510 | integers. The result is the modulo form which, when multiplied by |
bd712b70 | 11511 | `@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If |
d7b8e6c6 | 11512 | there is no solution to this equation (which can happen only when |
a4231b04 | 11513 | @expr{M} is non-prime), or if any of the arguments are non-integers, the |
d7b8e6c6 EZ |
11514 | division is left in symbolic form. Other operations, such as square |
11515 | roots, are not yet supported for modulo forms. (Note that, although | |
bd712b70 | 11516 | @w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root'' |
a4231b04 | 11517 | in the sense of reducing |
8e04863e | 11518 | @texline @math{\sqrt a} |
a4231b04 JB |
11519 | @infoline @expr{sqrt(a)} |
11520 | modulo @expr{M}, this is not a useful definition from the | |
11521 | number-theoretical point of view.) | |
d7b8e6c6 | 11522 | |
d7b8e6c6 EZ |
11523 | It is possible to mix HMS forms and modulo forms. For example, an |
11524 | HMS form modulo 24 could be used to manipulate clock times; an HMS | |
a4231b04 | 11525 | form modulo 360 would be suitable for angles. Making the modulo @expr{M} |
d7b8e6c6 EZ |
11526 | also be an HMS form eliminates troubles that would arise if the angular |
11527 | mode were inadvertently set to Radians, in which case | |
11528 | @w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo | |
11529 | 24 radians! | |
11530 | ||
11531 | Modulo forms cannot have variables or formulas for components. If you | |
11532 | enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus | |
11533 | to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}. | |
11534 | ||
029b2a44 JB |
11535 | You can use @kbd{v p} and @kbd{%} to modify modulo forms. |
11536 | @xref{Packing and Unpacking}. @xref{Basic Arithmetic}. | |
11537 | ||
5d67986c RS |
11538 | @ignore |
11539 | @starindex | |
11540 | @end ignore | |
d7b8e6c6 EZ |
11541 | @tindex makemod |
11542 | The algebraic function @samp{makemod(a, m)} builds the modulo form | |
11543 | @w{@samp{a mod m}}. | |
11544 | ||
11545 | @node Error Forms, Interval Forms, Modulo Forms, Data Types | |
11546 | @section Error Forms | |
11547 | ||
11548 | @noindent | |
11549 | @cindex Error forms | |
11550 | @cindex Standard deviations | |
11551 | An @dfn{error form} is a number with an associated standard | |
11552 | deviation, as in @samp{2.3 +/- 0.12}. The notation | |
bd712b70 JB |
11553 | @texline `@var{x} @tfn{+/-} @math{\sigma}' |
11554 | @infoline `@var{x} @tfn{+/-} sigma' | |
a4231b04 JB |
11555 | stands for an uncertain value which follows |
11556 | a normal or Gaussian distribution of mean @expr{x} and standard | |
11557 | deviation or ``error'' | |
8e04863e | 11558 | @texline @math{\sigma}. |
a4231b04 JB |
11559 | @infoline @expr{sigma}. |
11560 | Both the mean and the error can be either numbers or | |
d7b8e6c6 EZ |
11561 | formulas. Generally these are real numbers but the mean may also be |
11562 | complex. If the error is negative or complex, it is changed to its | |
11563 | absolute value. An error form with zero error is converted to a | |
a4231b04 | 11564 | regular number by the Calculator. |
d7b8e6c6 EZ |
11565 | |
11566 | All arithmetic and transcendental functions accept error forms as input. | |
11567 | Operations on the mean-value part work just like operations on regular | |
a4231b04 | 11568 | numbers. The error part for any function @expr{f(x)} (such as |
8e04863e | 11569 | @texline @math{\sin x} |
a4231b04 JB |
11570 | @infoline @expr{sin(x)}) |
11571 | is defined by the error of @expr{x} times the derivative of @expr{f} | |
11572 | evaluated at the mean value of @expr{x}. For a two-argument function | |
11573 | @expr{f(x,y)} (such as addition) the error is the square root of the sum | |
11574 | of the squares of the errors due to @expr{x} and @expr{y}. | |
d7b8e6c6 EZ |
11575 | @tex |
11576 | $$ \eqalign{ | |
11577 | f(x \hbox{\code{ +/- }} \sigma) | |
11578 | &= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr | |
11579 | f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y) | |
11580 | &= f(x,y) \hbox{\code{ +/- }} | |
11581 | \sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x} | |
11582 | \right| \right)^2 | |
11583 | +\left(\sigma_y \left| {\partial f(x,y) \over \partial y} | |
11584 | \right| \right)^2 } \cr | |
11585 | } $$ | |
11586 | @end tex | |
11587 | Note that this | |
a4231b04 | 11588 | definition assumes the errors in @expr{x} and @expr{y} are uncorrelated. |
d7b8e6c6 EZ |
11589 | A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)} |
11590 | is not the same as @samp{(2 +/- 1)^2}; the former represents the product | |
11591 | of two independent values which happen to have the same probability | |
11592 | distributions, and the latter is the product of one random value with itself. | |
11593 | The former will produce an answer with less error, since on the average | |
a4231b04 | 11594 | the two independent errors can be expected to cancel out. |
d7b8e6c6 EZ |
11595 | |
11596 | Consult a good text on error analysis for a discussion of the proper use | |
11597 | of standard deviations. Actual errors often are neither Gaussian-distributed | |
11598 | nor uncorrelated, and the above formulas are valid only when errors | |
11599 | are small. As an example, the error arising from | |
bd712b70 JB |
11600 | @texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}' |
11601 | @infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}' | |
a4231b04 | 11602 | is |
bd712b70 JB |
11603 | @texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'. |
11604 | @infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'. | |
a4231b04 | 11605 | When @expr{x} is close to zero, |
8e04863e | 11606 | @texline @math{\cos x} |
a4231b04 JB |
11607 | @infoline @expr{cos(x)} |
11608 | is close to one so the error in the sine is close to | |
8e04863e | 11609 | @texline @math{\sigma}; |
a4231b04 JB |
11610 | @infoline @expr{sigma}; |
11611 | this makes sense, since | |
8e04863e | 11612 | @texline @math{\sin x} |
a4231b04 JB |
11613 | @infoline @expr{sin(x)} |
11614 | is approximately @expr{x} near zero, so a given error in @expr{x} will | |
11615 | produce about the same error in the sine. Likewise, near 90 degrees | |
8e04863e | 11616 | @texline @math{\cos x} |
a4231b04 JB |
11617 | @infoline @expr{cos(x)} |
11618 | is nearly zero and so the computed error is | |
11619 | small: The sine curve is nearly flat in that region, so an error in @expr{x} | |
11620 | has relatively little effect on the value of | |
8e04863e | 11621 | @texline @math{\sin x}. |
a4231b04 JB |
11622 | @infoline @expr{sin(x)}. |
11623 | However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so | |
11624 | Calc will report zero error! We get an obviously wrong result because | |
11625 | we have violated the small-error approximation underlying the error | |
11626 | analysis. If the error in @expr{x} had been small, the error in | |
8e04863e | 11627 | @texline @math{\sin x} |
a4231b04 JB |
11628 | @infoline @expr{sin(x)} |
11629 | would indeed have been negligible. | |
d7b8e6c6 | 11630 | |
5d67986c RS |
11631 | @ignore |
11632 | @mindex p | |
11633 | @end ignore | |
d7b8e6c6 EZ |
11634 | @kindex p (error forms) |
11635 | @tindex +/- | |
11636 | To enter an error form during regular numeric entry, use the @kbd{p} | |
11637 | (``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually | |
11638 | typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's | |
973a6d1b | 11639 | @kbd{+} command!) Within an algebraic formula, you can press @kbd{M-+} to |
d7b8e6c6 EZ |
11640 | type the @samp{+/-} symbol, or type it out by hand. |
11641 | ||
11642 | Error forms and complex numbers can be mixed; the formulas shown above | |
11643 | are used for complex numbers, too; note that if the error part evaluates | |
11644 | to a complex number its absolute value (or the square root of the sum of | |
11645 | the squares of the absolute values of the two error contributions) is | |
11646 | used. Mathematically, this corresponds to a radially symmetric Gaussian | |
11647 | distribution of numbers on the complex plane. However, note that Calc | |
11648 | considers an error form with real components to represent a real number, | |
11649 | not a complex distribution around a real mean. | |
11650 | ||
11651 | Error forms may also be composed of HMS forms. For best results, both | |
11652 | the mean and the error should be HMS forms if either one is. | |
11653 | ||
5d67986c RS |
11654 | @ignore |
11655 | @starindex | |
11656 | @end ignore | |
d7b8e6c6 EZ |
11657 | @tindex sdev |
11658 | The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}. | |
11659 | ||
11660 | @node Interval Forms, Incomplete Objects, Error Forms, Data Types | |
11661 | @section Interval Forms | |
11662 | ||
11663 | @noindent | |
11664 | @cindex Interval forms | |
11665 | An @dfn{interval} is a subset of consecutive real numbers. For example, | |
11666 | the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4, | |
11667 | inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you | |
11668 | obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if | |
11669 | you multiply some number in the range @samp{[2 ..@: 4]} by some other | |
11670 | number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range | |
11671 | from 1 to 8. Interval arithmetic is used to get a worst-case estimate | |
11672 | of the possible range of values a computation will produce, given the | |
11673 | set of possible values of the input. | |
11674 | ||
11675 | @ifinfo | |
11676 | Calc supports several varieties of intervals, including @dfn{closed} | |
11677 | intervals of the type shown above, @dfn{open} intervals such as | |
11678 | @samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4 | |
11679 | @emph{exclusive}, and @dfn{semi-open} intervals in which one end | |
11680 | uses a round parenthesis and the other a square bracket. In mathematical | |
11681 | terms, | |
a4231b04 JB |
11682 | @samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas |
11683 | @samp{[2 ..@: 4)} represents @expr{2 <= x < 4}, | |
11684 | @samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and | |
11685 | @samp{(2 ..@: 4)} represents @expr{2 < x < 4}. | |
d7b8e6c6 EZ |
11686 | @end ifinfo |
11687 | @tex | |
11688 | Calc supports several varieties of intervals, including \dfn{closed} | |
11689 | intervals of the type shown above, \dfn{open} intervals such as | |
11690 | \samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4 | |
11691 | \emph{exclusive}, and \dfn{semi-open} intervals in which one end | |
11692 | uses a round parenthesis and the other a square bracket. In mathematical | |
11693 | terms, | |
11694 | $$ \eqalign{ | |
11695 | [2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr | |
11696 | [2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr | |
11697 | (2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr | |
11698 | (2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr | |
11699 | } $$ | |
11700 | @end tex | |
11701 | ||
11702 | The lower and upper limits of an interval must be either real numbers | |
11703 | (or HMS or date forms), or symbolic expressions which are assumed to be | |
11704 | real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit | |
11705 | must be less than the upper limit. A closed interval containing only | |
11706 | one value, @samp{[3 ..@: 3]}, is converted to a plain number (3) | |
11707 | automatically. An interval containing no values at all (such as | |
11708 | @samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not | |
11709 | guaranteed to behave well when used in arithmetic. Note that the | |
11710 | interval @samp{[3 .. inf)} represents all real numbers greater than | |
11711 | or equal to 3, and @samp{(-inf .. inf)} represents all real numbers. | |
11712 | In fact, @samp{[-inf .. inf]} represents all real numbers including | |
11713 | the real infinities. | |
11714 | ||
11715 | Intervals are entered in the notation shown here, either as algebraic | |
11716 | formulas, or using incomplete forms. (@xref{Incomplete Objects}.) | |
11717 | In algebraic formulas, multiple periods in a row are collected from | |
11718 | left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2} | |
11719 | rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to | |
11720 | get the other interpretation. If you omit the lower or upper limit, | |
11721 | a default of @samp{-inf} or @samp{inf} (respectively) is furnished. | |
11722 | ||
07ce2eb3 | 11723 | Infinite mode also affects operations on intervals |
d7b8e6c6 EZ |
11724 | (@pxref{Infinities}). Calc will always introduce an open infinity, |
11725 | as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities, | |
07ce2eb3 | 11726 | @w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode; |
d7b8e6c6 EZ |
11727 | otherwise they are left unevaluated. Note that the ``direction'' of |
11728 | a zero is not an issue in this case since the zero is always assumed | |
11729 | to be continuous with the rest of the interval. For intervals that | |
11730 | contain zero inside them Calc is forced to give the result, | |
11731 | @samp{1 / (-2 .. 2) = [-inf .. inf]}. | |
11732 | ||
11733 | While it may seem that intervals and error forms are similar, they are | |
11734 | based on entirely different concepts of inexact quantities. An error | |
a4231b04 | 11735 | form |
bd712b70 JB |
11736 | @texline `@var{x} @tfn{+/-} @math{\sigma}' |
11737 | @infoline `@var{x} @tfn{+/-} @var{sigma}' | |
a4231b04 JB |
11738 | means a variable is random, and its value could |
11739 | be anything but is ``probably'' within one | |
8e04863e | 11740 | @texline @math{\sigma} |
a4231b04 JB |
11741 | @infoline @var{sigma} |
11742 | of the mean value @expr{x}. An interval | |
bd712b70 | 11743 | `@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a |
a4231b04 JB |
11744 | variable's value is unknown, but guaranteed to lie in the specified |
11745 | range. Error forms are statistical or ``average case'' approximations; | |
11746 | interval arithmetic tends to produce ``worst case'' bounds on an | |
11747 | answer. | |
d7b8e6c6 EZ |
11748 | |
11749 | Intervals may not contain complex numbers, but they may contain | |
11750 | HMS forms or date forms. | |
11751 | ||
11752 | @xref{Set Operations}, for commands that interpret interval forms | |
11753 | as subsets of the set of real numbers. | |
11754 | ||
5d67986c RS |
11755 | @ignore |
11756 | @starindex | |
11757 | @end ignore | |
d7b8e6c6 EZ |
11758 | @tindex intv |
11759 | The algebraic function @samp{intv(n, a, b)} builds an interval form | |
11760 | from @samp{a} to @samp{b}; @samp{n} is an integer code which must | |
11761 | be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or | |
11762 | 3 for @samp{[..]}. | |
11763 | ||
11764 | Please note that in fully rigorous interval arithmetic, care would be | |
11765 | taken to make sure that the computation of the lower bound rounds toward | |
11766 | minus infinity, while upper bound computations round toward plus | |
11767 | infinity. Calc's arithmetic always uses a round-to-nearest mode, | |
11768 | which means that roundoff errors could creep into an interval | |
11769 | calculation to produce intervals slightly smaller than they ought to | |
11770 | be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^} | |
11771 | should yield the interval @samp{[1..2]} again, but in fact it yields the | |
11772 | (slightly too small) interval @samp{[1..1.9999999]} due to roundoff | |
11773 | error. | |
11774 | ||
11775 | @node Incomplete Objects, Variables, Interval Forms, Data Types | |
11776 | @section Incomplete Objects | |
11777 | ||
11778 | @noindent | |
5d67986c RS |
11779 | @ignore |
11780 | @mindex [ ] | |
11781 | @end ignore | |
d7b8e6c6 | 11782 | @kindex [ |
5d67986c RS |
11783 | @ignore |
11784 | @mindex ( ) | |
11785 | @end ignore | |
d7b8e6c6 EZ |
11786 | @kindex ( |
11787 | @kindex , | |
5d67986c RS |
11788 | @ignore |
11789 | @mindex @null | |
11790 | @end ignore | |
d7b8e6c6 | 11791 | @kindex ] |
5d67986c RS |
11792 | @ignore |
11793 | @mindex @null | |
11794 | @end ignore | |
d7b8e6c6 EZ |
11795 | @kindex ) |
11796 | @cindex Incomplete vectors | |
11797 | @cindex Incomplete complex numbers | |
11798 | @cindex Incomplete interval forms | |
11799 | When @kbd{(} or @kbd{[} is typed to begin entering a complex number or | |
11800 | vector, respectively, the effect is to push an @dfn{incomplete} complex | |
11801 | number or vector onto the stack. The @kbd{,} key adds the value(s) at | |
11802 | the top of the stack onto the current incomplete object. The @kbd{)} | |
11803 | and @kbd{]} keys ``close'' the incomplete object after adding any values | |
11804 | on the top of the stack in front of the incomplete object. | |
11805 | ||
11806 | As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]} | |
11807 | pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )} | |
11808 | pushes the complex number @samp{(1, 1.414)} (approximately). | |
11809 | ||
11810 | If several values lie on the stack in front of the incomplete object, | |
11811 | all are collected and appended to the object. Thus the @kbd{,} key | |
11812 | is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people | |
a4231b04 | 11813 | prefer the equivalent @key{SPC} key to @key{RET}. |
d7b8e6c6 EZ |
11814 | |
11815 | As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or | |
11816 | @kbd{,} adds a zero or duplicates the preceding value in the list being | |
11817 | formed. Typing @key{DEL} during incomplete entry removes the last item | |
11818 | from the list. | |
11819 | ||
11820 | @kindex ; | |
11821 | The @kbd{;} key is used in the same way as @kbd{,} to create polar complex | |
11822 | numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for | |
11823 | creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is | |
11824 | equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}. | |
11825 | ||
11826 | @kindex .. | |
11827 | @pindex calc-dots | |
11828 | Incomplete entry is also used to enter intervals. For example, | |
11829 | @kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type | |
11830 | the first period, it will be interpreted as a decimal point, but when | |
11831 | you type a second period immediately afterward, it is re-interpreted as | |
11832 | part of the interval symbol. Typing @kbd{..} corresponds to executing | |
11833 | the @code{calc-dots} command. | |
11834 | ||
11835 | If you find incomplete entry distracting, you may wish to enter vectors | |
11836 | and complex numbers as algebraic formulas by pressing the apostrophe key. | |
11837 | ||
11838 | @node Variables, Formulas, Incomplete Objects, Data Types | |
11839 | @section Variables | |
11840 | ||
11841 | @noindent | |
11842 | @cindex Variables, in formulas | |
11843 | A @dfn{variable} is somewhere between a storage register on a conventional | |
11844 | calculator, and a variable in a programming language. (In fact, a Calc | |
11845 | variable is really just an Emacs Lisp variable that contains a Calc number | |
11846 | or formula.) A variable's name is normally composed of letters and digits. | |
11847 | Calc also allows apostrophes and @code{#} signs in variable names. | |
4f38ed98 JB |
11848 | (The Calc variable @code{foo} corresponds to the Emacs Lisp variable |
11849 | @code{var-foo}, but unless you access the variable from within Emacs | |
a2db4c6b JB |
11850 | Lisp, you don't need to worry about it. Variable names in algebraic |
11851 | formulas implicitly have @samp{var-} prefixed to their names. The | |
11852 | @samp{#} character in variable names used in algebraic formulas | |
11853 | corresponds to a dash @samp{-} in the Lisp variable name. If the name | |
11854 | contains any dashes, the prefix @samp{var-} is @emph{not} automatically | |
11855 | added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both | |
11856 | refer to the same variable.) | |
d7b8e6c6 EZ |
11857 | |
11858 | In a command that takes a variable name, you can either type the full | |
11859 | name of a variable, or type a single digit to use one of the special | |
4f38ed98 JB |
11860 | convenience variables @code{q0} through @code{q9}. For example, |
11861 | @kbd{3 s s 2} stores the number 3 in variable @code{q2}, and | |
d7b8e6c6 | 11862 | @w{@kbd{3 s s foo @key{RET}}} stores that number in variable |
4f38ed98 | 11863 | @code{foo}. |
d7b8e6c6 EZ |
11864 | |
11865 | To push a variable itself (as opposed to the variable's value) on the | |
11866 | stack, enter its name as an algebraic expression using the apostrophe | |
4f38ed98 JB |
11867 | (@key{'}) key. |
11868 | ||
d7b8e6c6 EZ |
11869 | @kindex = |
11870 | @pindex calc-evaluate | |
11871 | @cindex Evaluation of variables in a formula | |
11872 | @cindex Variables, evaluation | |
11873 | @cindex Formulas, evaluation | |
11874 | The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by | |
11875 | replacing all variables in the formula which have been given values by a | |
11876 | @code{calc-store} or @code{calc-let} command by their stored values. | |
11877 | Other variables are left alone. Thus a variable that has not been | |
11878 | stored acts like an abstract variable in algebra; a variable that has | |
11879 | been stored acts more like a register in a traditional calculator. | |
11880 | With a positive numeric prefix argument, @kbd{=} evaluates the top | |
11881 | @var{n} stack entries; with a negative argument, @kbd{=} evaluates | |
11882 | the @var{n}th stack entry. | |
11883 | ||
11884 | @cindex @code{e} variable | |
11885 | @cindex @code{pi} variable | |
11886 | @cindex @code{i} variable | |
11887 | @cindex @code{phi} variable | |
11888 | @cindex @code{gamma} variable | |
11889 | @vindex e | |
11890 | @vindex pi | |
11891 | @vindex i | |
11892 | @vindex phi | |
11893 | @vindex gamma | |
11894 | A few variables are called @dfn{special constants}. Their names are | |
11895 | @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}. | |
11896 | (@xref{Scientific Functions}.) When they are evaluated with @kbd{=}, | |
11897 | their values are calculated if necessary according to the current precision | |
11898 | or complex polar mode. If you wish to use these symbols for other purposes, | |
a4231b04 | 11899 | simply undefine or redefine them using @code{calc-store}. |
d7b8e6c6 EZ |
11900 | |
11901 | The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for | |
11902 | infinite or indeterminate values. It's best not to use them as | |
11903 | regular variables, since Calc uses special algebraic rules when | |
11904 | it manipulates them. Calc displays a warning message if you store | |
11905 | a value into any of these special variables. | |
11906 | ||
11907 | @xref{Store and Recall}, for a discussion of commands dealing with variables. | |
11908 | ||
11909 | @node Formulas, , Variables, Data Types | |
11910 | @section Formulas | |
11911 | ||
11912 | @noindent | |
11913 | @cindex Formulas | |
11914 | @cindex Expressions | |
11915 | @cindex Operators in formulas | |
11916 | @cindex Precedence of operators | |
11917 | When you press the apostrophe key you may enter any expression or formula | |
11918 | in algebraic form. (Calc uses the terms ``expression'' and ``formula'' | |
11919 | interchangeably.) An expression is built up of numbers, variable names, | |
11920 | and function calls, combined with various arithmetic operators. | |
11921 | Parentheses may | |
11922 | be used to indicate grouping. Spaces are ignored within formulas, except | |
11923 | that spaces are not permitted within variable names or numbers. | |
11924 | Arithmetic operators, in order from highest to lowest precedence, and | |
11925 | with their equivalent function names, are: | |
11926 | ||
11927 | @samp{_} [@code{subscr}] (subscripts); | |
11928 | ||
11929 | postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25}); | |
11930 | ||
11931 | prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x}) | |
11932 | and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x}); | |
11933 | ||
11934 | @samp{+/-} [@code{sdev}] (the standard deviation symbol) and | |
11935 | @samp{mod} [@code{makemod}] (the symbol for modulo forms); | |
11936 | ||
11937 | postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!}) | |
11938 | and postfix @samp{!!} [@code{dfact}] (double factorial); | |
11939 | ||
11940 | @samp{^} [@code{pow}] (raised-to-the-power-of); | |
11941 | ||
11942 | @samp{*} [@code{mul}]; | |
11943 | ||
11944 | @samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and | |
11945 | @samp{\} [@code{idiv}] (integer division); | |
11946 | ||
11947 | infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y}); | |
11948 | ||
11949 | @samp{|} [@code{vconcat}] (vector concatenation); | |
11950 | ||
11951 | relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}], | |
11952 | @samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}]; | |
11953 | ||
11954 | @samp{&&} [@code{land}] (logical ``and''); | |
11955 | ||
11956 | @samp{||} [@code{lor}] (logical ``or''); | |
11957 | ||
11958 | the C-style ``if'' operator @samp{a?b:c} [@code{if}]; | |
11959 | ||
11960 | @samp{!!!} [@code{pnot}] (rewrite pattern ``not''); | |
11961 | ||
11962 | @samp{&&&} [@code{pand}] (rewrite pattern ``and''); | |
11963 | ||
11964 | @samp{|||} [@code{por}] (rewrite pattern ``or''); | |
11965 | ||
11966 | @samp{:=} [@code{assign}] (for assignments and rewrite rules); | |
11967 | ||
11968 | @samp{::} [@code{condition}] (rewrite pattern condition); | |
11969 | ||
11970 | @samp{=>} [@code{evalto}]. | |
11971 | ||
11972 | Note that, unlike in usual computer notation, multiplication binds more | |
a4231b04 | 11973 | strongly than division: @samp{a*b/c*d} is equivalent to |
8e04863e | 11974 | @texline @math{a b \over c d}. |
a4231b04 | 11975 | @infoline @expr{(a*b)/(c*d)}. |
d7b8e6c6 EZ |
11976 | |
11977 | @cindex Multiplication, implicit | |
11978 | @cindex Implicit multiplication | |
11979 | The multiplication sign @samp{*} may be omitted in many cases. In particular, | |
11980 | if the righthand side is a number, variable name, or parenthesized | |
11981 | expression, the @samp{*} may be omitted. Implicit multiplication has the | |
11982 | same precedence as the explicit @samp{*} operator. The one exception to | |
11983 | the rule is that a variable name followed by a parenthesized expression, | |
11984 | as in @samp{f(x)}, | |
11985 | is interpreted as a function call, not an implicit @samp{*}. In many | |
11986 | cases you must use a space if you omit the @samp{*}: @samp{2a} is the | |
11987 | same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab} | |
11988 | is a variable called @code{ab}, @emph{not} the product of @samp{a} and | |
a4231b04 | 11989 | @samp{b}! Also note that @samp{f (x)} is still a function call. |
d7b8e6c6 EZ |
11990 | |
11991 | @cindex Implicit comma in vectors | |
11992 | The rules are slightly different for vectors written with square brackets. | |
11993 | In vectors, the space character is interpreted (like the comma) as a | |
11994 | separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is | |
11995 | equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent | |
11996 | to @samp{2*a*b + c*d}. | |
11997 | Note that spaces around the brackets, and around explicit commas, are | |
11998 | ignored. To force spaces to be interpreted as multiplication you can | |
11999 | enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is | |
12000 | interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted | |
a4231b04 | 12001 | between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}. |
d7b8e6c6 EZ |
12002 | |
12003 | Vectors that contain commas (not embedded within nested parentheses or | |
12004 | brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector | |
12005 | of two elements. Also, if it would be an error to treat spaces as | |
12006 | separators, but not otherwise, then Calc will ignore spaces: | |
12007 | @w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is | |
12008 | a vector of two elements. Finally, vectors entered with curly braces | |
12009 | instead of square brackets do not give spaces any special treatment. | |
12010 | When Calc displays a vector that does not contain any commas, it will | |
12011 | insert parentheses if necessary to make the meaning clear: | |
12012 | @w{@samp{[(a b)]}}. | |
12013 | ||
12014 | The expression @samp{5%-2} is ambiguous; is this five-percent minus two, | |
12015 | or five modulo minus-two? Calc always interprets the leftmost symbol as | |
12016 | an infix operator preferentially (modulo, in this case), so you would | |
12017 | need to write @samp{(5%)-2} to get the former interpretation. | |
12018 | ||
12019 | @cindex Function call notation | |
a2db4c6b JB |
12020 | A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function |
12021 | @code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo}, | |
12022 | but unless you access the function from within Emacs Lisp, you don't | |
12023 | need to worry about it.) Most mathematical Calculator commands like | |
d7b8e6c6 EZ |
12024 | @code{calc-sin} have function equivalents like @code{sin}. |
12025 | If no Lisp function is defined for a function called by a formula, the | |
12026 | call is left as it is during algebraic manipulation: @samp{f(x+y)} is | |
12027 | left alone. Beware that many innocent-looking short names like @code{in} | |
12028 | and @code{re} have predefined meanings which could surprise you; however, | |
12029 | single letters or single letters followed by digits are always safe to | |
a4231b04 | 12030 | use for your own function names. @xref{Function Index}. |
d7b8e6c6 EZ |
12031 | |
12032 | In the documentation for particular commands, the notation @kbd{H S} | |
12033 | (@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the | |
12034 | command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all | |
a4231b04 | 12035 | represent the same operation. |
d7b8e6c6 EZ |
12036 | |
12037 | Commands that interpret (``parse'') text as algebraic formulas include | |
12038 | algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse | |
58547c3e JB |
12039 | the contents of the editing buffer when you finish, the @kbd{C-x * g} |
12040 | and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system | |
07ce2eb3 | 12041 | ``paste'' mouse operation, and Embedded mode. All of these operations |
d7b8e6c6 EZ |
12042 | use the same rules for parsing formulas; in particular, language modes |
12043 | (@pxref{Language Modes}) affect them all in the same way. | |
12044 | ||
12045 | When you read a large amount of text into the Calculator (say a vector | |
12046 | which represents a big set of rewrite rules; @pxref{Rewrite Rules}), | |
12047 | you may wish to include comments in the text. Calc's formula parser | |
12048 | ignores the symbol @samp{%%} and anything following it on a line: | |
12049 | ||
12050 | @example | |
12051 | [ a + b, %% the sum of "a" and "b" | |
12052 | c + d, | |
12053 | %% last line is coming up: | |
12054 | e + f ] | |
12055 | @end example | |
12056 | ||
12057 | @noindent | |
12058 | This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}. | |
12059 | ||
12060 | @xref{Syntax Tables}, for a way to create your own operators and other | |
12061 | input notations. @xref{Compositions}, for a way to create new display | |
12062 | formats. | |
12063 | ||
12064 | @xref{Algebra}, for commands for manipulating formulas symbolically. | |
12065 | ||
12066 | @node Stack and Trail, Mode Settings, Data Types, Top | |
12067 | @chapter Stack and Trail Commands | |
12068 | ||
12069 | @noindent | |
12070 | This chapter describes the Calc commands for manipulating objects on the | |
12071 | stack and in the trail buffer. (These commands operate on objects of any | |
12072 | type, such as numbers, vectors, formulas, and incomplete objects.) | |
12073 | ||
12074 | @menu | |
12075 | * Stack Manipulation:: | |
12076 | * Editing Stack Entries:: | |
12077 | * Trail Commands:: | |
12078 | * Keep Arguments:: | |
12079 | @end menu | |
12080 | ||
12081 | @node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail | |
12082 | @section Stack Manipulation Commands | |
12083 | ||
12084 | @noindent | |
5d67986c RS |
12085 | @kindex @key{RET} |
12086 | @kindex @key{SPC} | |
d7b8e6c6 EZ |
12087 | @pindex calc-enter |
12088 | @cindex Duplicating stack entries | |
12089 | To duplicate the top object on the stack, press @key{RET} or @key{SPC} | |
12090 | (two equivalent keys for the @code{calc-enter} command). | |
12091 | Given a positive numeric prefix argument, these commands duplicate | |
12092 | several elements at the top of the stack. | |
12093 | Given a negative argument, | |
12094 | these commands duplicate the specified element of the stack. | |
12095 | Given an argument of zero, they duplicate the entire stack. | |
12096 | For example, with @samp{10 20 30} on the stack, | |
12097 | @key{RET} creates @samp{10 20 30 30}, | |
12098 | @kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30}, | |
12099 | @kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and | |
a4231b04 | 12100 | @kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}. |
d7b8e6c6 | 12101 | |
5d67986c | 12102 | @kindex @key{LFD} |
d7b8e6c6 EZ |
12103 | @pindex calc-over |
12104 | The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you | |
12105 | have it, else on @kbd{C-j}) is like @code{calc-enter} | |
12106 | except that the sign of the numeric prefix argument is interpreted | |
12107 | oppositely. Also, with no prefix argument the default argument is 2. | |
12108 | Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}} | |
12109 | are both equivalent to @kbd{C-u - 2 @key{RET}}, producing | |
a4231b04 | 12110 | @samp{10 20 30 20}. |
d7b8e6c6 | 12111 | |
5d67986c | 12112 | @kindex @key{DEL} |
d7b8e6c6 EZ |
12113 | @kindex C-d |
12114 | @pindex calc-pop | |
12115 | @cindex Removing stack entries | |
12116 | @cindex Deleting stack entries | |
12117 | To remove the top element from the stack, press @key{DEL} (@code{calc-pop}). | |
12118 | The @kbd{C-d} key is a synonym for @key{DEL}. | |
12119 | (If the top element is an incomplete object with at least one element, the | |
12120 | last element is removed from it.) Given a positive numeric prefix argument, | |
12121 | several elements are removed. Given a negative argument, the specified | |
12122 | element of the stack is deleted. Given an argument of zero, the entire | |
12123 | stack is emptied. | |
12124 | For example, with @samp{10 20 30} on the stack, | |
12125 | @key{DEL} leaves @samp{10 20}, | |
12126 | @kbd{C-u 2 @key{DEL}} leaves @samp{10}, | |
12127 | @kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and | |
a4231b04 | 12128 | @kbd{C-u 0 @key{DEL}} leaves an empty stack. |
d7b8e6c6 | 12129 | |
5d67986c | 12130 | @kindex M-@key{DEL} |
d7b8e6c6 | 12131 | @pindex calc-pop-above |
0d48e8aa | 12132 | The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what |
d7b8e6c6 EZ |
12133 | @key{LFD} is to @key{RET}: It interprets the sign of the numeric |
12134 | prefix argument in the opposite way, and the default argument is 2. | |
0d48e8aa | 12135 | Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element, |
5d67986c | 12136 | leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes |
d7b8e6c6 EZ |
12137 | the third stack element. |
12138 | ||
5d67986c | 12139 | @kindex @key{TAB} |
d7b8e6c6 EZ |
12140 | @pindex calc-roll-down |
12141 | To exchange the top two elements of the stack, press @key{TAB} | |
12142 | (@code{calc-roll-down}). Given a positive numeric prefix argument, the | |
12143 | specified number of elements at the top of the stack are rotated downward. | |
12144 | Given a negative argument, the entire stack is rotated downward the specified | |
12145 | number of times. Given an argument of zero, the entire stack is reversed | |
12146 | top-for-bottom. | |
12147 | For example, with @samp{10 20 30 40 50} on the stack, | |
12148 | @key{TAB} creates @samp{10 20 30 50 40}, | |
12149 | @kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40}, | |
12150 | @kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and | |
a4231b04 | 12151 | @kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}. |
d7b8e6c6 | 12152 | |
5d67986c | 12153 | @kindex M-@key{TAB} |
d7b8e6c6 | 12154 | @pindex calc-roll-up |
5d67986c | 12155 | The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB} |
d7b8e6c6 EZ |
12156 | except that it rotates upward instead of downward. Also, the default |
12157 | with no prefix argument is to rotate the top 3 elements. | |
12158 | For example, with @samp{10 20 30 40 50} on the stack, | |
5d67986c RS |
12159 | @kbd{M-@key{TAB}} creates @samp{10 20 40 50 30}, |
12160 | @kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20}, | |
12161 | @kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and | |
a4231b04 | 12162 | @kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}. |
d7b8e6c6 | 12163 | |
5d67986c | 12164 | A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in |
d7b8e6c6 | 12165 | terms of moving a particular element to a new position in the stack. |
5d67986c RS |
12166 | With a positive argument @var{n}, @key{TAB} moves the top stack |
12167 | element down to level @var{n}, making room for it by pulling all the | |
12168 | intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the | |
12169 | element at level @var{n} up to the top. (Compare with @key{LFD}, | |
12170 | which copies instead of moving the element in level @var{n}.) | |
12171 | ||
8e04863e | 12172 | With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack |
5d67986c | 12173 | to move the object in level @var{n} to the deepest place in the |
8e04863e JB |
12174 | stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}} |
12175 | rotates the deepest stack element to be in level @mathit{n}, also | |
12176 | putting the top stack element in level @mathit{@var{n}+1}. | |
d7b8e6c6 EZ |
12177 | |
12178 | @xref{Selecting Subformulas}, for a way to apply these commands to | |
12179 | any portion of a vector or formula on the stack. | |
12180 | ||
12181 | @node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail | |
12182 | @section Editing Stack Entries | |
12183 | ||
12184 | @noindent | |
12185 | @kindex ` | |
12186 | @pindex calc-edit | |
12187 | @pindex calc-edit-finish | |
12188 | @cindex Editing the stack with Emacs | |
12189 | The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary | |
12190 | buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using | |
12191 | regular Emacs commands. With a numeric prefix argument, it edits the | |
12192 | specified number of stack entries at once. (An argument of zero edits | |
12193 | the entire stack; a negative argument edits one specific stack entry.) | |
12194 | ||
33108698 | 12195 | When you are done editing, press @kbd{C-c C-c} to finish and return |
d7b8e6c6 EZ |
12196 | to Calc. The @key{RET} and @key{LFD} keys also work to finish most |
12197 | sorts of editing, though in some cases Calc leaves @key{RET} with its | |
12198 | usual meaning (``insert a newline'') if it's a situation where you | |
33108698 | 12199 | might want to insert new lines into the editing buffer. |
d7b8e6c6 EZ |
12200 | |
12201 | When you finish editing, the Calculator parses the lines of text in | |
12202 | the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the | |
12203 | original stack elements in the original buffer with these new values, | |
12204 | then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer | |
12205 | continues to exist during editing, but for best results you should be | |
12206 | careful not to change it until you have finished the edit. You can | |
33108698 | 12207 | also cancel the edit by killing the buffer with @kbd{C-x k}. |
d7b8e6c6 EZ |
12208 | |
12209 | The formula is normally reevaluated as it is put onto the stack. | |
12210 | For example, editing @samp{a + 2} to @samp{3 + 2} and pressing | |
33108698 | 12211 | @kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to |
d7b8e6c6 EZ |
12212 | finish, Calc will put the result on the stack without evaluating it. |
12213 | ||
33108698 | 12214 | If you give a prefix argument to @kbd{C-c C-c}, |
d7b8e6c6 EZ |
12215 | Calc will not kill the @samp{*Calc Edit*} buffer. You can switch |
12216 | back to that buffer and continue editing if you wish. However, you | |
12217 | should understand that if you initiated the edit with @kbd{`}, the | |
33108698 | 12218 | @kbd{C-c C-c} operation will be programmed to replace the top of the |
d7b8e6c6 EZ |
12219 | stack with the new edited value, and it will do this even if you have |
12220 | rearranged the stack in the meanwhile. This is not so much of a problem | |
12221 | with other editing commands, though, such as @kbd{s e} | |
12222 | (@code{calc-edit-variable}; @pxref{Operations on Variables}). | |
12223 | ||
12224 | If the @code{calc-edit} command involves more than one stack entry, | |
12225 | each line of the @samp{*Calc Edit*} buffer is interpreted as a | |
12226 | separate formula. Otherwise, the entire buffer is interpreted as | |
12227 | one formula, with line breaks ignored. (You can use @kbd{C-o} or | |
12228 | @kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.) | |
12229 | ||
12230 | The @kbd{`} key also works during numeric or algebraic entry. The | |
12231 | text entered so far is moved to the @code{*Calc Edit*} buffer for | |
12232 | more extensive editing than is convenient in the minibuffer. | |
12233 | ||
12234 | @node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail | |
12235 | @section Trail Commands | |
12236 | ||
12237 | @noindent | |
12238 | @cindex Trail buffer | |
12239 | The commands for manipulating the Calc Trail buffer are two-key sequences | |
12240 | beginning with the @kbd{t} prefix. | |
12241 | ||
12242 | @kindex t d | |
12243 | @pindex calc-trail-display | |
12244 | The @kbd{t d} (@code{calc-trail-display}) command turns display of the | |
12245 | trail on and off. Normally the trail display is toggled on if it was off, | |
12246 | off if it was on. With a numeric prefix of zero, this command always | |
12247 | turns the trail off; with a prefix of one, it always turns the trail on. | |
12248 | The other trail-manipulation commands described here automatically turn | |
12249 | the trail on. Note that when the trail is off values are still recorded | |
12250 | there; they are simply not displayed. To set Emacs to turn the trail | |
12251 | off by default, type @kbd{t d} and then save the mode settings with | |
12252 | @kbd{m m} (@code{calc-save-modes}). | |
12253 | ||
12254 | @kindex t i | |
12255 | @pindex calc-trail-in | |
12256 | @kindex t o | |
12257 | @pindex calc-trail-out | |
12258 | The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o} | |
12259 | (@code{calc-trail-out}) commands switch the cursor into and out of the | |
12260 | Calc Trail window. In practice they are rarely used, since the commands | |
12261 | shown below are a more convenient way to move around in the | |
12262 | trail, and they work ``by remote control'' when the cursor is still | |
a4231b04 | 12263 | in the Calculator window. |
d7b8e6c6 EZ |
12264 | |
12265 | @cindex Trail pointer | |
12266 | There is a @dfn{trail pointer} which selects some entry of the trail at | |
12267 | any given time. The trail pointer looks like a @samp{>} symbol right | |
12268 | before the selected number. The following commands operate on the | |
12269 | trail pointer in various ways. | |
12270 | ||
12271 | @kindex t y | |
12272 | @pindex calc-trail-yank | |
12273 | @cindex Retrieving previous results | |
12274 | The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in | |
12275 | the trail and pushes it onto the Calculator stack. It allows you to | |
12276 | re-use any previously computed value without retyping. With a numeric | |
12277 | prefix argument @var{n}, it yanks the value @var{n} lines above the current | |
12278 | trail pointer. | |
12279 | ||
12280 | @kindex t < | |
12281 | @pindex calc-trail-scroll-left | |
12282 | @kindex t > | |
12283 | @pindex calc-trail-scroll-right | |
12284 | The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >} | |
12285 | (@code{calc-trail-scroll-right}) commands horizontally scroll the trail | |
a4231b04 | 12286 | window left or right by one half of its width. |
d7b8e6c6 EZ |
12287 | |
12288 | @kindex t n | |
12289 | @pindex calc-trail-next | |
12290 | @kindex t p | |
12291 | @pindex calc-trail-previous | |
12292 | @kindex t f | |
12293 | @pindex calc-trail-forward | |
12294 | @kindex t b | |
12295 | @pindex calc-trail-backward | |
12296 | The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p} | |
12297 | (@code{calc-trail-previous)} commands move the trail pointer down or up | |
12298 | one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b} | |
12299 | (@code{calc-trail-backward}) commands move the trail pointer down or up | |
12300 | one screenful at a time. All of these commands accept numeric prefix | |
a4231b04 | 12301 | arguments to move several lines or screenfuls at a time. |
d7b8e6c6 EZ |
12302 | |
12303 | @kindex t [ | |
12304 | @pindex calc-trail-first | |
12305 | @kindex t ] | |
12306 | @pindex calc-trail-last | |
12307 | @kindex t h | |
12308 | @pindex calc-trail-here | |
12309 | The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]} | |
12310 | (@code{calc-trail-last}) commands move the trail pointer to the first or | |
12311 | last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command | |
12312 | moves the trail pointer to the cursor position; unlike the other trail | |
a4231b04 | 12313 | commands, @kbd{t h} works only when Calc Trail is the selected window. |
d7b8e6c6 EZ |
12314 | |
12315 | @kindex t s | |
12316 | @pindex calc-trail-isearch-forward | |
12317 | @kindex t r | |
12318 | @pindex calc-trail-isearch-backward | |
12319 | @ifinfo | |
12320 | The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} | |
12321 | (@code{calc-trail-isearch-backward}) commands perform an incremental | |
12322 | search forward or backward through the trail. You can press @key{RET} | |
12323 | to terminate the search; the trail pointer moves to the current line. | |
12324 | If you cancel the search with @kbd{C-g}, the trail pointer stays where | |
a4231b04 | 12325 | it was when the search began. |
d7b8e6c6 EZ |
12326 | @end ifinfo |
12327 | @tex | |
12328 | The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r} | |
12329 | (@code{calc-trail-isearch-backward}) com\-mands perform an incremental | |
12330 | search forward or backward through the trail. You can press @key{RET} | |
12331 | to terminate the search; the trail pointer moves to the current line. | |
12332 | If you cancel the search with @kbd{C-g}, the trail pointer stays where | |
12333 | it was when the search began. | |
12334 | @end tex | |
12335 | ||
12336 | @kindex t m | |
12337 | @pindex calc-trail-marker | |
12338 | The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a | |
12339 | line of text of your own choosing into the trail. The text is inserted | |
12340 | after the line containing the trail pointer; this usually means it is | |
12341 | added to the end of the trail. Trail markers are useful mainly as the | |
12342 | targets for later incremental searches in the trail. | |
12343 | ||
12344 | @kindex t k | |
12345 | @pindex calc-trail-kill | |
12346 | The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line | |
12347 | from the trail. The line is saved in the Emacs kill ring suitable for | |
12348 | yanking into another buffer, but it is not easy to yank the text back | |
12349 | into the trail buffer. With a numeric prefix argument, this command | |
12350 | kills the @var{n} lines below or above the selected one. | |
12351 | ||
12352 | The @kbd{t .} (@code{calc-full-trail-vectors}) command is described | |
12353 | elsewhere; @pxref{Vector and Matrix Formats}. | |
12354 | ||
12355 | @node Keep Arguments, , Trail Commands, Stack and Trail | |
12356 | @section Keep Arguments | |
12357 | ||
12358 | @noindent | |
12359 | @kindex K | |
12360 | @pindex calc-keep-args | |
12361 | The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for | |
12362 | the following command. It prevents that command from removing its | |
12363 | arguments from the stack. For example, after @kbd{2 @key{RET} 3 +}, | |
12364 | the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +}, | |
12365 | the stack contains the arguments and the result: @samp{2 3 5}. | |
12366 | ||
11e81923 JB |
12367 | With the exception of keyboard macros, this works for all commands that |
12368 | take arguments off the stack. (To avoid potentially unpleasant behavior, | |
8423891c JB |
12369 | a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K} |
12370 | prefix called @emph{within} the keyboard macro will still take effect.) | |
12371 | As another example, @kbd{K a s} simplifies a formula, pushing the | |
12372 | simplified version of the formula onto the stack after the original | |
12373 | formula (rather than replacing the original formula). Note that you | |
12374 | could get the same effect by typing @kbd{@key{RET} a s}, copying the | |
12375 | formula and then simplifying the copy. One difference is that for a very | |
12376 | large formula the time taken to format the intermediate copy in | |
12377 | @kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this | |
12378 | extra work. | |
d7b8e6c6 EZ |
12379 | |
12380 | Even stack manipulation commands are affected. @key{TAB} works by | |
12381 | popping two values and pushing them back in the opposite order, | |
12382 | so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}. | |
12383 | ||
12384 | A few Calc commands provide other ways of doing the same thing. | |
12385 | For example, @kbd{' sin($)} replaces the number on the stack with | |
12386 | its sine using algebraic entry; to push the sine and keep the | |
12387 | original argument you could use either @kbd{' sin($1)} or | |
12388 | @kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s} | |
12389 | command is effectively the same as @kbd{K s t}. @xref{Storing Variables}. | |
12390 | ||
d7b8e6c6 EZ |
12391 | If you execute a command and then decide you really wanted to keep |
12392 | the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}). | |
12393 | This command pushes the last arguments that were popped by any command | |
12394 | onto the stack. Note that the order of things on the stack will be | |
12395 | different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves | |
12396 | @samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}. | |
12397 | ||
12398 | @node Mode Settings, Arithmetic, Stack and Trail, Top | |
12399 | @chapter Mode Settings | |
12400 | ||
12401 | @noindent | |
12402 | This chapter describes commands that set modes in the Calculator. | |
12403 | They do not affect the contents of the stack, although they may change | |
12404 | the @emph{appearance} or @emph{interpretation} of the stack's contents. | |
12405 | ||
12406 | @menu | |
12407 | * General Mode Commands:: | |
12408 | * Precision:: | |
12409 | * Inverse and Hyperbolic:: | |
12410 | * Calculation Modes:: | |
12411 | * Simplification Modes:: | |
12412 | * Declarations:: | |
12413 | * Display Modes:: | |
12414 | * Language Modes:: | |
12415 | * Modes Variable:: | |
12416 | * Calc Mode Line:: | |
12417 | @end menu | |
12418 | ||
12419 | @node General Mode Commands, Precision, Mode Settings, Mode Settings | |
12420 | @section General Mode Commands | |
12421 | ||
12422 | @noindent | |
12423 | @kindex m m | |
12424 | @pindex calc-save-modes | |
12425 | @cindex Continuous memory | |
12426 | @cindex Saving mode settings | |
12427 | @cindex Permanent mode settings | |
3b846359 JB |
12428 | @cindex Calc init file, mode settings |
12429 | You can save all of the current mode settings in your Calc init file | |
12430 | (the file given by the variable @code{calc-settings-file}, typically | |
12431 | @file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command. | |
12432 | This will cause Emacs to reestablish these modes each time it starts up. | |
12433 | The modes saved in the file include everything controlled by the @kbd{m} | |
12434 | and @kbd{d} prefix keys, the current precision and binary word size, | |
12435 | whether or not the trail is displayed, the current height of the Calc | |
58547c3e JB |
12436 | window, and more. The current interface (used when you type @kbd{C-x * *}) |
12437 | is also saved. If there were already saved mode settings in the | |
3b846359 JB |
12438 | file, they are replaced. Otherwise, the new mode information is |
12439 | appended to the end of the file. | |
d7b8e6c6 EZ |
12440 | |
12441 | @kindex m R | |
12442 | @pindex calc-mode-record-mode | |
12443 | The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to | |
35626cba JB |
12444 | record all the mode settings (as if by pressing @kbd{m m}) every |
12445 | time a mode setting changes. If the modes are saved this way, then this | |
12446 | ``automatic mode recording'' mode is also saved. | |
12447 | Type @kbd{m R} again to disable this method of recording the mode | |
12448 | settings. To turn it off permanently, the @kbd{m m} command will also be | |
12449 | necessary. (If Embedded mode is enabled, other options for recording | |
12450 | the modes are available; @pxref{Mode Settings in Embedded Mode}.) | |
d7b8e6c6 EZ |
12451 | |
12452 | @kindex m F | |
12453 | @pindex calc-settings-file-name | |
12454 | The @kbd{m F} (@code{calc-settings-file-name}) command allows you to | |
16085693 JB |
12455 | choose a different file than the current value of @code{calc-settings-file} |
12456 | for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information. | |
d7b8e6c6 EZ |
12457 | You are prompted for a file name. All Calc modes are then reset to |
12458 | their default values, then settings from the file you named are loaded | |
12459 | if this file exists, and this file becomes the one that Calc will | |
12460 | use in the future for commands like @kbd{m m}. The default settings | |
16085693 | 12461 | file name is @file{~/.calc.el}. You can see the current file name by |
d7b8e6c6 | 12462 | giving a blank response to the @kbd{m F} prompt. See also the |
58547c3e | 12463 | discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}. |
d7b8e6c6 | 12464 | |
16085693 JB |
12465 | If the file name you give is your user init file (typically |
12466 | @file{~/.emacs}), @kbd{m F} will not automatically load the new file. This | |
12467 | is because your user init file may contain other things you don't want | |
12468 | to reread. You can give | |
d7b8e6c6 | 12469 | a numeric prefix argument of 1 to @kbd{m F} to force it to read the |
16085693 | 12470 | file no matter what. Conversely, an argument of @mathit{-1} tells |
8e04863e | 12471 | @kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2} |
d7b8e6c6 EZ |
12472 | tells @kbd{m F} not to reset the modes to their defaults beforehand, |
12473 | which is useful if you intend your new file to have a variant of the | |
12474 | modes present in the file you were using before. | |
12475 | ||
12476 | @kindex m x | |
12477 | @pindex calc-always-load-extensions | |
12478 | The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode | |
12479 | in which the first use of Calc loads the entire program, including all | |
12480 | extensions modules. Otherwise, the extensions modules will not be loaded | |
12481 | until the various advanced Calc features are used. Since this mode only | |
12482 | has effect when Calc is first loaded, @kbd{m x} is usually followed by | |
12483 | @kbd{m m} to make the mode-setting permanent. To load all of Calc just | |
58547c3e | 12484 | once, rather than always in the future, you can press @kbd{C-x * L}. |
d7b8e6c6 EZ |
12485 | |
12486 | @kindex m S | |
12487 | @pindex calc-shift-prefix | |
12488 | The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which | |
12489 | all of Calc's letter prefix keys may be typed shifted as well as unshifted. | |
12490 | If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often | |
12491 | you might find it easier to turn this mode on so that you can type | |
12492 | @kbd{A S} instead. When this mode is enabled, the commands that used to | |
12493 | be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can | |
12494 | now be invoked by pressing the shifted letter twice: @kbd{A A}. Note | |
12495 | that the @kbd{v} prefix key always works both shifted and unshifted, and | |
12496 | the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h} | |
12497 | prefix is not affected by this mode. Press @kbd{m S} again to disable | |
12498 | shifted-prefix mode. | |
12499 | ||
12500 | @node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings | |
12501 | @section Precision | |
12502 | ||
12503 | @noindent | |
12504 | @kindex p | |
12505 | @pindex calc-precision | |
12506 | @cindex Precision of calculations | |
12507 | The @kbd{p} (@code{calc-precision}) command controls the precision to | |
12508 | which floating-point calculations are carried. The precision must be | |
12509 | at least 3 digits and may be arbitrarily high, within the limits of | |
12510 | memory and time. This affects only floats: Integer and rational | |
12511 | calculations are always carried out with as many digits as necessary. | |
12512 | ||
12513 | The @kbd{p} key prompts for the current precision. If you wish you | |
12514 | can instead give the precision as a numeric prefix argument. | |
12515 | ||
12516 | Many internal calculations are carried to one or two digits higher | |
12517 | precision than normal. Results are rounded down afterward to the | |
12518 | current precision. Unless a special display mode has been selected, | |
12519 | floats are always displayed with their full stored precision, i.e., | |
12520 | what you see is what you get. Reducing the current precision does not | |
12521 | round values already on the stack, but those values will be rounded | |
12522 | down before being used in any calculation. The @kbd{c 0} through | |
12523 | @kbd{c 9} commands (@pxref{Conversions}) can be used to round an | |
a4231b04 | 12524 | existing value to a new precision. |
d7b8e6c6 EZ |
12525 | |
12526 | @cindex Accuracy of calculations | |
12527 | It is important to distinguish the concepts of @dfn{precision} and | |
12528 | @dfn{accuracy}. In the normal usage of these words, the number | |
12529 | 123.4567 has a precision of 7 digits but an accuracy of 4 digits. | |
12530 | The precision is the total number of digits not counting leading | |
12531 | or trailing zeros (regardless of the position of the decimal point). | |
12532 | The accuracy is simply the number of digits after the decimal point | |
12533 | (again not counting trailing zeros). In Calc you control the precision, | |
12534 | not the accuracy of computations. If you were to set the accuracy | |
12535 | instead, then calculations like @samp{exp(100)} would generate many | |
12536 | more digits than you would typically need, while @samp{exp(-100)} would | |
12537 | probably round to zero! In Calc, both these computations give you | |
12538 | exactly 12 (or the requested number of) significant digits. | |
12539 | ||
12540 | The only Calc features that deal with accuracy instead of precision | |
12541 | are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}), | |
12542 | and the rounding functions like @code{floor} and @code{round} | |
12543 | (@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9} | |
12544 | deal with both precision and accuracy depending on the magnitudes | |
12545 | of the numbers involved. | |
12546 | ||
12547 | If you need to work with a particular fixed accuracy (say, dollars and | |
12548 | cents with two digits after the decimal point), one solution is to work | |
12549 | with integers and an ``implied'' decimal point. For example, $8.99 | |
5d67986c | 12550 | divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833 |
d7b8e6c6 EZ |
12551 | (actually $1.49833 with our implied decimal point); pressing @kbd{R} |
12552 | would round this to 150 cents, i.e., $1.50. | |
12553 | ||
12554 | @xref{Floats}, for still more on floating-point precision and related | |
12555 | issues. | |
12556 | ||
12557 | @node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings | |
12558 | @section Inverse and Hyperbolic Flags | |
12559 | ||
12560 | @noindent | |
12561 | @kindex I | |
12562 | @pindex calc-inverse | |
12563 | There is no single-key equivalent to the @code{calc-arcsin} function. | |
12564 | Instead, you must first press @kbd{I} (@code{calc-inverse}) to set | |
12565 | the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}). | |
12566 | The @kbd{I} key actually toggles the Inverse Flag. When this flag | |
a4231b04 | 12567 | is set, the word @samp{Inv} appears in the mode line. |
d7b8e6c6 EZ |
12568 | |
12569 | @kindex H | |
12570 | @pindex calc-hyperbolic | |
12571 | Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the | |
12572 | Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}. | |
12573 | If both of these flags are set at once, the effect will be | |
12574 | @code{calc-arcsinh}. (The Hyperbolic flag is also used by some | |
12575 | non-trigonometric commands; for example @kbd{H L} computes a base-10, | |
8e04863e | 12576 | instead of base-@mathit{e}, logarithm.) |
d7b8e6c6 EZ |
12577 | |
12578 | Command names like @code{calc-arcsin} are provided for completeness, and | |
12579 | may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to | |
12580 | toggle the Inverse and/or Hyperbolic flags and then execute the | |
12581 | corresponding base command (@code{calc-sin} in this case). | |
12582 | ||
12583 | The Inverse and Hyperbolic flags apply only to the next Calculator | |
12584 | command, after which they are automatically cleared. (They are also | |
12585 | cleared if the next keystroke is not a Calc command.) Digits you | |
12586 | type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix | |
12587 | arguments for the next command, not as numeric entries. The same | |
12588 | is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to | |
12589 | subtract and keep arguments). | |
12590 | ||
12591 | The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed | |
12592 | elsewhere. @xref{Keep Arguments}. | |
12593 | ||
12594 | @node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings | |
12595 | @section Calculation Modes | |
12596 | ||
12597 | @noindent | |
12598 | The commands in this section are two-key sequences beginning with | |
12599 | the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.) | |
12600 | The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere | |
12601 | (@pxref{Algebraic Entry}). | |
12602 | ||
12603 | @menu | |
12604 | * Angular Modes:: | |
12605 | * Polar Mode:: | |
12606 | * Fraction Mode:: | |
12607 | * Infinite Mode:: | |
12608 | * Symbolic Mode:: | |
12609 | * Matrix Mode:: | |
12610 | * Automatic Recomputation:: | |
12611 | * Working Message:: | |
12612 | @end menu | |
12613 | ||
12614 | @node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes | |
12615 | @subsection Angular Modes | |
12616 | ||
12617 | @noindent | |
12618 | @cindex Angular mode | |
12619 | The Calculator supports three notations for angles: radians, degrees, | |
12620 | and degrees-minutes-seconds. When a number is presented to a function | |
12621 | like @code{sin} that requires an angle, the current angular mode is | |
12622 | used to interpret the number as either radians or degrees. If an HMS | |
12623 | form is presented to @code{sin}, it is always interpreted as | |
12624 | degrees-minutes-seconds. | |
12625 | ||
12626 | Functions that compute angles produce a number in radians, a number in | |
12627 | degrees, or an HMS form depending on the current angular mode. If the | |
12628 | result is a complex number and the current mode is HMS, the number is | |
12629 | instead expressed in degrees. (Complex-number calculations would | |
07ce2eb3 | 12630 | normally be done in Radians mode, though. Complex numbers are converted |
d7b8e6c6 | 12631 | to degrees by calculating the complex result in radians and then |
a4231b04 | 12632 | multiplying by 180 over @cpi{}.) |
d7b8e6c6 EZ |
12633 | |
12634 | @kindex m r | |
12635 | @pindex calc-radians-mode | |
12636 | @kindex m d | |
12637 | @pindex calc-degrees-mode | |
12638 | @kindex m h | |
12639 | @pindex calc-hms-mode | |
12640 | The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}), | |
12641 | and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode. | |
12642 | The current angular mode is displayed on the Emacs mode line. | |
07ce2eb3 | 12643 | The default angular mode is Degrees. |
d7b8e6c6 EZ |
12644 | |
12645 | @node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes | |
12646 | @subsection Polar Mode | |
12647 | ||
12648 | @noindent | |
12649 | @cindex Polar mode | |
12650 | The Calculator normally ``prefers'' rectangular complex numbers in the | |
12651 | sense that rectangular form is used when the proper form can not be | |
12652 | decided from the input. This might happen by multiplying a rectangular | |
12653 | number by a polar one, by taking the square root of a negative real | |
12654 | number, or by entering @kbd{( 2 @key{SPC} 3 )}. | |
12655 | ||
12656 | @kindex m p | |
12657 | @pindex calc-polar-mode | |
12658 | The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number | |
07ce2eb3 | 12659 | preference between rectangular and polar forms. In Polar mode, all |
d7b8e6c6 EZ |
12660 | of the above example situations would produce polar complex numbers. |
12661 | ||
12662 | @node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes | |
12663 | @subsection Fraction Mode | |
12664 | ||
12665 | @noindent | |
12666 | @cindex Fraction mode | |
12667 | @cindex Division of integers | |
12668 | Division of two integers normally yields a floating-point number if the | |
12669 | result cannot be expressed as an integer. In some cases you would | |
12670 | rather get an exact fractional answer. One way to accomplish this is | |
029b2a44 JB |
12671 | to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which |
12672 | divides the two integers on the top of the stack to produce a fraction: | |
12673 | @kbd{6 @key{RET} 4 :} produces @expr{3:2} even though | |
12674 | @kbd{6 @key{RET} 4 /} produces @expr{1.5}. | |
d7b8e6c6 EZ |
12675 | |
12676 | @kindex m f | |
12677 | @pindex calc-frac-mode | |
12678 | To set the Calculator to produce fractional results for normal integer | |
12679 | divisions, use the @kbd{m f} (@code{calc-frac-mode}) command. | |
a4231b04 | 12680 | For example, @expr{8/4} produces @expr{2} in either mode, |
07ce2eb3 JB |
12681 | but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in |
12682 | Float mode. | |
d7b8e6c6 EZ |
12683 | |
12684 | At any time you can use @kbd{c f} (@code{calc-float}) to convert a | |
12685 | fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a | |
12686 | float to a fraction. @xref{Conversions}. | |
12687 | ||
12688 | @node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes | |
12689 | @subsection Infinite Mode | |
12690 | ||
12691 | @noindent | |
12692 | @cindex Infinite mode | |
a4231b04 | 12693 | The Calculator normally treats results like @expr{1 / 0} as errors; |
d7b8e6c6 EZ |
12694 | formulas like this are left in unsimplified form. But Calc can be |
12695 | put into a mode where such calculations instead produce ``infinite'' | |
12696 | results. | |
12697 | ||
12698 | @kindex m i | |
12699 | @pindex calc-infinite-mode | |
12700 | The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode | |
12701 | on and off. When the mode is off, infinities do not arise except | |
12702 | in calculations that already had infinities as inputs. (One exception | |
12703 | is that infinite open intervals like @samp{[0 .. inf)} can be | |
12704 | generated; however, intervals closed at infinity (@samp{[0 .. inf]}) | |
07ce2eb3 | 12705 | will not be generated when Infinite mode is off.) |
d7b8e6c6 | 12706 | |
07ce2eb3 | 12707 | With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf}, |
d7b8e6c6 | 12708 | an undirected infinity. @xref{Infinities}, for a discussion of the |
a4231b04 | 12709 | difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0} |
d7b8e6c6 EZ |
12710 | evaluates to @code{nan}, the ``indeterminate'' symbol. Various other |
12711 | functions can also return infinities in this mode; for example, | |
12712 | @samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again, | |
07ce2eb3 | 12713 | note that @samp{exp(inf) = inf} regardless of Infinite mode because |
d7b8e6c6 EZ |
12714 | this calculation has infinity as an input. |
12715 | ||
07ce2eb3 | 12716 | @cindex Positive Infinite mode |
d7b8e6c6 | 12717 | The @kbd{m i} command with a numeric prefix argument of zero, |
07ce2eb3 | 12718 | i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in |
177c0ea7 | 12719 | which zero is treated as positive instead of being directionless. |
d7b8e6c6 EZ |
12720 | Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode. |
12721 | Note that zero never actually has a sign in Calc; there are no | |
8e04863e | 12722 | separate representations for @mathit{+0} and @mathit{-0}. Positive |
07ce2eb3 | 12723 | Infinite mode merely changes the interpretation given to the |
d7b8e6c6 EZ |
12724 | single symbol, @samp{0}. One consequence of this is that, while |
12725 | you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0} | |
12726 | is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}. | |
12727 | ||
12728 | @node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes | |
12729 | @subsection Symbolic Mode | |
12730 | ||
12731 | @noindent | |
12732 | @cindex Symbolic mode | |
12733 | @cindex Inexact results | |
12734 | Calculations are normally performed numerically wherever possible. | |
12735 | For example, the @code{calc-sqrt} command, or @code{sqrt} function in an | |
12736 | algebraic expression, produces a numeric answer if the argument is a | |
12737 | number or a symbolic expression if the argument is an expression: | |
12738 | @kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}. | |
12739 | ||
12740 | @kindex m s | |
12741 | @pindex calc-symbolic-mode | |
07ce2eb3 | 12742 | In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode}) |
d7b8e6c6 EZ |
12743 | command, functions which would produce inexact, irrational results are |
12744 | left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes | |
12745 | @samp{sqrt(2)}. | |
12746 | ||
12747 | @kindex N | |
12748 | @pindex calc-eval-num | |
12749 | The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically | |
12750 | the expression at the top of the stack, by temporarily disabling | |
12751 | @code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}). | |
12752 | Given a numeric prefix argument, it also | |
12753 | sets the floating-point precision to the specified value for the duration | |
a4231b04 | 12754 | of the command. |
d7b8e6c6 EZ |
12755 | |
12756 | To evaluate a formula numerically without expanding the variables it | |
12757 | contains, you can use the key sequence @kbd{m s a v m s} (this uses | |
12758 | @code{calc-alg-evaluate}, which resimplifies but doesn't evaluate | |
12759 | variables.) | |
12760 | ||
12761 | @node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes | |
12762 | @subsection Matrix and Scalar Modes | |
12763 | ||
12764 | @noindent | |
12765 | @cindex Matrix mode | |
12766 | @cindex Scalar mode | |
12767 | Calc sometimes makes assumptions during algebraic manipulation that | |
12768 | are awkward or incorrect when vectors and matrices are involved. | |
07ce2eb3 | 12769 | Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which |
d7b8e6c6 EZ |
12770 | modify its behavior around vectors in useful ways. |
12771 | ||
12772 | @kindex m v | |
12773 | @pindex calc-matrix-mode | |
07ce2eb3 | 12774 | Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode. |
d7b8e6c6 EZ |
12775 | In this mode, all objects are assumed to be matrices unless provably |
12776 | otherwise. One major effect is that Calc will no longer consider | |
12777 | multiplication to be commutative. (Recall that in matrix arithmetic, | |
12778 | @samp{A*B} is not the same as @samp{B*A}.) This assumption affects | |
12779 | rewrite rules and algebraic simplification. Another effect of this | |
12780 | mode is that calculations that would normally produce constants like | |
a4231b04 | 12781 | 0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now |
d7b8e6c6 EZ |
12782 | produce function calls that represent ``generic'' zero or identity |
12783 | matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function | |
12784 | @samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n} | |
12785 | identity matrix; if @var{n} is omitted, it doesn't know what | |
12786 | dimension to use and so the @code{idn} call remains in symbolic | |
12787 | form. However, if this generic identity matrix is later combined | |
12788 | with a matrix whose size is known, it will be converted into | |
12789 | a true identity matrix of the appropriate size. On the other hand, | |
12790 | if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc | |
12791 | will assume it really was a scalar after all and produce, e.g., 3. | |
12792 | ||
07ce2eb3 | 12793 | Press @kbd{m v} a second time to get Scalar mode. Here, objects are |
d7b8e6c6 EZ |
12794 | assumed @emph{not} to be vectors or matrices unless provably so. |
12795 | For example, normally adding a variable to a vector, as in | |
12796 | @samp{[x, y, z] + a}, will leave the sum in symbolic form because | |
12797 | as far as Calc knows, @samp{a} could represent either a number or | |
07ce2eb3 | 12798 | another 3-vector. In Scalar mode, @samp{a} is assumed to be a |
d7b8e6c6 EZ |
12799 | non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}. |
12800 | ||
12801 | Press @kbd{m v} a third time to return to the normal mode of operation. | |
12802 | ||
12803 | If you press @kbd{m v} with a numeric prefix argument @var{n}, you | |
07ce2eb3 | 12804 | get a special ``dimensioned'' Matrix mode in which matrices of |
d7b8e6c6 EZ |
12805 | unknown size are assumed to be @var{n}x@var{n} square matrices. |
12806 | Then, the function call @samp{idn(1)} will expand into an actual | |
fe7d6d98 JB |
12807 | matrix rather than representing a ``generic'' matrix. Simply typing |
12808 | @kbd{C-u m v} will get you a square Matrix mode, in which matrices of | |
12809 | unknown size are assumed to be square matrices of unspecified size. | |
d7b8e6c6 EZ |
12810 | |
12811 | @cindex Declaring scalar variables | |
12812 | Of course these modes are approximations to the true state of | |
12813 | affairs, which is probably that some quantities will be matrices | |
12814 | and others will be scalars. One solution is to ``declare'' | |
12815 | certain variables or functions to be scalar-valued. | |
12816 | @xref{Declarations}, to see how to make declarations in Calc. | |
12817 | ||
12818 | There is nothing stopping you from declaring a variable to be | |
12819 | scalar and then storing a matrix in it; however, if you do, the | |
12820 | results you get from Calc may not be valid. Suppose you let Calc | |
12821 | get the result @samp{[x+a, y+a, z+a]} shown above, and then stored | |
12822 | @samp{[1, 2, 3]} in @samp{a}. The result would not be the same as | |
12823 | for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken | |
12824 | your earlier promise to Calc that @samp{a} would be scalar. | |
12825 | ||
12826 | Another way to mix scalars and matrices is to use selections | |
07ce2eb3 JB |
12827 | (@pxref{Selecting Subformulas}). Use Matrix mode when operating on |
12828 | your formula normally; then, to apply Scalar mode to a certain part | |
d7b8e6c6 | 12829 | of the formula without affecting the rest just select that part, |
07ce2eb3 JB |
12830 | change into Scalar mode and press @kbd{=} to resimplify the part |
12831 | under this mode, then change back to Matrix mode before deselecting. | |
d7b8e6c6 EZ |
12832 | |
12833 | @node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes | |
12834 | @subsection Automatic Recomputation | |
12835 | ||
12836 | @noindent | |
12837 | The @dfn{evaluates-to} operator, @samp{=>}, has the special | |
12838 | property that any @samp{=>} formulas on the stack are recomputed | |
12839 | whenever variable values or mode settings that might affect them | |
12840 | are changed. @xref{Evaluates-To Operator}. | |
12841 | ||
12842 | @kindex m C | |
12843 | @pindex calc-auto-recompute | |
12844 | The @kbd{m C} (@code{calc-auto-recompute}) command turns this | |
12845 | automatic recomputation on and off. If you turn it off, Calc will | |
12846 | not update @samp{=>} operators on the stack (nor those in the | |
07ce2eb3 | 12847 | attached Embedded mode buffer, if there is one). They will not |
d7b8e6c6 EZ |
12848 | be updated unless you explicitly do so by pressing @kbd{=} or until |
12849 | you press @kbd{m C} to turn recomputation back on. (While automatic | |
12850 | recomputation is off, you can think of @kbd{m C m C} as a command | |
12851 | to update all @samp{=>} operators while leaving recomputation off.) | |
12852 | ||
12853 | To update @samp{=>} operators in an Embedded buffer while | |
58547c3e | 12854 | automatic recomputation is off, use @w{@kbd{C-x * u}}. |
d7b8e6c6 EZ |
12855 | @xref{Embedded Mode}. |
12856 | ||
12857 | @node Working Message, , Automatic Recomputation, Calculation Modes | |
12858 | @subsection Working Messages | |
12859 | ||
12860 | @noindent | |
12861 | @cindex Performance | |
12862 | @cindex Working messages | |
12863 | Since the Calculator is written entirely in Emacs Lisp, which is not | |
12864 | designed for heavy numerical work, many operations are quite slow. | |
12865 | The Calculator normally displays the message @samp{Working...} in the | |
12866 | echo area during any command that may be slow. In addition, iterative | |
12867 | operations such as square roots and trigonometric functions display the | |
12868 | intermediate result at each step. Both of these types of messages can | |
12869 | be disabled if you find them distracting. | |
12870 | ||
12871 | @kindex m w | |
12872 | @pindex calc-working | |
12873 | Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to | |
12874 | disable all ``working'' messages. Use a numeric prefix of 1 to enable | |
12875 | only the plain @samp{Working...} message. Use a numeric prefix of 2 to | |
12876 | see intermediate results as well. With no numeric prefix this displays | |
a4231b04 | 12877 | the current mode. |
d7b8e6c6 EZ |
12878 | |
12879 | While it may seem that the ``working'' messages will slow Calc down | |
12880 | considerably, experiments have shown that their impact is actually | |
12881 | quite small. But if your terminal is slow you may find that it helps | |
12882 | to turn the messages off. | |
12883 | ||
12884 | @node Simplification Modes, Declarations, Calculation Modes, Mode Settings | |
12885 | @section Simplification Modes | |
12886 | ||
12887 | @noindent | |
12888 | The current @dfn{simplification mode} controls how numbers and formulas | |
12889 | are ``normalized'' when being taken from or pushed onto the stack. | |
12890 | Some normalizations are unavoidable, such as rounding floating-point | |
12891 | results to the current precision, and reducing fractions to simplest | |
a4231b04 | 12892 | form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}), |
d7b8e6c6 EZ |
12893 | are done by default but can be turned off when necessary. |
12894 | ||
a4231b04 | 12895 | When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the |
d7b8e6c6 | 12896 | stack, Calc pops these numbers, normalizes them, creates the formula |
a4231b04 JB |
12897 | @expr{2+3}, normalizes it, and pushes the result. Of course the standard |
12898 | rules for normalizing @expr{2+3} will produce the result @expr{5}. | |
d7b8e6c6 EZ |
12899 | |
12900 | Simplification mode commands consist of the lower-case @kbd{m} prefix key | |
12901 | followed by a shifted letter. | |
12902 | ||
12903 | @kindex m O | |
12904 | @pindex calc-no-simplify-mode | |
12905 | The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional | |
a4231b04 | 12906 | simplifications. These would leave a formula like @expr{2+3} alone. In |
d7b8e6c6 EZ |
12907 | fact, nothing except simple numbers are ever affected by normalization |
12908 | in this mode. | |
12909 | ||
12910 | @kindex m N | |
12911 | @pindex calc-num-simplify-mode | |
12912 | The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification | |
12913 | of any formulas except those for which all arguments are constants. For | |
a4231b04 JB |
12914 | example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is |
12915 | simplified to @expr{a+0} but no further, since one argument of the sum | |
12916 | is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified | |
d7b8e6c6 | 12917 | because the top-level @samp{-} operator's arguments are not both |
a4231b04 | 12918 | constant numbers (one of them is the formula @expr{a+2}). |
d7b8e6c6 EZ |
12919 | A constant is a number or other numeric object (such as a constant |
12920 | error form or modulo form), or a vector all of whose | |
a4231b04 | 12921 | elements are constant. |
d7b8e6c6 EZ |
12922 | |
12923 | @kindex m D | |
12924 | @pindex calc-default-simplify-mode | |
12925 | The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the | |
12926 | default simplifications for all formulas. This includes many easy and | |
a4231b04 JB |
12927 | fast algebraic simplifications such as @expr{a+0} to @expr{a}, and |
12928 | @expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like | |
bd712b70 | 12929 | @expr{@tfn{deriv}(x^2, x)} to @expr{2 x}. |
d7b8e6c6 EZ |
12930 | |
12931 | @kindex m B | |
12932 | @pindex calc-bin-simplify-mode | |
12933 | The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default | |
12934 | simplifications to a result and then, if the result is an integer, | |
12935 | uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according | |
12936 | to the current binary word size. @xref{Binary Functions}. Real numbers | |
12937 | are rounded to the nearest integer and then clipped; other kinds of | |
12938 | results (after the default simplifications) are left alone. | |
12939 | ||
12940 | @kindex m A | |
12941 | @pindex calc-alg-simplify-mode | |
12942 | The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic | |
12943 | simplification; it applies all the default simplifications, and also | |
12944 | the more powerful (and slower) simplifications made by @kbd{a s} | |
12945 | (@code{calc-simplify}). @xref{Algebraic Simplifications}. | |
12946 | ||
12947 | @kindex m E | |
12948 | @pindex calc-ext-simplify-mode | |
12949 | The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended'' | |
12950 | algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended}) | |
12951 | command. @xref{Unsafe Simplifications}. | |
12952 | ||
12953 | @kindex m U | |
12954 | @pindex calc-units-simplify-mode | |
12955 | The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units | |
12956 | simplification; it applies the command @kbd{u s} | |
12957 | (@code{calc-simplify-units}), which in turn | |
12958 | is a superset of @kbd{a s}. In this mode, variable names which | |
12959 | are identifiable as unit names (like @samp{mm} for ``millimeters'') | |
a4231b04 | 12960 | are simplified with their unit definitions in mind. |
d7b8e6c6 EZ |
12961 | |
12962 | A common technique is to set the simplification mode down to the lowest | |
12963 | amount of simplification you will allow to be applied automatically, then | |
12964 | use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to | |
12965 | perform higher types of simplifications on demand. @xref{Algebraic | |
07ce2eb3 | 12966 | Definitions}, for another sample use of No-Simplification mode. |
d7b8e6c6 EZ |
12967 | |
12968 | @node Declarations, Display Modes, Simplification Modes, Mode Settings | |
12969 | @section Declarations | |
12970 | ||
12971 | @noindent | |
12972 | A @dfn{declaration} is a statement you make that promises you will | |
12973 | use a certain variable or function in a restricted way. This may | |
12974 | give Calc the freedom to do things that it couldn't do if it had to | |
12975 | take the fully general situation into account. | |
12976 | ||
12977 | @menu | |
12978 | * Declaration Basics:: | |
12979 | * Kinds of Declarations:: | |
12980 | * Functions for Declarations:: | |
12981 | @end menu | |
12982 | ||
12983 | @node Declaration Basics, Kinds of Declarations, Declarations, Declarations | |
12984 | @subsection Declaration Basics | |
12985 | ||
12986 | @noindent | |
12987 | @kindex s d | |
12988 | @pindex calc-declare-variable | |
12989 | The @kbd{s d} (@code{calc-declare-variable}) command is the easiest | |
12990 | way to make a declaration for a variable. This command prompts for | |
12991 | the variable name, then prompts for the declaration. The default | |
12992 | at the declaration prompt is the previous declaration, if any. | |
12993 | You can edit this declaration, or press @kbd{C-k} to erase it and | |
12994 | type a new declaration. (Or, erase it and press @key{RET} to clear | |
12995 | the declaration, effectively ``undeclaring'' the variable.) | |
12996 | ||
12997 | A declaration is in general a vector of @dfn{type symbols} and | |
12998 | @dfn{range} values. If there is only one type symbol or range value, | |
12999 | you can write it directly rather than enclosing it in a vector. | |
5d67986c RS |
13000 | For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to |
13001 | be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}} | |
d7b8e6c6 EZ |
13002 | declares @code{bar} to be a constant integer between 1 and 6. |
13003 | (Actually, you can omit the outermost brackets and Calc will | |
5d67986c | 13004 | provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.) |
d7b8e6c6 EZ |
13005 | |
13006 | @cindex @code{Decls} variable | |
13007 | @vindex Decls | |
13008 | Declarations in Calc are kept in a special variable called @code{Decls}. | |
13009 | This variable encodes the set of all outstanding declarations in | |
13010 | the form of a matrix. Each row has two elements: A variable or | |
13011 | vector of variables declared by that row, and the declaration | |
13012 | specifier as described above. You can use the @kbd{s D} command to | |
13013 | edit this variable if you wish to see all the declarations at once. | |
13014 | @xref{Operations on Variables}, for a description of this command | |
13015 | and the @kbd{s p} command that allows you to save your declarations | |
13016 | permanently if you wish. | |
13017 | ||
13018 | Items being declared can also be function calls. The arguments in | |
13019 | the call are ignored; the effect is to say that this function returns | |
13020 | values of the declared type for any valid arguments. The @kbd{s d} | |
13021 | command declares only variables, so if you wish to make a function | |
13022 | declaration you will have to edit the @code{Decls} matrix yourself. | |
13023 | ||
13024 | For example, the declaration matrix | |
13025 | ||
d7b8e6c6 | 13026 | @smallexample |
5d67986c | 13027 | @group |
d7b8e6c6 EZ |
13028 | [ [ foo, real ] |
13029 | [ [j, k, n], int ] | |
13030 | [ f(1,2,3), [0 .. inf) ] ] | |
d7b8e6c6 | 13031 | @end group |
5d67986c | 13032 | @end smallexample |
d7b8e6c6 EZ |
13033 | |
13034 | @noindent | |
13035 | declares that @code{foo} represents a real number, @code{j}, @code{k} | |
13036 | and @code{n} represent integers, and the function @code{f} always | |
13037 | returns a real number in the interval shown. | |
13038 | ||
13039 | @vindex All | |
13040 | If there is a declaration for the variable @code{All}, then that | |
13041 | declaration applies to all variables that are not otherwise declared. | |
13042 | It does not apply to function names. For example, using the row | |
13043 | @samp{[All, real]} says that all your variables are real unless they | |
13044 | are explicitly declared without @code{real} in some other row. | |
13045 | The @kbd{s d} command declares @code{All} if you give a blank | |
13046 | response to the variable-name prompt. | |
13047 | ||
13048 | @node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations | |
13049 | @subsection Kinds of Declarations | |
13050 | ||
13051 | @noindent | |
13052 | The type-specifier part of a declaration (that is, the second prompt | |
13053 | in the @kbd{s d} command) can be a type symbol, an interval, or a | |
13054 | vector consisting of zero or more type symbols followed by zero or | |
13055 | more intervals or numbers that represent the set of possible values | |
13056 | for the variable. | |
13057 | ||
d7b8e6c6 | 13058 | @smallexample |
5d67986c | 13059 | @group |
d7b8e6c6 EZ |
13060 | [ [ a, [1, 2, 3, 4, 5] ] |
13061 | [ b, [1 .. 5] ] | |
13062 | [ c, [int, 1 .. 5] ] ] | |
d7b8e6c6 | 13063 | @end group |
5d67986c | 13064 | @end smallexample |
d7b8e6c6 EZ |
13065 | |
13066 | Here @code{a} is declared to contain one of the five integers shown; | |
13067 | @code{b} is any number in the interval from 1 to 5 (any real number | |
13068 | since we haven't specified), and @code{c} is any integer in that | |
13069 | interval. Thus the declarations for @code{a} and @code{c} are | |
13070 | nearly equivalent (see below). | |
13071 | ||
13072 | The type-specifier can be the empty vector @samp{[]} to say that | |
13073 | nothing is known about a given variable's value. This is the same | |
13074 | as not declaring the variable at all except that it overrides any | |
13075 | @code{All} declaration which would otherwise apply. | |
13076 | ||
13077 | The initial value of @code{Decls} is the empty vector @samp{[]}. | |
13078 | If @code{Decls} has no stored value or if the value stored in it | |
13079 | is not valid, it is ignored and there are no declarations as far | |
13080 | as Calc is concerned. (The @kbd{s d} command will replace such a | |
13081 | malformed value with a fresh empty matrix, @samp{[]}, before recording | |
13082 | the new declaration.) Unrecognized type symbols are ignored. | |
13083 | ||
13084 | The following type symbols describe what sorts of numbers will be | |
13085 | stored in a variable: | |
13086 | ||
13087 | @table @code | |
13088 | @item int | |
13089 | Integers. | |
13090 | @item numint | |
13091 | Numerical integers. (Integers or integer-valued floats.) | |
13092 | @item frac | |
13093 | Fractions. (Rational numbers which are not integers.) | |
13094 | @item rat | |
13095 | Rational numbers. (Either integers or fractions.) | |
13096 | @item float | |
13097 | Floating-point numbers. | |
13098 | @item real | |
13099 | Real numbers. (Integers, fractions, or floats. Actually, | |
13100 | intervals and error forms with real components also count as | |
13101 | reals here.) | |
13102 | @item pos | |
13103 | Positive real numbers. (Strictly greater than zero.) | |
13104 | @item nonneg | |
13105 | Nonnegative real numbers. (Greater than or equal to zero.) | |
13106 | @item number | |
13107 | Numbers. (Real or complex.) | |
13108 | @end table | |
13109 | ||
13110 | Calc uses this information to determine when certain simplifications | |
13111 | of formulas are safe. For example, @samp{(x^y)^z} cannot be | |
13112 | simplified to @samp{x^(y z)} in general; for example, | |
8e04863e | 13113 | @samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}. |
d7b8e6c6 EZ |
13114 | However, this simplification @emph{is} safe if @code{z} is known |
13115 | to be an integer, or if @code{x} is known to be a nonnegative | |
13116 | real number. If you have given declarations that allow Calc to | |
13117 | deduce either of these facts, Calc will perform this simplification | |
13118 | of the formula. | |
13119 | ||
13120 | Calc can apply a certain amount of logic when using declarations. | |
13121 | For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n} | |
13122 | has been declared @code{int}; Calc knows that an integer times an | |
13123 | integer, plus an integer, must always be an integer. (In fact, | |
13124 | Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since | |
13125 | it is able to determine that @samp{2n+1} must be an odd integer.) | |
13126 | ||
13127 | Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)} | |
13128 | because Calc knows that the @code{abs} function always returns a | |
13129 | nonnegative real. If you had a @code{myabs} function that also had | |
13130 | this property, you could get Calc to recognize it by adding the row | |
13131 | @samp{[myabs(), nonneg]} to the @code{Decls} matrix. | |
13132 | ||
13133 | One instance of this simplification is @samp{sqrt(x^2)} (since the | |
13134 | @code{sqrt} function is effectively a one-half power). Normally | |
13135 | Calc leaves this formula alone. After the command | |
5d67986c RS |
13136 | @kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to |
13137 | @samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can | |
d7b8e6c6 EZ |
13138 | simplify this formula all the way to @samp{x}. |
13139 | ||
13140 | If there are any intervals or real numbers in the type specifier, | |
13141 | they comprise the set of possible values that the variable or | |
13142 | function being declared can have. In particular, the type symbol | |
13143 | @code{real} is effectively the same as the range @samp{[-inf .. inf]} | |
13144 | (note that infinity is included in the range of possible values); | |
13145 | @code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is | |
13146 | the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is | |
13147 | redundant because the fact that the variable is real can be | |
13148 | deduced just from the interval, but @samp{[int, [-5 .. 5]]} and | |
13149 | @samp{[rat, [-5 .. 5]]} are useful combinations. | |
13150 | ||
13151 | Note that the vector of intervals or numbers is in the same format | |
13152 | used by Calc's set-manipulation commands. @xref{Set Operations}. | |
13153 | ||
13154 | The type specifier @samp{[1, 2, 3]} is equivalent to | |
13155 | @samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}. | |
13156 | In other words, the range of possible values means only that | |
13157 | the variable's value must be numerically equal to a number in | |
13158 | that range, but not that it must be equal in type as well. | |
13159 | Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])} | |
13160 | and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.'' | |
13161 | ||
13162 | If you use a conflicting combination of type specifiers, the | |
13163 | results are unpredictable. An example is @samp{[pos, [0 .. 5]]}, | |
13164 | where the interval does not lie in the range described by the | |
13165 | type symbol. | |
13166 | ||
13167 | ``Real'' declarations mostly affect simplifications involving powers | |
13168 | like the one described above. Another case where they are used | |
13169 | is in the @kbd{a P} command which returns a list of all roots of a | |
13170 | polynomial; if the variable has been declared real, only the real | |
13171 | roots (if any) will be included in the list. | |
13172 | ||
13173 | ``Integer'' declarations are used for simplifications which are valid | |
13174 | only when certain values are integers (such as @samp{(x^y)^z} | |
13175 | shown above). | |
13176 | ||
13177 | Another command that makes use of declarations is @kbd{a s}, when | |
13178 | simplifying equations and inequalities. It will cancel @code{x} | |
13179 | from both sides of @samp{a x = b x} only if it is sure @code{x} | |
13180 | is non-zero, say, because it has a @code{pos} declaration. | |
13181 | To declare specifically that @code{x} is real and non-zero, | |
13182 | use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the | |
13183 | current notation to say that @code{x} is nonzero but not necessarily | |
13184 | real.) The @kbd{a e} command does ``unsafe'' simplifications, | |
13185 | including cancelling @samp{x} from the equation when @samp{x} is | |
13186 | not known to be nonzero. | |
13187 | ||
13188 | Another set of type symbols distinguish between scalars and vectors. | |
13189 | ||
13190 | @table @code | |
13191 | @item scalar | |
13192 | The value is not a vector. | |
13193 | @item vector | |
13194 | The value is a vector. | |
13195 | @item matrix | |
13196 | The value is a matrix (a rectangular vector of vectors). | |
fe7d6d98 JB |
13197 | @item sqmatrix |
13198 | The value is a square matrix. | |
d7b8e6c6 EZ |
13199 | @end table |
13200 | ||
13201 | These type symbols can be combined with the other type symbols | |
13202 | described above; @samp{[int, matrix]} describes an object which | |
13203 | is a matrix of integers. | |
13204 | ||
13205 | Scalar/vector declarations are used to determine whether certain | |
13206 | algebraic operations are safe. For example, @samp{[a, b, c] + x} | |
13207 | is normally not simplified to @samp{[a + x, b + x, c + x]}, but | |
13208 | it will be if @code{x} has been declared @code{scalar}. On the | |
13209 | other hand, multiplication is usually assumed to be commutative, | |
13210 | but the terms in @samp{x y} will never be exchanged if both @code{x} | |
13211 | and @code{y} are known to be vectors or matrices. (Calc currently | |
13212 | never distinguishes between @code{vector} and @code{matrix} | |
13213 | declarations.) | |
13214 | ||
07ce2eb3 JB |
13215 | @xref{Matrix Mode}, for a discussion of Matrix mode and |
13216 | Scalar mode, which are similar to declaring @samp{[All, matrix]} | |
d7b8e6c6 EZ |
13217 | or @samp{[All, scalar]} but much more convenient. |
13218 | ||
13219 | One more type symbol that is recognized is used with the @kbd{H a d} | |
13220 | command for taking total derivatives of a formula. @xref{Calculus}. | |
13221 | ||
13222 | @table @code | |
13223 | @item const | |
13224 | The value is a constant with respect to other variables. | |
13225 | @end table | |
13226 | ||
13227 | Calc does not check the declarations for a variable when you store | |
8e04863e | 13228 | a value in it. However, storing @mathit{-3.5} in a variable that has |
d7b8e6c6 | 13229 | been declared @code{pos}, @code{int}, or @code{matrix} may have |
a4231b04 JB |
13230 | unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5} |
13231 | if it substitutes the value first, or to @expr{-3.5} if @code{x} | |
d7b8e6c6 EZ |
13232 | was declared @code{pos} and the formula @samp{sqrt(x^2)} is |
13233 | simplified to @samp{x} before the value is substituted. Before | |
13234 | using a variable for a new purpose, it is best to use @kbd{s d} | |
13235 | or @kbd{s D} to check to make sure you don't still have an old | |
13236 | declaration for the variable that will conflict with its new meaning. | |
13237 | ||
13238 | @node Functions for Declarations, , Kinds of Declarations, Declarations | |
13239 | @subsection Functions for Declarations | |
13240 | ||
13241 | @noindent | |
13242 | Calc has a set of functions for accessing the current declarations | |
13243 | in a convenient manner. These functions return 1 if the argument | |
13244 | can be shown to have the specified property, or 0 if the argument | |
13245 | can be shown @emph{not} to have that property; otherwise they are | |
13246 | left unevaluated. These functions are suitable for use with rewrite | |
13247 | rules (@pxref{Conditional Rewrite Rules}) or programming constructs | |
13248 | (@pxref{Conditionals in Macros}). They can be entered only using | |
13249 | algebraic notation. @xref{Logical Operations}, for functions | |
13250 | that perform other tests not related to declarations. | |
13251 | ||
13252 | For example, @samp{dint(17)} returns 1 because 17 is an integer, as | |
13253 | do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared | |
13254 | @code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0. | |
13255 | Calc consults knowledge of its own built-in functions as well as your | |
13256 | own declarations: @samp{dint(floor(x))} returns 1. | |
13257 | ||
5d67986c RS |
13258 | @ignore |
13259 | @starindex | |
13260 | @end ignore | |
d7b8e6c6 | 13261 | @tindex dint |
5d67986c RS |
13262 | @ignore |
13263 | @starindex | |
13264 | @end ignore | |
d7b8e6c6 | 13265 | @tindex dnumint |
5d67986c RS |
13266 | @ignore |
13267 | @starindex | |
13268 | @end ignore | |
d7b8e6c6 EZ |
13269 | @tindex dnatnum |
13270 | The @code{dint} function checks if its argument is an integer. | |
13271 | The @code{dnatnum} function checks if its argument is a natural | |
13272 | number, i.e., a nonnegative integer. The @code{dnumint} function | |
13273 | checks if its argument is numerically an integer, i.e., either an | |
13274 | integer or an integer-valued float. Note that these and the other | |
13275 | data type functions also accept vectors or matrices composed of | |
13276 | suitable elements, and that real infinities @samp{inf} and @samp{-inf} | |
13277 | are considered to be integers for the purposes of these functions. | |
13278 | ||
5d67986c RS |
13279 | @ignore |
13280 | @starindex | |
13281 | @end ignore | |
d7b8e6c6 EZ |
13282 | @tindex drat |
13283 | The @code{drat} function checks if its argument is rational, i.e., | |
13284 | an integer or fraction. Infinities count as rational, but intervals | |
13285 | and error forms do not. | |
13286 | ||
5d67986c RS |
13287 | @ignore |
13288 | @starindex | |
13289 | @end ignore | |
d7b8e6c6 EZ |
13290 | @tindex dreal |
13291 | The @code{dreal} function checks if its argument is real. This | |
13292 | includes integers, fractions, floats, real error forms, and intervals. | |
13293 | ||
5d67986c RS |
13294 | @ignore |
13295 | @starindex | |
13296 | @end ignore | |
d7b8e6c6 EZ |
13297 | @tindex dimag |
13298 | The @code{dimag} function checks if its argument is imaginary, | |
a4231b04 | 13299 | i.e., is mathematically equal to a real number times @expr{i}. |
d7b8e6c6 | 13300 | |
5d67986c RS |
13301 | @ignore |
13302 | @starindex | |
13303 | @end ignore | |
d7b8e6c6 | 13304 | @tindex dpos |
5d67986c RS |
13305 | @ignore |
13306 | @starindex | |
13307 | @end ignore | |
d7b8e6c6 | 13308 | @tindex dneg |
5d67986c RS |
13309 | @ignore |
13310 | @starindex | |
13311 | @end ignore | |
d7b8e6c6 EZ |
13312 | @tindex dnonneg |
13313 | The @code{dpos} function checks for positive (but nonzero) reals. | |
13314 | The @code{dneg} function checks for negative reals. The @code{dnonneg} | |
13315 | function checks for nonnegative reals, i.e., reals greater than or | |
13316 | equal to zero. Note that the @kbd{a s} command can simplify an | |
a4231b04 | 13317 | expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that |
d7b8e6c6 EZ |
13318 | @kbd{a s} is effectively applied to all conditions in rewrite rules, |
13319 | so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg} | |
13320 | are rarely necessary. | |
13321 | ||
5d67986c RS |
13322 | @ignore |
13323 | @starindex | |
13324 | @end ignore | |
d7b8e6c6 EZ |
13325 | @tindex dnonzero |
13326 | The @code{dnonzero} function checks that its argument is nonzero. | |
13327 | This includes all nonzero real or complex numbers, all intervals that | |
13328 | do not include zero, all nonzero modulo forms, vectors all of whose | |
13329 | elements are nonzero, and variables or formulas whose values can be | |
13330 | deduced to be nonzero. It does not include error forms, since they | |
13331 | represent values which could be anything including zero. (This is | |
13332 | also the set of objects considered ``true'' in conditional contexts.) | |
13333 | ||
5d67986c RS |
13334 | @ignore |
13335 | @starindex | |
13336 | @end ignore | |
d7b8e6c6 | 13337 | @tindex deven |
5d67986c RS |
13338 | @ignore |
13339 | @starindex | |
13340 | @end ignore | |
d7b8e6c6 EZ |
13341 | @tindex dodd |
13342 | The @code{deven} function returns 1 if its argument is known to be | |
13343 | an even integer (or integer-valued float); it returns 0 if its argument | |
13344 | is known not to be even (because it is known to be odd or a non-integer). | |
13345 | The @kbd{a s} command uses this to simplify a test of the form | |
13346 | @samp{x % 2 = 0}. There is also an analogous @code{dodd} function. | |
13347 | ||
5d67986c RS |
13348 | @ignore |
13349 | @starindex | |
13350 | @end ignore | |
d7b8e6c6 EZ |
13351 | @tindex drange |
13352 | The @code{drange} function returns a set (an interval or a vector | |
13353 | of intervals and/or numbers; @pxref{Set Operations}) that describes | |
13354 | the set of possible values of its argument. If the argument is | |
13355 | a variable or a function with a declaration, the range is copied | |
13356 | from the declaration. Otherwise, the possible signs of the | |
13357 | expression are determined using a method similar to @code{dpos}, | |
13358 | etc., and a suitable set like @samp{[0 .. inf]} is returned. If | |
13359 | the expression is not provably real, the @code{drange} function | |
13360 | remains unevaluated. | |
13361 | ||
5d67986c RS |
13362 | @ignore |
13363 | @starindex | |
13364 | @end ignore | |
d7b8e6c6 EZ |
13365 | @tindex dscalar |
13366 | The @code{dscalar} function returns 1 if its argument is provably | |
13367 | scalar, or 0 if its argument is provably non-scalar. It is left | |
07ce2eb3 JB |
13368 | unevaluated if this cannot be determined. (If Matrix mode or Scalar |
13369 | mode is in effect, this function returns 1 or 0, respectively, | |
d7b8e6c6 EZ |
13370 | if it has no other information.) When Calc interprets a condition |
13371 | (say, in a rewrite rule) it considers an unevaluated formula to be | |
13372 | ``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is | |
13373 | provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a} | |
13374 | is provably non-scalar; both are ``false'' if there is insufficient | |
13375 | information to tell. | |
13376 | ||
13377 | @node Display Modes, Language Modes, Declarations, Mode Settings | |
13378 | @section Display Modes | |
13379 | ||
13380 | @noindent | |
13381 | The commands in this section are two-key sequences beginning with the | |
13382 | @kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b} | |
13383 | (@code{calc-line-breaking}) commands are described elsewhere; | |
13384 | @pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively. | |
13385 | Display formats for vectors and matrices are also covered elsewhere; | |
a4231b04 | 13386 | @pxref{Vector and Matrix Formats}. |
d7b8e6c6 EZ |
13387 | |
13388 | One thing all display modes have in common is their treatment of the | |
13389 | @kbd{H} prefix. This prefix causes any mode command that would normally | |
13390 | refresh the stack to leave the stack display alone. The word ``Dirty'' | |
13391 | will appear in the mode line when Calc thinks the stack display may not | |
13392 | reflect the latest mode settings. | |
13393 | ||
5d67986c | 13394 | @kindex d @key{RET} |
d7b8e6c6 | 13395 | @pindex calc-refresh-top |
5d67986c | 13396 | The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the |
d7b8e6c6 EZ |
13397 | top stack entry according to all the current modes. Positive prefix |
13398 | arguments reformat the top @var{n} entries; negative prefix arguments | |
13399 | reformat the specified entry, and a prefix of zero is equivalent to | |
5d67986c RS |
13400 | @kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack. |
13401 | For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation | |
d7b8e6c6 EZ |
13402 | but reformats only the top two stack entries in the new mode. |
13403 | ||
13404 | The @kbd{I} prefix has another effect on the display modes. The mode | |
13405 | is set only temporarily; the top stack entry is reformatted according | |
13406 | to that mode, then the original mode setting is restored. In other | |
5d67986c | 13407 | words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}. |
d7b8e6c6 EZ |
13408 | |
13409 | @menu | |
13410 | * Radix Modes:: | |
13411 | * Grouping Digits:: | |
13412 | * Float Formats:: | |
13413 | * Complex Formats:: | |
13414 | * Fraction Formats:: | |
13415 | * HMS Formats:: | |
13416 | * Date Formats:: | |
13417 | * Truncating the Stack:: | |
13418 | * Justification:: | |
13419 | * Labels:: | |
13420 | @end menu | |
13421 | ||
13422 | @node Radix Modes, Grouping Digits, Display Modes, Display Modes | |
13423 | @subsection Radix Modes | |
13424 | ||
13425 | @noindent | |
13426 | @cindex Radix display | |
13427 | @cindex Non-decimal numbers | |
13428 | @cindex Decimal and non-decimal numbers | |
13429 | Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10}) | |
13430 | notation. Calc can actually display in any radix from two (binary) to 36. | |
13431 | When the radix is above 10, the letters @code{A} to @code{Z} are used as | |
13432 | digits. When entering such a number, letter keys are interpreted as | |
13433 | potential digits rather than terminating numeric entry mode. | |
13434 | ||
13435 | @kindex d 2 | |
13436 | @kindex d 8 | |
13437 | @kindex d 6 | |
13438 | @kindex d 0 | |
13439 | @cindex Hexadecimal integers | |
13440 | @cindex Octal integers | |
13441 | The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select | |
13442 | binary, octal, hexadecimal, and decimal as the current display radix, | |
13443 | respectively. Numbers can always be entered in any radix, though the | |
13444 | current radix is used as a default if you press @kbd{#} without any initial | |
13445 | digits. A number entered without a @kbd{#} is @emph{always} interpreted | |
a4231b04 | 13446 | as decimal. |
d7b8e6c6 EZ |
13447 | |
13448 | @kindex d r | |
13449 | @pindex calc-radix | |
13450 | To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter | |
13451 | an integer from 2 to 36. You can specify the radix as a numeric prefix | |
13452 | argument; otherwise you will be prompted for it. | |
13453 | ||
13454 | @kindex d z | |
13455 | @pindex calc-leading-zeros | |
13456 | @cindex Leading zeros | |
13457 | Integers normally are displayed with however many digits are necessary to | |
13458 | represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros}) | |
13459 | command causes integers to be padded out with leading zeros according to the | |
13460 | current binary word size. (@xref{Binary Functions}, for a discussion of | |
a4231b04 JB |
13461 | word size.) If the absolute value of the word size is @expr{w}, all integers |
13462 | are displayed with at least enough digits to represent | |
8e04863e | 13463 | @texline @math{2^w-1} |
a4231b04 JB |
13464 | @infoline @expr{(2^w)-1} |
13465 | in the current radix. (Larger integers will still be displayed in their | |
13466 | entirety.) | |
d7b8e6c6 EZ |
13467 | |
13468 | @node Grouping Digits, Float Formats, Radix Modes, Display Modes | |
13469 | @subsection Grouping Digits | |
13470 | ||
13471 | @noindent | |
13472 | @kindex d g | |
13473 | @pindex calc-group-digits | |
13474 | @cindex Grouping digits | |
13475 | @cindex Digit grouping | |
13476 | Long numbers can be hard to read if they have too many digits. For | |
13477 | example, the factorial of 30 is 33 digits long! Press @kbd{d g} | |
07ce2eb3 | 13478 | (@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits |
d7b8e6c6 EZ |
13479 | are displayed in clumps of 3 or 4 (depending on the current radix) |
13480 | separated by commas. | |
13481 | ||
13482 | The @kbd{d g} command toggles grouping on and off. | |
029b2a44 | 13483 | With a numeric prefix of 0, this command displays the current state of |
d7b8e6c6 | 13484 | the grouping flag; with an argument of minus one it disables grouping; |
a4231b04 | 13485 | with a positive argument @expr{N} it enables grouping on every @expr{N} |
d7b8e6c6 | 13486 | digits. For floating-point numbers, grouping normally occurs only |
a4231b04 JB |
13487 | before the decimal point. A negative prefix argument @expr{-N} enables |
13488 | grouping every @expr{N} digits both before and after the decimal point. | |
d7b8e6c6 EZ |
13489 | |
13490 | @kindex d , | |
13491 | @pindex calc-group-char | |
13492 | The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any | |
13493 | character as the grouping separator. The default is the comma character. | |
13494 | If you find it difficult to read vectors of large integers grouped with | |
13495 | commas, you may wish to use spaces or some other character instead. | |
13496 | This command takes the next character you type, whatever it is, and | |
13497 | uses it as the digit separator. As a special case, @kbd{d , \} selects | |
13498 | @samp{\,} (@TeX{}'s thin-space symbol) as the digit separator. | |
13499 | ||
13500 | Please note that grouped numbers will not generally be parsed correctly | |
58547c3e | 13501 | if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}. |
d7b8e6c6 EZ |
13502 | (@xref{Kill and Yank}, for details on these commands.) One exception is |
13503 | the @samp{\,} separator, which doesn't interfere with parsing because it | |
13504 | is ignored by @TeX{} language mode. | |
13505 | ||
13506 | @node Float Formats, Complex Formats, Grouping Digits, Display Modes | |
13507 | @subsection Float Formats | |
13508 | ||
13509 | @noindent | |
13510 | Floating-point quantities are normally displayed in standard decimal | |
13511 | form, with scientific notation used if the exponent is especially high | |
13512 | or low. All significant digits are normally displayed. The commands | |
13513 | in this section allow you to choose among several alternative display | |
13514 | formats for floats. | |
13515 | ||
13516 | @kindex d n | |
13517 | @pindex calc-normal-notation | |
13518 | The @kbd{d n} (@code{calc-normal-notation}) command selects the normal | |
13519 | display format. All significant figures in a number are displayed. | |
13520 | With a positive numeric prefix, numbers are rounded if necessary to | |
13521 | that number of significant digits. With a negative numerix prefix, | |
13522 | the specified number of significant digits less than the current | |
13523 | precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the | |
13524 | current precision is 12.) | |
13525 | ||
13526 | @kindex d f | |
13527 | @pindex calc-fix-notation | |
13528 | The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point | |
13529 | notation. The numeric argument is the number of digits after the | |
13530 | decimal point, zero or more. This format will relax into scientific | |
13531 | notation if a nonzero number would otherwise have been rounded all the | |
13532 | way to zero. Specifying a negative number of digits is the same as | |
13533 | for a positive number, except that small nonzero numbers will be rounded | |
13534 | to zero rather than switching to scientific notation. | |
13535 | ||
13536 | @kindex d s | |
13537 | @pindex calc-sci-notation | |
13538 | @cindex Scientific notation, display of | |
13539 | The @kbd{d s} (@code{calc-sci-notation}) command selects scientific | |
13540 | notation. A positive argument sets the number of significant figures | |
13541 | displayed, of which one will be before and the rest after the decimal | |
13542 | point. A negative argument works the same as for @kbd{d n} format. | |
13543 | The default is to display all significant digits. | |
13544 | ||
13545 | @kindex d e | |
13546 | @pindex calc-eng-notation | |
13547 | @cindex Engineering notation, display of | |
13548 | The @kbd{d e} (@code{calc-eng-notation}) command selects engineering | |
13549 | notation. This is similar to scientific notation except that the | |
13550 | exponent is rounded down to a multiple of three, with from one to three | |
13551 | digits before the decimal point. An optional numeric prefix sets the | |
13552 | number of significant digits to display, as for @kbd{d s}. | |
13553 | ||
13554 | It is important to distinguish between the current @emph{precision} and | |
13555 | the current @emph{display format}. After the commands @kbd{C-u 10 p} | |
13556 | and @kbd{C-u 6 d n} the Calculator computes all results to ten | |
13557 | significant figures but displays only six. (In fact, intermediate | |
13558 | calculations are often carried to one or two more significant figures, | |
13559 | but values placed on the stack will be rounded down to ten figures.) | |
13560 | Numbers are never actually rounded to the display precision for storage, | |
58547c3e | 13561 | except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the |
d7b8e6c6 EZ |
13562 | actual displayed text in the Calculator buffer. |
13563 | ||
13564 | @kindex d . | |
13565 | @pindex calc-point-char | |
13566 | The @kbd{d .} (@code{calc-point-char}) command selects the character used | |
13567 | as a decimal point. Normally this is a period; users in some countries | |
13568 | may wish to change this to a comma. Note that this is only a display | |
13569 | style; on entry, periods must always be used to denote floating-point | |
13570 | numbers, and commas to separate elements in a list. | |
13571 | ||
13572 | @node Complex Formats, Fraction Formats, Float Formats, Display Modes | |
13573 | @subsection Complex Formats | |
13574 | ||
13575 | @noindent | |
13576 | @kindex d c | |
13577 | @pindex calc-complex-notation | |
13578 | There are three supported notations for complex numbers in rectangular | |
13579 | form. The default is as a pair of real numbers enclosed in parentheses | |
13580 | and separated by a comma: @samp{(a,b)}. The @kbd{d c} | |
a4231b04 | 13581 | (@code{calc-complex-notation}) command selects this style. |
d7b8e6c6 EZ |
13582 | |
13583 | @kindex d i | |
13584 | @pindex calc-i-notation | |
13585 | @kindex d j | |
13586 | @pindex calc-j-notation | |
13587 | The other notations are @kbd{d i} (@code{calc-i-notation}), in which | |
13588 | numbers are displayed in @samp{a+bi} form, and @kbd{d j} | |
13589 | (@code{calc-j-notation}) which displays the form @samp{a+bj} preferred | |
a4231b04 | 13590 | in some disciplines. |
d7b8e6c6 EZ |
13591 | |
13592 | @cindex @code{i} variable | |
13593 | @vindex i | |
13594 | Complex numbers are normally entered in @samp{(a,b)} format. | |
13595 | If you enter @samp{2+3i} as an algebraic formula, it will be stored as | |
13596 | the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate | |
13597 | this formula and you have not changed the variable @samp{i}, the @samp{i} | |
13598 | will be interpreted as @samp{(0,1)} and the formula will be simplified | |
13599 | to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not} | |
13600 | interpret the formula @samp{2 + 3 * i} as a complex number. | |
a4231b04 | 13601 | @xref{Variables}, under ``special constants.'' |
d7b8e6c6 EZ |
13602 | |
13603 | @node Fraction Formats, HMS Formats, Complex Formats, Display Modes | |
13604 | @subsection Fraction Formats | |
13605 | ||
13606 | @noindent | |
13607 | @kindex d o | |
13608 | @pindex calc-over-notation | |
13609 | Display of fractional numbers is controlled by the @kbd{d o} | |
13610 | (@code{calc-over-notation}) command. By default, a number like | |
13611 | eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command | |
13612 | prompts for a one- or two-character format. If you give one character, | |
13613 | that character is used as the fraction separator. Common separators are | |
13614 | @samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be | |
13615 | used regardless of the display format; in particular, the @kbd{/} is used | |
13616 | for RPN-style division, @emph{not} for entering fractions.) | |
13617 | ||
13618 | If you give two characters, fractions use ``integer-plus-fractional-part'' | |
13619 | notation. For example, the format @samp{+/} would display eight thirds | |
13620 | as @samp{2+2/3}. If two colons are present in a number being entered, | |
13621 | the number is interpreted in this form (so that the entries @kbd{2:2:3} | |
13622 | and @kbd{8:3} are equivalent). | |
13623 | ||
13624 | It is also possible to follow the one- or two-character format with | |
13625 | a number. For example: @samp{:10} or @samp{+/3}. In this case, | |
13626 | Calc adjusts all fractions that are displayed to have the specified | |
13627 | denominator, if possible. Otherwise it adjusts the denominator to | |
13628 | be a multiple of the specified value. For example, in @samp{:6} mode | |
a4231b04 JB |
13629 | the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be |
13630 | displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6}, | |
13631 | and @expr{1:8} will be displayed as @expr{3:24}. Integers are also | |
13632 | affected by this mode: 3 is displayed as @expr{18:6}. Note that the | |
d7b8e6c6 | 13633 | format @samp{:1} writes fractions the same as @samp{:}, but it writes |
a4231b04 | 13634 | integers as @expr{n:1}. |
d7b8e6c6 EZ |
13635 | |
13636 | The fraction format does not affect the way fractions or integers are | |
13637 | stored, only the way they appear on the screen. The fraction format | |
13638 | never affects floats. | |
13639 | ||
13640 | @node HMS Formats, Date Formats, Fraction Formats, Display Modes | |
13641 | @subsection HMS Formats | |
13642 | ||
13643 | @noindent | |
13644 | @kindex d h | |
13645 | @pindex calc-hms-notation | |
13646 | The @kbd{d h} (@code{calc-hms-notation}) command controls the display of | |
13647 | HMS (hours-minutes-seconds) forms. It prompts for a string which | |
13648 | consists basically of an ``hours'' marker, optional punctuation, a | |
13649 | ``minutes'' marker, more optional punctuation, and a ``seconds'' marker. | |
13650 | Punctuation is zero or more spaces, commas, or semicolons. The hours | |
13651 | marker is one or more non-punctuation characters. The minutes and | |
13652 | seconds markers must be single non-punctuation characters. | |
13653 | ||
13654 | The default HMS format is @samp{@@ ' "}, producing HMS values of the form | |
13655 | @samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same | |
13656 | value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o} | |
13657 | keys are recognized as synonyms for @kbd{@@} regardless of display format. | |
13658 | The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and | |
13659 | @kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has | |
13660 | already been typed; otherwise, they have their usual meanings | |
13661 | (@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and | |
13662 | @kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.'' | |
13663 | The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or | |
13664 | @kbd{o}) has already been pressed; otherwise it means to switch to algebraic | |
13665 | entry. | |
13666 | ||
13667 | @node Date Formats, Truncating the Stack, HMS Formats, Display Modes | |
13668 | @subsection Date Formats | |
13669 | ||
13670 | @noindent | |
13671 | @kindex d d | |
13672 | @pindex calc-date-notation | |
13673 | The @kbd{d d} (@code{calc-date-notation}) command controls the display | |
13674 | of date forms (@pxref{Date Forms}). It prompts for a string which | |
13675 | contains letters that represent the various parts of a date and time. | |
13676 | To show which parts should be omitted when the form represents a pure | |
13677 | date with no time, parts of the string can be enclosed in @samp{< >} | |
13678 | marks. If you don't include @samp{< >} markers in the format, Calc | |
13679 | guesses at which parts, if any, should be omitted when formatting | |
13680 | pure dates. | |
13681 | ||
13682 | The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}. | |
13683 | An example string in this format is @samp{3:32pm Wed Jan 9, 1991}. | |
13684 | If you enter a blank format string, this default format is | |
13685 | reestablished. | |
13686 | ||
13687 | Calc uses @samp{< >} notation for nameless functions as well as for | |
13688 | dates. @xref{Specifying Operators}. To avoid confusion with nameless | |
13689 | functions, your date formats should avoid using the @samp{#} character. | |
13690 | ||
13691 | @menu | |
13692 | * Date Formatting Codes:: | |
13693 | * Free-Form Dates:: | |
13694 | * Standard Date Formats:: | |
13695 | @end menu | |
13696 | ||
13697 | @node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats | |
13698 | @subsubsection Date Formatting Codes | |
13699 | ||
13700 | @noindent | |
13701 | When displaying a date, the current date format is used. All | |
13702 | characters except for letters and @samp{<} and @samp{>} are | |
13703 | copied literally when dates are formatted. The portion between | |
13704 | @samp{< >} markers is omitted for pure dates, or included for | |
13705 | date/time forms. Letters are interpreted according to the table | |
13706 | below. | |
13707 | ||
13708 | When dates are read in during algebraic entry, Calc first tries to | |
13709 | match the input string to the current format either with or without | |
13710 | the time part. The punctuation characters (including spaces) must | |
13711 | match exactly; letter fields must correspond to suitable text in | |
13712 | the input. If this doesn't work, Calc checks if the input is a | |
13713 | simple number; if so, the number is interpreted as a number of days | |
13714 | since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and | |
13715 | flexible algorithm which is described in the next section. | |
13716 | ||
13717 | Weekday names are ignored during reading. | |
13718 | ||
13719 | Two-digit year numbers are interpreted as lying in the range | |
13720 | from 1941 to 2039. Years outside that range are always | |
13721 | entered and displayed in full. Year numbers with a leading | |
13722 | @samp{+} sign are always interpreted exactly, allowing the | |
13723 | entry and display of the years 1 through 99 AD. | |
13724 | ||
13725 | Here is a complete list of the formatting codes for dates: | |
13726 | ||
13727 | @table @asis | |
13728 | @item Y | |
13729 | Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD. | |
13730 | @item YY | |
13731 | Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD. | |
13732 | @item BY | |
13733 | Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD. | |
13734 | @item YYY | |
13735 | Year: ``1991'' for 1991, ``23'' for 23 AD. | |
13736 | @item YYYY | |
13737 | Year: ``1991'' for 1991, ``+23'' for 23 AD. | |
13738 | @item aa | |
13739 | Year: ``ad'' or blank. | |
13740 | @item AA | |
13741 | Year: ``AD'' or blank. | |
13742 | @item aaa | |
13743 | Year: ``ad '' or blank. (Note trailing space.) | |
13744 | @item AAA | |
13745 | Year: ``AD '' or blank. | |
13746 | @item aaaa | |
13747 | Year: ``a.d.'' or blank. | |
13748 | @item AAAA | |
13749 | Year: ``A.D.'' or blank. | |
13750 | @item bb | |
13751 | Year: ``bc'' or blank. | |
13752 | @item BB | |
13753 | Year: ``BC'' or blank. | |
13754 | @item bbb | |
13755 | Year: `` bc'' or blank. (Note leading space.) | |
13756 | @item BBB | |
13757 | Year: `` BC'' or blank. | |
13758 | @item bbbb | |
13759 | Year: ``b.c.'' or blank. | |
13760 | @item BBBB | |
13761 | Year: ``B.C.'' or blank. | |
13762 | @item M | |
13763 | Month: ``8'' for August. | |
13764 | @item MM | |
13765 | Month: ``08'' for August. | |
13766 | @item BM | |
13767 | Month: `` 8'' for August. | |
13768 | @item MMM | |
13769 | Month: ``AUG'' for August. | |
13770 | @item Mmm | |
13771 | Month: ``Aug'' for August. | |
13772 | @item mmm | |
13773 | Month: ``aug'' for August. | |
13774 | @item MMMM | |
13775 | Month: ``AUGUST'' for August. | |
13776 | @item Mmmm | |
13777 | Month: ``August'' for August. | |
13778 | @item D | |
13779 | Day: ``7'' for 7th day of month. | |
13780 | @item DD | |
13781 | Day: ``07'' for 7th day of month. | |
13782 | @item BD | |
13783 | Day: `` 7'' for 7th day of month. | |
13784 | @item W | |
13785 | Weekday: ``0'' for Sunday, ``6'' for Saturday. | |
13786 | @item WWW | |
13787 | Weekday: ``SUN'' for Sunday. | |
13788 | @item Www | |
13789 | Weekday: ``Sun'' for Sunday. | |
13790 | @item www | |
13791 | Weekday: ``sun'' for Sunday. | |
13792 | @item WWWW | |
13793 | Weekday: ``SUNDAY'' for Sunday. | |
13794 | @item Wwww | |
13795 | Weekday: ``Sunday'' for Sunday. | |
13796 | @item d | |
13797 | Day of year: ``34'' for Feb. 3. | |
13798 | @item ddd | |
13799 | Day of year: ``034'' for Feb. 3. | |
13800 | @item bdd | |
13801 | Day of year: `` 34'' for Feb. 3. | |
13802 | @item h | |
13803 | Hour: ``5'' for 5 AM; ``17'' for 5 PM. | |
13804 | @item hh | |
13805 | Hour: ``05'' for 5 AM; ``17'' for 5 PM. | |
13806 | @item bh | |
13807 | Hour: `` 5'' for 5 AM; ``17'' for 5 PM. | |
13808 | @item H | |
13809 | Hour: ``5'' for 5 AM and 5 PM. | |
13810 | @item HH | |
13811 | Hour: ``05'' for 5 AM and 5 PM. | |
13812 | @item BH | |
13813 | Hour: `` 5'' for 5 AM and 5 PM. | |
13814 | @item p | |
13815 | AM/PM: ``a'' or ``p''. | |
13816 | @item P | |
13817 | AM/PM: ``A'' or ``P''. | |
13818 | @item pp | |
13819 | AM/PM: ``am'' or ``pm''. | |
13820 | @item PP | |
13821 | AM/PM: ``AM'' or ``PM''. | |
13822 | @item pppp | |
13823 | AM/PM: ``a.m.'' or ``p.m.''. | |
13824 | @item PPPP | |
13825 | AM/PM: ``A.M.'' or ``P.M.''. | |
13826 | @item m | |
13827 | Minutes: ``7'' for 7. | |
13828 | @item mm | |
13829 | Minutes: ``07'' for 7. | |
13830 | @item bm | |
13831 | Minutes: `` 7'' for 7. | |
13832 | @item s | |
13833 | Seconds: ``7'' for 7; ``7.23'' for 7.23. | |
13834 | @item ss | |
13835 | Seconds: ``07'' for 7; ``07.23'' for 7.23. | |
13836 | @item bs | |
13837 | Seconds: `` 7'' for 7; `` 7.23'' for 7.23. | |
13838 | @item SS | |
13839 | Optional seconds: ``07'' for 7; blank for 0. | |
13840 | @item BS | |
13841 | Optional seconds: `` 7'' for 7; blank for 0. | |
13842 | @item N | |
13843 | Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991. | |
13844 | @item n | |
13845 | Numeric date: ``726842'' for any time on Wed Jan 9, 1991. | |
13846 | @item J | |
13847 | Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991. | |
13848 | @item j | |
13849 | Julian date: ``2448266'' for any time on Wed Jan 9, 1991. | |
13850 | @item U | |
13851 | Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991. | |
13852 | @item X | |
13853 | Brackets suppression. An ``X'' at the front of the format | |
13854 | causes the surrounding @w{@samp{< >}} delimiters to be omitted | |
13855 | when formatting dates. Note that the brackets are still | |
13856 | required for algebraic entry. | |
13857 | @end table | |
13858 | ||
13859 | If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the | |
13860 | colon is also omitted if the seconds part is zero. | |
13861 | ||
13862 | If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents | |
13863 | appear in the format, then negative year numbers are displayed | |
13864 | without a minus sign. Note that ``aa'' and ``bb'' are mutually | |
13865 | exclusive. Some typical usages would be @samp{YYYY AABB}; | |
13866 | @samp{AAAYYYYBBB}; @samp{YYYYBBB}. | |
13867 | ||
13868 | The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,'' | |
13869 | ``mm,'' ``ss,'' and ``SS'' actually match any number of digits during | |
13870 | reading unless several of these codes are strung together with no | |
13871 | punctuation in between, in which case the input must have exactly as | |
13872 | many digits as there are letters in the format. | |
13873 | ||
13874 | The ``j,'' ``J,'' and ``U'' formats do not make any time zone | |
13875 | adjustment. They effectively use @samp{julian(x,0)} and | |
13876 | @samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}. | |
13877 | ||
13878 | @node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats | |
13879 | @subsubsection Free-Form Dates | |
13880 | ||
13881 | @noindent | |
13882 | When reading a date form during algebraic entry, Calc falls back | |
13883 | on the algorithm described here if the input does not exactly | |
13884 | match the current date format. This algorithm generally | |
13885 | ``does the right thing'' and you don't have to worry about it, | |
13886 | but it is described here in full detail for the curious. | |
13887 | ||
13888 | Calc does not distinguish between upper- and lower-case letters | |
13889 | while interpreting dates. | |
13890 | ||
13891 | First, the time portion, if present, is located somewhere in the | |
13892 | text and then removed. The remaining text is then interpreted as | |
13893 | the date. | |
13894 | ||
13895 | A time is of the form @samp{hh:mm:ss}, possibly with the seconds | |
13896 | part omitted and possibly with an AM/PM indicator added to indicate | |
13897 | 12-hour time. If the AM/PM is present, the minutes may also be | |
13898 | omitted. The AM/PM part may be any of the words @samp{am}, | |
13899 | @samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be | |
13900 | abbreviated to one letter, and the alternate forms @samp{a.m.}, | |
13901 | @samp{p.m.}, and @samp{mid} are also understood. Obviously | |
13902 | @samp{noon} and @samp{midnight} are allowed only on 12:00:00. | |
13903 | The words @samp{noon}, @samp{mid}, and @samp{midnight} are also | |
13904 | recognized with no number attached. | |
13905 | ||
13906 | If there is no AM/PM indicator, the time is interpreted in 24-hour | |
13907 | format. | |
13908 | ||
13909 | To read the date portion, all words and numbers are isolated | |
13910 | from the string; other characters are ignored. All words must | |
13911 | be either month names or day-of-week names (the latter of which | |
13912 | are ignored). Names can be written in full or as three-letter | |
13913 | abbreviations. | |
13914 | ||
13915 | Large numbers, or numbers with @samp{+} or @samp{-} signs, | |
13916 | are interpreted as years. If one of the other numbers is | |
13917 | greater than 12, then that must be the day and the remaining | |
13918 | number in the input is therefore the month. Otherwise, Calc | |
13919 | assumes the month, day and year are in the same order that they | |
13920 | appear in the current date format. If the year is omitted, the | |
13921 | current year is taken from the system clock. | |
13922 | ||
13923 | If there are too many or too few numbers, or any unrecognizable | |
13924 | words, then the input is rejected. | |
13925 | ||
13926 | If there are any large numbers (of five digits or more) other than | |
13927 | the year, they are ignored on the assumption that they are something | |
13928 | like Julian dates that were included along with the traditional | |
13929 | date components when the date was formatted. | |
13930 | ||
13931 | One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.} | |
13932 | may optionally be used; the latter two are equivalent to a | |
13933 | minus sign on the year value. | |
13934 | ||
13935 | If you always enter a four-digit year, and use a name instead | |
13936 | of a number for the month, there is no danger of ambiguity. | |
13937 | ||
13938 | @node Standard Date Formats, , Free-Form Dates, Date Formats | |
13939 | @subsubsection Standard Date Formats | |
13940 | ||
13941 | @noindent | |
13942 | There are actually ten standard date formats, numbered 0 through 9. | |
13943 | Entering a blank line at the @kbd{d d} command's prompt gives | |
13944 | you format number 1, Calc's usual format. You can enter any digit | |
13945 | to select the other formats. | |
13946 | ||
13947 | To create your own standard date formats, give a numeric prefix | |
13948 | argument from 0 to 9 to the @w{@kbd{d d}} command. The format you | |
13949 | enter will be recorded as the new standard format of that | |
13950 | number, as well as becoming the new current date format. | |
13951 | You can save your formats permanently with the @w{@kbd{m m}} | |
13952 | command (@pxref{Mode Settings}). | |
13953 | ||
13954 | @table @asis | |
13955 | @item 0 | |
13956 | @samp{N} (Numerical format) | |
13957 | @item 1 | |
13958 | @samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format) | |
13959 | @item 2 | |
13960 | @samp{D Mmm YYYY<, h:mm:SS>} (European format) | |
13961 | @item 3 | |
13962 | @samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format) | |
13963 | @item 4 | |
13964 | @samp{M/D/Y< H:mm:SSpp>} (American slashed format) | |
13965 | @item 5 | |
13966 | @samp{D.M.Y< h:mm:SS>} (European dotted format) | |
13967 | @item 6 | |
13968 | @samp{M-D-Y< H:mm:SSpp>} (American dashed format) | |
13969 | @item 7 | |
13970 | @samp{D-M-Y< h:mm:SS>} (European dashed format) | |
13971 | @item 8 | |
13972 | @samp{j<, h:mm:ss>} (Julian day plus time) | |
13973 | @item 9 | |
13974 | @samp{YYddd< hh:mm:ss>} (Year-day format) | |
13975 | @end table | |
13976 | ||
13977 | @node Truncating the Stack, Justification, Date Formats, Display Modes | |
13978 | @subsection Truncating the Stack | |
13979 | ||
13980 | @noindent | |
13981 | @kindex d t | |
13982 | @pindex calc-truncate-stack | |
13983 | @cindex Truncating the stack | |
13984 | @cindex Narrowing the stack | |
13985 | The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@: | |
13986 | line that marks the top-of-stack up or down in the Calculator buffer. | |
13987 | The number right above that line is considered to the be at the top of | |
13988 | the stack. Any numbers below that line are ``hidden'' from all stack | |
029b2a44 JB |
13989 | operations (although still visible to the user). This is similar to the |
13990 | Emacs ``narrowing'' feature, except that the values below the @samp{.} | |
13991 | are @emph{visible}, just temporarily frozen. This feature allows you to | |
13992 | keep several independent calculations running at once in different parts | |
13993 | of the stack, or to apply a certain command to an element buried deep in | |
13994 | the stack. | |
d7b8e6c6 EZ |
13995 | |
13996 | Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor | |
13997 | is on. Thus, this line and all those below it become hidden. To un-hide | |
13998 | these lines, move down to the end of the buffer and press @w{@kbd{d t}}. | |
a4231b04 JB |
13999 | With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the |
14000 | bottom @expr{n} values in the buffer. With a negative argument, it hides | |
14001 | all but the top @expr{n} values. With an argument of zero, it hides zero | |
14002 | values, i.e., moves the @samp{.} all the way down to the bottom. | |
d7b8e6c6 EZ |
14003 | |
14004 | @kindex d [ | |
14005 | @pindex calc-truncate-up | |
14006 | @kindex d ] | |
14007 | @pindex calc-truncate-down | |
14008 | The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]} | |
14009 | (@code{calc-truncate-down}) commands move the @samp{.} up or down one | |
a4231b04 | 14010 | line at a time (or several lines with a prefix argument). |
d7b8e6c6 EZ |
14011 | |
14012 | @node Justification, Labels, Truncating the Stack, Display Modes | |
14013 | @subsection Justification | |
14014 | ||
14015 | @noindent | |
14016 | @kindex d < | |
14017 | @pindex calc-left-justify | |
14018 | @kindex d = | |
14019 | @pindex calc-center-justify | |
14020 | @kindex d > | |
14021 | @pindex calc-right-justify | |
14022 | Values on the stack are normally left-justified in the window. You can | |
14023 | control this arrangement by typing @kbd{d <} (@code{calc-left-justify}), | |
14024 | @kbd{d >} (@code{calc-right-justify}), or @kbd{d =} | |
07ce2eb3 | 14025 | (@code{calc-center-justify}). For example, in Right-Justification mode, |
d7b8e6c6 | 14026 | stack entries are displayed flush-right against the right edge of the |
a4231b04 | 14027 | window. |
d7b8e6c6 EZ |
14028 | |
14029 | If you change the width of the Calculator window you may have to type | |
5d67986c | 14030 | @kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered |
d7b8e6c6 EZ |
14031 | text. |
14032 | ||
14033 | Right-justification is especially useful together with fixed-point | |
14034 | notation (see @code{d f}; @code{calc-fix-notation}). With these modes | |
14035 | together, the decimal points on numbers will always line up. | |
14036 | ||
14037 | With a numeric prefix argument, the justification commands give you | |
14038 | a little extra control over the display. The argument specifies the | |
14039 | horizontal ``origin'' of a display line. It is also possible to | |
14040 | specify a maximum line width using the @kbd{d b} command (@pxref{Normal | |
14041 | Language Modes}). For reference, the precise rules for formatting and | |
14042 | breaking lines are given below. Notice that the interaction between | |
14043 | origin and line width is slightly different in each justification | |
14044 | mode. | |
14045 | ||
07ce2eb3 | 14046 | In Left-Justified mode, the line is indented by a number of spaces |
d7b8e6c6 EZ |
14047 | given by the origin (default zero). If the result is longer than the |
14048 | maximum line width, if given, or too wide to fit in the Calc window | |
14049 | otherwise, then it is broken into lines which will fit; each broken | |
14050 | line is indented to the origin. | |
14051 | ||
07ce2eb3 | 14052 | In Right-Justified mode, lines are shifted right so that the rightmost |
d7b8e6c6 EZ |
14053 | character is just before the origin, or just before the current |
14054 | window width if no origin was specified. If the line is too long | |
14055 | for this, then it is broken; the current line width is used, if | |
14056 | specified, or else the origin is used as a width if that is | |
14057 | specified, or else the line is broken to fit in the window. | |
14058 | ||
07ce2eb3 | 14059 | In Centering mode, the origin is the column number of the center of |
d7b8e6c6 EZ |
14060 | each stack entry. If a line width is specified, lines will not be |
14061 | allowed to go past that width; Calc will either indent less or | |
14062 | break the lines if necessary. If no origin is specified, half the | |
14063 | line width or Calc window width is used. | |
14064 | ||
14065 | Note that, in each case, if line numbering is enabled the display | |
14066 | is indented an additional four spaces to make room for the line | |
14067 | number. The width of the line number is taken into account when | |
14068 | positioning according to the current Calc window width, but not | |
14069 | when positioning by explicit origins and widths. In the latter | |
14070 | case, the display is formatted as specified, and then uniformly | |
14071 | shifted over four spaces to fit the line numbers. | |
14072 | ||
14073 | @node Labels, , Justification, Display Modes | |
14074 | @subsection Labels | |
14075 | ||
14076 | @noindent | |
14077 | @kindex d @{ | |
14078 | @pindex calc-left-label | |
14079 | The @kbd{d @{} (@code{calc-left-label}) command prompts for a string, | |
14080 | then displays that string to the left of every stack entry. If the | |
14081 | entries are left-justified (@pxref{Justification}), then they will | |
14082 | appear immediately after the label (unless you specified an origin | |
14083 | greater than the length of the label). If the entries are centered | |
14084 | or right-justified, the label appears on the far left and does not | |
14085 | affect the horizontal position of the stack entry. | |
14086 | ||
14087 | Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off. | |
14088 | ||
14089 | @kindex d @} | |
14090 | @pindex calc-right-label | |
14091 | The @kbd{d @}} (@code{calc-right-label}) command similarly adds a | |
14092 | label on the righthand side. It does not affect positioning of | |
14093 | the stack entries unless they are right-justified. Also, if both | |
07ce2eb3 | 14094 | a line width and an origin are given in Right-Justified mode, the |
d7b8e6c6 EZ |
14095 | stack entry is justified to the origin and the righthand label is |
14096 | justified to the line width. | |
14097 | ||
14098 | One application of labels would be to add equation numbers to | |
14099 | formulas you are manipulating in Calc and then copying into a | |
07ce2eb3 | 14100 | document (possibly using Embedded mode). The equations would |
d7b8e6c6 EZ |
14101 | typically be centered, and the equation numbers would be on the |
14102 | left or right as you prefer. | |
14103 | ||
14104 | @node Language Modes, Modes Variable, Display Modes, Mode Settings | |
14105 | @section Language Modes | |
14106 | ||
14107 | @noindent | |
14108 | The commands in this section change Calc to use a different notation for | |
14109 | entry and display of formulas, corresponding to the conventions of some | |
053bc283 | 14110 | other common language such as Pascal or La@TeX{}. Objects displayed on the |
d7b8e6c6 EZ |
14111 | stack or yanked from the Calculator to an editing buffer will be formatted |
14112 | in the current language; objects entered in algebraic entry or yanked from | |
14113 | another buffer will be interpreted according to the current language. | |
14114 | ||
14115 | The current language has no effect on things written to or read from the | |
14116 | trail buffer, nor does it affect numeric entry. Only algebraic entry is | |
14117 | affected. You can make even algebraic entry ignore the current language | |
14118 | and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}. | |
14119 | ||
14120 | For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C | |
14121 | program; elsewhere in the program you need the derivatives of this formula | |
14122 | with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C} | |
58547c3e | 14123 | to switch to C notation. Now use @code{C-u C-x * g} to grab the formula |
d7b8e6c6 | 14124 | into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect |
58547c3e | 14125 | to the first variable, and @kbd{C-x * y} to yank the formula for the derivative |
d7b8e6c6 EZ |
14126 | back into your C program. Press @kbd{U} to undo the differentiation and |
14127 | repeat with @kbd{a d a[2] @key{RET}} for the other derivative. | |
14128 | ||
14129 | Without being switched into C mode first, Calc would have misinterpreted | |
14130 | the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that | |
14131 | @code{atan} was equivalent to Calc's built-in @code{arctan} function, | |
14132 | and would have written the formula back with notations (like implicit | |
2cbd16b9 | 14133 | multiplication) which would not have been valid for a C program. |
d7b8e6c6 | 14134 | |
053bc283 | 14135 | As another example, suppose you are maintaining a C program and a La@TeX{} |
d7b8e6c6 | 14136 | document, each of which needs a copy of the same formula. You can grab the |
053bc283 JB |
14137 | formula from the program in C mode, switch to La@TeX{} mode, and yank the |
14138 | formula into the document in La@TeX{} math-mode format. | |
d7b8e6c6 EZ |
14139 | |
14140 | Language modes are selected by typing the letter @kbd{d} followed by a | |
14141 | shifted letter key. | |
14142 | ||
14143 | @menu | |
14144 | * Normal Language Modes:: | |
14145 | * C FORTRAN Pascal:: | |
8ed713c6 | 14146 | * TeX and LaTeX Language Modes:: |
d7b8e6c6 EZ |
14147 | * Eqn Language Mode:: |
14148 | * Mathematica Language Mode:: | |
14149 | * Maple Language Mode:: | |
14150 | * Compositions:: | |
14151 | * Syntax Tables:: | |
14152 | @end menu | |
14153 | ||
14154 | @node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes | |
14155 | @subsection Normal Language Modes | |
14156 | ||
14157 | @noindent | |
14158 | @kindex d N | |
14159 | @pindex calc-normal-language | |
14160 | The @kbd{d N} (@code{calc-normal-language}) command selects the usual | |
14161 | notation for Calc formulas, as described in the rest of this manual. | |
14162 | Matrices are displayed in a multi-line tabular format, but all other | |
14163 | objects are written in linear form, as they would be typed from the | |
14164 | keyboard. | |
14165 | ||
14166 | @kindex d O | |
14167 | @pindex calc-flat-language | |
14168 | @cindex Matrix display | |
14169 | The @kbd{d O} (@code{calc-flat-language}) command selects a language | |
14170 | identical with the normal one, except that matrices are written in | |
14171 | one-line form along with everything else. In some applications this | |
14172 | form may be more suitable for yanking data into other buffers. | |
14173 | ||
14174 | @kindex d b | |
14175 | @pindex calc-line-breaking | |
14176 | @cindex Line breaking | |
14177 | @cindex Breaking up long lines | |
14178 | Even in one-line mode, long formulas or vectors will still be split | |
14179 | across multiple lines if they exceed the width of the Calculator window. | |
14180 | The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking | |
14181 | feature on and off. (It works independently of the current language.) | |
14182 | If you give a numeric prefix argument of five or greater to the @kbd{d b} | |
14183 | command, that argument will specify the line width used when breaking | |
14184 | long lines. | |
14185 | ||
14186 | @kindex d B | |
14187 | @pindex calc-big-language | |
14188 | The @kbd{d B} (@code{calc-big-language}) command selects a language | |
14189 | which uses textual approximations to various mathematical notations, | |
14190 | such as powers, quotients, and square roots: | |
14191 | ||
14192 | @example | |
14193 | ____________ | |
14194 | | a + 1 2 | |
14195 | | ----- + c | |
14196 | \| b | |
14197 | @end example | |
14198 | ||
14199 | @noindent | |
14200 | in place of @samp{sqrt((a+1)/b + c^2)}. | |
14201 | ||
07ce2eb3 | 14202 | Subscripts like @samp{a_i} are displayed as actual subscripts in Big |
d7b8e6c6 EZ |
14203 | mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)}) |
14204 | are displayed as @samp{a} with subscripts separated by commas: | |
14205 | @samp{i, j}. They must still be entered in the usual underscore | |
14206 | notation. | |
14207 | ||
14208 | One slight ambiguity of Big notation is that | |
14209 | ||
14210 | @example | |
14211 | 3 | |
14212 | - - | |
14213 | 4 | |
14214 | @end example | |
14215 | ||
14216 | @noindent | |
a4231b04 | 14217 | can represent either the negative rational number @expr{-3:4}, or the |
d7b8e6c6 EZ |
14218 | actual expression @samp{-(3/4)}; but the latter formula would normally |
14219 | never be displayed because it would immediately be evaluated to | |
a4231b04 | 14220 | @expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in |
d7b8e6c6 EZ |
14221 | typical use. |
14222 | ||
14223 | Non-decimal numbers are displayed with subscripts. Thus there is no | |
14224 | way to tell the difference between @samp{16#C2} and @samp{C2_16}, | |
14225 | though generally you will know which interpretation is correct. | |
14226 | Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts | |
14227 | in Big mode. | |
14228 | ||
14229 | In Big mode, stack entries often take up several lines. To aid | |
14230 | readability, stack entries are separated by a blank line in this mode. | |
14231 | You may find it useful to expand the Calc window's height using | |
14232 | @kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only | |
14233 | one on the screen with @kbd{C-x 1} (@code{delete-other-windows}). | |
14234 | ||
14235 | Long lines are currently not rearranged to fit the window width in | |
14236 | Big mode, so you may need to use the @kbd{<} and @kbd{>} keys | |
14237 | to scroll across a wide formula. For really big formulas, you may | |
14238 | even need to use @kbd{@{} and @kbd{@}} to scroll up and down. | |
14239 | ||
14240 | @kindex d U | |
14241 | @pindex calc-unformatted-language | |
14242 | The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables | |
14243 | the use of operator notation in formulas. In this mode, the formula | |
14244 | shown above would be displayed: | |
14245 | ||
14246 | @example | |
14247 | sqrt(add(div(add(a, 1), b), pow(c, 2))) | |
14248 | @end example | |
14249 | ||
14250 | These four modes differ only in display format, not in the format | |
14251 | expected for algebraic entry. The standard Calc operators work in | |
14252 | all four modes, and unformatted notation works in any language mode | |
14253 | (except that Mathematica mode expects square brackets instead of | |
14254 | parentheses). | |
14255 | ||
8ed713c6 | 14256 | @node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes |
d7b8e6c6 EZ |
14257 | @subsection C, FORTRAN, and Pascal Modes |
14258 | ||
14259 | @noindent | |
14260 | @kindex d C | |
14261 | @pindex calc-c-language | |
14262 | @cindex C language | |
14263 | The @kbd{d C} (@code{calc-c-language}) command selects the conventions | |
14264 | of the C language for display and entry of formulas. This differs from | |
14265 | the normal language mode in a variety of (mostly minor) ways. In | |
14266 | particular, C language operators and operator precedences are used in | |
14267 | place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)} | |
14268 | in C mode; a value raised to a power is written as a function call, | |
14269 | @samp{pow(a,b)}. | |
14270 | ||
14271 | In C mode, vectors and matrices use curly braces instead of brackets. | |
14272 | Octal and hexadecimal values are written with leading @samp{0} or @samp{0x} | |
14273 | rather than using the @samp{#} symbol. Array subscripting is | |
14274 | translated into @code{subscr} calls, so that @samp{a[i]} in C | |
07ce2eb3 | 14275 | mode is the same as @samp{a_i} in Normal mode. Assignments |
d7b8e6c6 EZ |
14276 | turn into the @code{assign} function, which Calc normally displays |
14277 | using the @samp{:=} symbol. | |
14278 | ||
4f38ed98 | 14279 | The variables @code{pi} and @code{e} would be displayed @samp{pi} |
07ce2eb3 | 14280 | and @samp{e} in Normal mode, but in C mode they are displayed as |
d7b8e6c6 EZ |
14281 | @samp{M_PI} and @samp{M_E}, corresponding to the names of constants |
14282 | typically provided in the @file{<math.h>} header. Functions whose | |
14283 | names are different in C are translated automatically for entry and | |
14284 | display purposes. For example, entering @samp{asin(x)} will push the | |
14285 | formula @samp{arcsin(x)} onto the stack; this formula will be displayed | |
14286 | as @samp{asin(x)} as long as C mode is in effect. | |
14287 | ||
14288 | @kindex d P | |
14289 | @pindex calc-pascal-language | |
14290 | @cindex Pascal language | |
14291 | The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal | |
14292 | conventions. Like C mode, Pascal mode interprets array brackets and uses | |
14293 | a different table of operators. Hexadecimal numbers are entered and | |
14294 | displayed with a preceding dollar sign. (Thus the regular meaning of | |
14295 | @kbd{$2} during algebraic entry does not work in Pascal mode, though | |
14296 | @kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as | |
14297 | always.) No special provisions are made for other non-decimal numbers, | |
14298 | vectors, and so on, since there is no universally accepted standard way | |
14299 | of handling these in Pascal. | |
14300 | ||
14301 | @kindex d F | |
14302 | @pindex calc-fortran-language | |
14303 | @cindex FORTRAN language | |
14304 | The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN | |
14305 | conventions. Various function names are transformed into FORTRAN | |
14306 | equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be | |
14307 | entered this way or using square brackets. Since FORTRAN uses round | |
14308 | parentheses for both function calls and array subscripts, Calc displays | |
14309 | both in the same way; @samp{a(i)} is interpreted as a function call | |
14310 | upon reading, and subscripts must be entered as @samp{subscr(a, i)}. | |
14311 | Also, if the variable @code{a} has been declared to have type | |
14312 | @code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a | |
14313 | subscript. (@xref{Declarations}.) Usually it doesn't matter, though; | |
14314 | if you enter the subscript expression @samp{a(i)} and Calc interprets | |
14315 | it as a function call, you'll never know the difference unless you | |
14316 | switch to another language mode or replace @code{a} with an actual | |
14317 | vector (or unless @code{a} happens to be the name of a built-in | |
14318 | function!). | |
14319 | ||
14320 | Underscores are allowed in variable and function names in all of these | |
14321 | language modes. The underscore here is equivalent to the @samp{#} in | |
07ce2eb3 | 14322 | Normal mode, or to hyphens in the underlying Emacs Lisp variable names. |
d7b8e6c6 EZ |
14323 | |
14324 | FORTRAN and Pascal modes normally do not adjust the case of letters in | |
14325 | formulas. Most built-in Calc names use lower-case letters. If you use a | |
14326 | positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these | |
14327 | modes will use upper-case letters exclusively for display, and will | |
14328 | convert to lower-case on input. With a negative prefix, these modes | |
14329 | convert to lower-case for display and input. | |
14330 | ||
8ed713c6 | 14331 | @node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes |
053bc283 | 14332 | @subsection @TeX{} and La@TeX{} Language Modes |
d7b8e6c6 EZ |
14333 | |
14334 | @noindent | |
14335 | @kindex d T | |
14336 | @pindex calc-tex-language | |
14337 | @cindex TeX language | |
8ed713c6 JB |
14338 | @kindex d L |
14339 | @pindex calc-latex-language | |
14340 | @cindex LaTeX language | |
d7b8e6c6 | 14341 | The @kbd{d T} (@code{calc-tex-language}) command selects the conventions |
8ed713c6 JB |
14342 | of ``math mode'' in Donald Knuth's @TeX{} typesetting language, |
14343 | and the @kbd{d L} (@code{calc-latex-language}) command selects the | |
053bc283 JB |
14344 | conventions of ``math mode'' in La@TeX{}, a typesetting language that |
14345 | uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can | |
14346 | read any formula that the @TeX{} language mode can, although La@TeX{} | |
8ed713c6 JB |
14347 | mode may display it differently. |
14348 | ||
14349 | Formulas are entered and displayed in the appropriate notation; | |
14350 | @texline @math{\sin(a/b)} | |
14351 | @infoline @expr{sin(a/b)} | |
14352 | will appear as @samp{\sin\left( a \over b \right)} in @TeX{} mode and | |
053bc283 | 14353 | @samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode. |
8ed713c6 | 14354 | Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and |
053bc283 | 14355 | La@TeX{}; these should be omitted when interfacing with Calc. To Calc, |
8ed713c6 JB |
14356 | the @samp{$} sign has the same meaning it always does in algebraic |
14357 | formulas (a reference to an existing entry on the stack). | |
d7b8e6c6 EZ |
14358 | |
14359 | Complex numbers are displayed as in @samp{3 + 4i}. Fractions and | |
8ed713c6 | 14360 | quotients are written using @code{\over} in @TeX{} mode (as in |
053bc283 | 14361 | @code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in |
8ed713c6 JB |
14362 | @code{\frac@{a@}@{b@}}); binomial coefficients are written with |
14363 | @code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and | |
053bc283 | 14364 | @code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}). |
8ed713c6 JB |
14365 | Interval forms are written with @code{\ldots}, and error forms are |
14366 | written with @code{\pm}. Absolute values are written as in | |
14367 | @samp{|x + 1|}, and the floor and ceiling functions are written with | |
14368 | @code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and | |
053bc283 | 14369 | @code{\right} are ignored when reading formulas in @TeX{} and La@TeX{} |
8ed713c6 JB |
14370 | modes. Both @code{inf} and @code{uinf} are written as @code{\infty}; |
14371 | when read, @code{\infty} always translates to @code{inf}. | |
d7b8e6c6 EZ |
14372 | |
14373 | Function calls are written the usual way, with the function name followed | |
8ed713c6 | 14374 | by the arguments in parentheses. However, functions for which @TeX{} |
053bc283 | 14375 | and La@TeX{} have special names (like @code{\sin}) will use curly braces |
8ed713c6 JB |
14376 | instead of parentheses for very simple arguments. During input, curly |
14377 | braces and parentheses work equally well for grouping, but when the | |
14378 | document is formatted the curly braces will be invisible. Thus the | |
14379 | printed result is | |
8e04863e | 14380 | @texline @math{\sin{2 x}} |
a4231b04 JB |
14381 | @infoline @expr{sin 2x} |
14382 | but | |
8e04863e | 14383 | @texline @math{\sin(2 + x)}. |
a4231b04 | 14384 | @infoline @expr{sin(2 + x)}. |
d7b8e6c6 | 14385 | |
053bc283 | 14386 | Function and variable names not treated specially by @TeX{} and La@TeX{} |
8ed713c6 JB |
14387 | are simply written out as-is, which will cause them to come out in |
14388 | italic letters in the printed document. If you invoke @kbd{d T} or | |
14389 | @kbd{d L} with a positive numeric prefix argument, names of more than | |
14390 | one character will instead be enclosed in a protective commands that | |
14391 | will prevent them from being typeset in the math italics; they will be | |
14392 | written @samp{\hbox@{@var{name}@}} in @TeX{} mode and | |
053bc283 | 14393 | @samp{\text@{@var{name}@}} in La@TeX{} mode. The |
8ed713c6 JB |
14394 | @samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during |
14395 | reading. If you use a negative prefix argument, such function names are | |
14396 | written @samp{\@var{name}}, and function names that begin with @code{\} during | |
14397 | reading have the @code{\} removed. (Note that in this mode, long | |
14398 | variable names are still written with @code{\hbox} or @code{\text}. | |
14399 | However, you can always make an actual variable name like @code{\bar} in | |
14400 | any @TeX{} mode.) | |
d7b8e6c6 EZ |
14401 | |
14402 | During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced | |
14403 | by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and | |
053bc283 | 14404 | @code{\bmatrix}. In La@TeX{} mode this also applies to |
8ed713c6 JB |
14405 | @samp{\begin@{matrix@} ... \end@{matrix@}}, |
14406 | @samp{\begin@{bmatrix@} ... \end@{bmatrix@}}, | |
14407 | @samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as | |
14408 | @samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}. | |
14409 | The symbol @samp{&} is interpreted as a comma, | |
d7b8e6c6 EZ |
14410 | and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons. |
14411 | During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}} | |
8ed713c6 JB |
14412 | format in @TeX{} mode and in |
14413 | @samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in | |
053bc283 | 14414 | La@TeX{} mode; you may need to edit this afterwards to change to your |
8ed713c6 JB |
14415 | preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an |
14416 | argument of 2 or -2, then matrices will be displayed in two-dimensional | |
14417 | form, such as | |
14418 | ||
14419 | @example | |
14420 | \begin@{pmatrix@} | |
14421 | a & b \\ | |
14422 | c & d | |
14423 | \end@{pmatrix@} | |
14424 | @end example | |
14425 | ||
14426 | @noindent | |
14427 | This may be convenient for isolated matrices, but could lead to | |
14428 | expressions being displayed like | |
14429 | ||
14430 | @example | |
14431 | \begin@{pmatrix@} \times x | |
14432 | a & b \\ | |
14433 | c & d | |
14434 | \end@{pmatrix@} | |
14435 | @end example | |
14436 | ||
14437 | @noindent | |
053bc283 | 14438 | While this wouldn't bother Calc, it is incorrect La@TeX{}. |
8ed713c6 | 14439 | (Similarly for @TeX{}.) |
d7b8e6c6 EZ |
14440 | |
14441 | Accents like @code{\tilde} and @code{\bar} translate into function | |
14442 | calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline} | |
14443 | sequence is treated as an accent. The @code{\vec} accent corresponds | |
14444 | to the function name @code{Vec}, because @code{vec} is the name of | |
14445 | a built-in Calc function. The following table shows the accents | |
053bc283 | 14446 | in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section): |
d7b8e6c6 EZ |
14447 | |
14448 | @iftex | |
14449 | @begingroup | |
14450 | @let@calcindexershow=@calcindexernoshow @c Suppress marginal notes | |
14451 | @let@calcindexersh=@calcindexernoshow | |
14452 | @end iftex | |
5d67986c RS |
14453 | @ignore |
14454 | @starindex | |
14455 | @end ignore | |
d7b8e6c6 | 14456 | @tindex acute |
5d67986c RS |
14457 | @ignore |
14458 | @starindex | |
14459 | @end ignore | |
8ed713c6 JB |
14460 | @tindex Acute |
14461 | @ignore | |
14462 | @starindex | |
14463 | @end ignore | |
d7b8e6c6 | 14464 | @tindex bar |
5d67986c RS |
14465 | @ignore |
14466 | @starindex | |
14467 | @end ignore | |
8ed713c6 JB |
14468 | @tindex Bar |
14469 | @ignore | |
14470 | @starindex | |
14471 | @end ignore | |
d7b8e6c6 | 14472 | @tindex breve |
5d67986c RS |
14473 | @ignore |
14474 | @starindex | |
14475 | @end ignore | |
8ed713c6 JB |
14476 | @tindex Breve |
14477 | @ignore | |
14478 | @starindex | |
14479 | @end ignore | |
d7b8e6c6 | 14480 | @tindex check |
5d67986c RS |
14481 | @ignore |
14482 | @starindex | |
14483 | @end ignore | |
8ed713c6 JB |
14484 | @tindex Check |
14485 | @ignore | |
14486 | @starindex | |
14487 | @end ignore | |
14488 | @tindex dddot | |
14489 | @ignore | |
14490 | @starindex | |
14491 | @end ignore | |
14492 | @tindex ddddot | |
14493 | @ignore | |
14494 | @starindex | |
14495 | @end ignore | |
d7b8e6c6 | 14496 | @tindex dot |
5d67986c RS |
14497 | @ignore |
14498 | @starindex | |
14499 | @end ignore | |
8ed713c6 JB |
14500 | @tindex Dot |
14501 | @ignore | |
14502 | @starindex | |
14503 | @end ignore | |
d7b8e6c6 | 14504 | @tindex dotdot |
5d67986c RS |
14505 | @ignore |
14506 | @starindex | |
14507 | @end ignore | |
8ed713c6 JB |
14508 | @tindex DotDot |
14509 | @ignore | |
14510 | @starindex | |
14511 | @end ignore | |
d7b8e6c6 | 14512 | @tindex dyad |
5d67986c RS |
14513 | @ignore |
14514 | @starindex | |
14515 | @end ignore | |
d7b8e6c6 | 14516 | @tindex grave |
5d67986c RS |
14517 | @ignore |
14518 | @starindex | |
14519 | @end ignore | |
8ed713c6 JB |
14520 | @tindex Grave |
14521 | @ignore | |
14522 | @starindex | |
14523 | @end ignore | |
d7b8e6c6 | 14524 | @tindex hat |
5d67986c RS |
14525 | @ignore |
14526 | @starindex | |
14527 | @end ignore | |
8ed713c6 JB |
14528 | @tindex Hat |
14529 | @ignore | |
14530 | @starindex | |
14531 | @end ignore | |
d7b8e6c6 | 14532 | @tindex Prime |
5d67986c RS |
14533 | @ignore |
14534 | @starindex | |
14535 | @end ignore | |
d7b8e6c6 | 14536 | @tindex tilde |
5d67986c RS |
14537 | @ignore |
14538 | @starindex | |
14539 | @end ignore | |
8ed713c6 JB |
14540 | @tindex Tilde |
14541 | @ignore | |
14542 | @starindex | |
14543 | @end ignore | |
d7b8e6c6 | 14544 | @tindex under |
5d67986c RS |
14545 | @ignore |
14546 | @starindex | |
14547 | @end ignore | |
d7b8e6c6 | 14548 | @tindex Vec |
8ed713c6 JB |
14549 | @ignore |
14550 | @starindex | |
14551 | @end ignore | |
14552 | @tindex VEC | |
d7b8e6c6 EZ |
14553 | @iftex |
14554 | @endgroup | |
14555 | @end iftex | |
14556 | @example | |
8ed713c6 JB |
14557 | Calc TeX LaTeX eqn |
14558 | ---- --- ----- --- | |
14559 | acute \acute \acute | |
14560 | Acute \Acute | |
14561 | bar \bar \bar bar | |
14562 | Bar \Bar | |
14563 | breve \breve \breve | |
14564 | Breve \Breve | |
14565 | check \check \check | |
14566 | Check \Check | |
14567 | dddot \dddot | |
14568 | ddddot \ddddot | |
14569 | dot \dot \dot dot | |
14570 | Dot \Dot | |
14571 | dotdot \ddot \ddot dotdot | |
14572 | DotDot \Ddot | |
14573 | dyad dyad | |
14574 | grave \grave \grave | |
14575 | Grave \Grave | |
14576 | hat \hat \hat hat | |
14577 | Hat \Hat | |
14578 | Prime prime | |
14579 | tilde \tilde \tilde tilde | |
14580 | Tilde \Tilde | |
14581 | under \underline \underline under | |
14582 | Vec \vec \vec vec | |
14583 | VEC \Vec | |
d7b8e6c6 EZ |
14584 | @end example |
14585 | ||
14586 | The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol: | |
14587 | @samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an | |
14588 | alias for @code{\rightarrow}. However, if the @samp{=>} is the | |
14589 | top-level expression being formatted, a slightly different notation | |
14590 | is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto} | |
14591 | word is ignored by Calc's input routines, and is undefined in @TeX{}. | |
14592 | You will typically want to include one of the following definitions | |
14593 | at the top of a @TeX{} file that uses @code{\evalto}: | |
14594 | ||
14595 | @example | |
14596 | \def\evalto@{@} | |
14597 | \def\evalto#1\to@{@} | |
14598 | @end example | |
14599 | ||
14600 | The first definition formats evaluates-to operators in the usual | |
14601 | way. The second causes only the @var{b} part to appear in the | |
14602 | printed document; the @var{a} part and the arrow are hidden. | |
14603 | Another definition you may wish to use is @samp{\let\to=\Rightarrow} | |
14604 | which causes @code{\to} to appear more like Calc's @samp{=>} symbol. | |
14605 | @xref{Evaluates-To Operator}, for a discussion of @code{evalto}. | |
14606 | ||
14607 | The complete set of @TeX{} control sequences that are ignored during | |
14608 | reading is: | |
14609 | ||
14610 | @example | |
14611 | \hbox \mbox \text \left \right | |
14612 | \, \> \: \; \! \quad \qquad \hfil \hfill | |
14613 | \displaystyle \textstyle \dsize \tsize | |
14614 | \scriptstyle \scriptscriptstyle \ssize \ssize | |
14615 | \rm \bf \it \sl \roman \bold \italic \slanted | |
14616 | \cal \mit \Cal \Bbb \frak \goth | |
14617 | \evalto | |
14618 | @end example | |
14619 | ||
8ed713c6 | 14620 | Note that, because these symbols are ignored, reading a @TeX{} or |
053bc283 | 14621 | La@TeX{} formula into Calc and writing it back out may lose spacing and |
8ed713c6 | 14622 | font information. |
d7b8e6c6 EZ |
14623 | |
14624 | Also, the ``discretionary multiplication sign'' @samp{\*} is read | |
14625 | the same as @samp{*}. | |
14626 | ||
14627 | @ifinfo | |
14628 | The @TeX{} version of this manual includes some printed examples at the | |
14629 | end of this section. | |
14630 | @end ifinfo | |
14631 | @iftex | |
14632 | Here are some examples of how various Calc formulas are formatted in @TeX{}: | |
14633 | ||
d7b8e6c6 | 14634 | @example |
5d67986c | 14635 | @group |
d7b8e6c6 EZ |
14636 | sin(a^2 / b_i) |
14637 | \sin\left( {a^2 \over b_i} \right) | |
5d67986c | 14638 | @end group |
d7b8e6c6 EZ |
14639 | @end example |
14640 | @tex | |
d7b8e6c6 EZ |
14641 | $$ \sin\left( a^2 \over b_i \right) $$ |
14642 | @end tex | |
14643 | @sp 1 | |
d7b8e6c6 | 14644 | |
d7b8e6c6 | 14645 | @example |
5d67986c | 14646 | @group |
d7b8e6c6 EZ |
14647 | [(3, 4), 3:4, 3 +/- 4, [3 .. inf)] |
14648 | [3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)] | |
5d67986c | 14649 | @end group |
d7b8e6c6 EZ |
14650 | @end example |
14651 | @tex | |
14652 | \turnoffactive | |
14653 | $$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$ | |
14654 | @end tex | |
14655 | @sp 1 | |
d7b8e6c6 | 14656 | |
d7b8e6c6 | 14657 | @example |
5d67986c | 14658 | @group |
d7b8e6c6 EZ |
14659 | [abs(a), abs(a / b), floor(a), ceil(a / b)] |
14660 | [|a|, \left| a \over b \right|, | |
14661 | \lfloor a \rfloor, \left\lceil a \over b \right\rceil] | |
5d67986c | 14662 | @end group |
d7b8e6c6 EZ |
14663 | @end example |
14664 | @tex | |
14665 | $$ [|a|, \left| a \over b \right|, | |
14666 | \lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$ | |
14667 | @end tex | |
14668 | @sp 1 | |
d7b8e6c6 | 14669 | |
d7b8e6c6 | 14670 | @example |
5d67986c | 14671 | @group |
d7b8e6c6 EZ |
14672 | [sin(a), sin(2 a), sin(2 + a), sin(a / b)] |
14673 | [\sin@{a@}, \sin@{2 a@}, \sin(2 + a), | |
14674 | \sin\left( @{a \over b@} \right)] | |
5d67986c | 14675 | @end group |
d7b8e6c6 EZ |
14676 | @end example |
14677 | @tex | |
a4231b04 | 14678 | \turnoffactive |
d7b8e6c6 EZ |
14679 | $$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$ |
14680 | @end tex | |
14681 | @sp 2 | |
d7b8e6c6 | 14682 | |
d7b8e6c6 EZ |
14683 | First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with |
14684 | @kbd{C-u - d T} (using the example definition | |
14685 | @samp{\def\foo#1@{\tilde F(#1)@}}: | |
14686 | ||
14687 | @example | |
5d67986c | 14688 | @group |
d7b8e6c6 EZ |
14689 | [f(a), foo(bar), sin(pi)] |
14690 | [f(a), foo(bar), \sin{\pi}] | |
14691 | [f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}] | |
14692 | [f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}] | |
5d67986c | 14693 | @end group |
d7b8e6c6 EZ |
14694 | @end example |
14695 | @tex | |
d7b8e6c6 EZ |
14696 | $$ [f(a), foo(bar), \sin{\pi}] $$ |
14697 | $$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$ | |
14698 | $$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$ | |
14699 | @end tex | |
14700 | @sp 2 | |
d7b8e6c6 | 14701 | |
d7b8e6c6 EZ |
14702 | First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}: |
14703 | ||
14704 | @example | |
5d67986c | 14705 | @group |
d7b8e6c6 EZ |
14706 | 2 + 3 => 5 |
14707 | \evalto 2 + 3 \to 5 | |
5d67986c | 14708 | @end group |
d7b8e6c6 EZ |
14709 | @end example |
14710 | @tex | |
14711 | \turnoffactive | |
14712 | $$ 2 + 3 \to 5 $$ | |
14713 | $$ 5 $$ | |
14714 | @end tex | |
14715 | @sp 2 | |
d7b8e6c6 | 14716 | |
d7b8e6c6 EZ |
14717 | First with standard @code{\to}, then with @samp{\let\to\Rightarrow}: |
14718 | ||
14719 | @example | |
5d67986c | 14720 | @group |
d7b8e6c6 EZ |
14721 | [2 + 3 => 5, a / 2 => (b + c) / 2] |
14722 | [@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}] | |
5d67986c | 14723 | @end group |
d7b8e6c6 EZ |
14724 | @end example |
14725 | @tex | |
14726 | \turnoffactive | |
14727 | $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$ | |
14728 | {\let\to\Rightarrow | |
14729 | $$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$} | |
14730 | @end tex | |
14731 | @sp 2 | |
d7b8e6c6 | 14732 | |
d7b8e6c6 EZ |
14733 | Matrices normally, then changing @code{\matrix} to @code{\pmatrix}: |
14734 | ||
14735 | @example | |
5d67986c | 14736 | @group |
d7b8e6c6 EZ |
14737 | [ [ a / b, 0 ], [ 0, 2^(x + 1) ] ] |
14738 | \matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} | |
14739 | \pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @} | |
5d67986c | 14740 | @end group |
d7b8e6c6 EZ |
14741 | @end example |
14742 | @tex | |
14743 | \turnoffactive | |
14744 | $$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ | |
14745 | $$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$ | |
14746 | @end tex | |
14747 | @sp 2 | |
d7b8e6c6 EZ |
14748 | @end iftex |
14749 | ||
8ed713c6 | 14750 | @node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes |
d7b8e6c6 EZ |
14751 | @subsection Eqn Language Mode |
14752 | ||
14753 | @noindent | |
14754 | @kindex d E | |
14755 | @pindex calc-eqn-language | |
14756 | @dfn{Eqn} is another popular formatter for math formulas. It is | |
14757 | designed for use with the TROFF text formatter, and comes standard | |
14758 | with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language}) | |
14759 | command selects @dfn{eqn} notation. | |
14760 | ||
14761 | The @dfn{eqn} language's main idiosyncrasy is that whitespace plays | |
14762 | a significant part in the parsing of the language. For example, | |
14763 | @samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the | |
14764 | @code{sqrt} operator. @dfn{Eqn} also understands more conventional | |
14765 | grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are | |
14766 | required only when the argument contains spaces. | |
14767 | ||
14768 | In Calc's @dfn{eqn} mode, however, curly braces are required to | |
14769 | delimit arguments of operators like @code{sqrt}. The first of the | |
14770 | above examples would treat only the @samp{x} as the argument of | |
14771 | @code{sqrt}, and in fact @samp{sin x+1} would be interpreted as | |
14772 | @samp{sin * x + 1}, because @code{sin} is not a special operator | |
14773 | in the @dfn{eqn} language. If you always surround the argument | |
14774 | with curly braces, Calc will never misunderstand. | |
14775 | ||
14776 | Calc also understands parentheses as grouping characters. Another | |
14777 | peculiarity of @dfn{eqn}'s syntax makes it advisable to separate | |
14778 | words with spaces from any surrounding characters that aren't curly | |
14779 | braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode. | |
14780 | (The spaces around @code{sin} are important to make @dfn{eqn} | |
14781 | recognize that @code{sin} should be typeset in a roman font, and | |
14782 | the spaces around @code{x} and @code{y} are a good idea just in | |
14783 | case the @dfn{eqn} document has defined special meanings for these | |
14784 | names, too.) | |
14785 | ||
14786 | Powers and subscripts are written with the @code{sub} and @code{sup} | |
14787 | operators, respectively. Note that the caret symbol @samp{^} is | |
14788 | treated the same as a space in @dfn{eqn} mode, as is the @samp{~} | |
14789 | symbol (these are used to introduce spaces of various widths into | |
14790 | the typeset output of @dfn{eqn}). | |
14791 | ||
053bc283 | 14792 | As in La@TeX{} mode, Calc's formatter omits parentheses around the |
d7b8e6c6 EZ |
14793 | arguments of functions like @code{ln} and @code{sin} if they are |
14794 | ``simple-looking''; in this case Calc surrounds the argument with | |
14795 | braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}. | |
14796 | ||
14797 | Font change codes (like @samp{roman @var{x}}) and positioning codes | |
14798 | (like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the | |
14799 | @dfn{eqn} reader. Also ignored are the words @code{left}, @code{right}, | |
14800 | @code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input | |
14801 | are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to | |
14802 | @samp{sqrt @{1+x@}}; this is only an approximation to the true meaning | |
14803 | of quotes in @dfn{eqn}, but it is good enough for most uses. | |
14804 | ||
14805 | Accent codes (@samp{@var{x} dot}) are handled by treating them as | |
8ed713c6 JB |
14806 | function calls (@samp{dot(@var{x})}) internally. |
14807 | @xref{TeX and LaTeX Language Modes}, for a table of these accent | |
14808 | functions. The @code{prime} accent is treated specially if it occurs on | |
14809 | a variable or function name: @samp{f prime prime @w{( x prime )}} is | |
14810 | stored internally as @samp{f'@w{'}(x')}. For example, taking the | |
14811 | derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2 | |
14812 | x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}. | |
d7b8e6c6 EZ |
14813 | |
14814 | Assignments are written with the @samp{<-} (left-arrow) symbol, | |
14815 | and @code{evalto} operators are written with @samp{->} or | |
8ed713c6 | 14816 | @samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion |
d7b8e6c6 EZ |
14817 | of this). The regular Calc symbols @samp{:=} and @samp{=>} are also |
14818 | recognized for these operators during reading. | |
14819 | ||
14820 | Vectors in @dfn{eqn} mode use regular Calc square brackets, but | |
14821 | matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}. | |
14822 | The words @code{lcol} and @code{rcol} are recognized as synonyms | |
14823 | for @code{ccol} during input, and are generated instead of @code{ccol} | |
14824 | if the matrix justification mode so specifies. | |
14825 | ||
14826 | @node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes | |
14827 | @subsection Mathematica Language Mode | |
14828 | ||
14829 | @noindent | |
14830 | @kindex d M | |
14831 | @pindex calc-mathematica-language | |
14832 | @cindex Mathematica language | |
14833 | The @kbd{d M} (@code{calc-mathematica-language}) command selects the | |
87101b33 | 14834 | conventions of Mathematica. Notable differences in Mathematica mode |
d7b8e6c6 EZ |
14835 | are that the names of built-in functions are capitalized, and function |
14836 | calls use square brackets instead of parentheses. Thus the Calc | |
14837 | formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in | |
14838 | Mathematica mode. | |
14839 | ||
14840 | Vectors and matrices use curly braces in Mathematica. Complex numbers | |
14841 | are written @samp{3 + 4 I}. The standard special constants in Calc are | |
14842 | written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma}, | |
14843 | @code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in | |
14844 | Mathematica mode. | |
14845 | Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point | |
14846 | numbers in scientific notation are written @samp{1.23*10.^3}. | |
a4231b04 | 14847 | Subscripts use double square brackets: @samp{a[[i]]}. |
d7b8e6c6 EZ |
14848 | |
14849 | @node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes | |
14850 | @subsection Maple Language Mode | |
14851 | ||
14852 | @noindent | |
14853 | @kindex d W | |
14854 | @pindex calc-maple-language | |
14855 | @cindex Maple language | |
14856 | The @kbd{d W} (@code{calc-maple-language}) command selects the | |
87101b33 | 14857 | conventions of Maple. |
d7b8e6c6 EZ |
14858 | |
14859 | Maple's language is much like C. Underscores are allowed in symbol | |
14860 | names; square brackets are used for subscripts; explicit @samp{*}s for | |
14861 | multiplications are required. Use either @samp{^} or @samp{**} to | |
14862 | denote powers. | |
14863 | ||
14864 | Maple uses square brackets for lists and curly braces for sets. Calc | |
14865 | interprets both notations as vectors, and displays vectors with square | |
14866 | brackets. This means Maple sets will be converted to lists when they | |
14867 | pass through Calc. As a special case, matrices are written as calls | |
14868 | to the function @code{matrix}, given a list of lists as the argument, | |
14869 | and can be read in this form or with all-capitals @code{MATRIX}. | |
14870 | ||
14871 | The Maple interval notation @samp{2 .. 3} has no surrounding brackets; | |
14872 | Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and | |
14873 | writes any kind of interval as @samp{2 .. 3}. This means you cannot | |
14874 | see the difference between an open and a closed interval while in | |
14875 | Maple display mode. | |
14876 | ||
14877 | Maple writes complex numbers as @samp{3 + 4*I}. Its special constants | |
14878 | are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of | |
14879 | @code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}). | |
14880 | Floating-point numbers are written @samp{1.23*10.^3}. | |
14881 | ||
14882 | Among things not currently handled by Calc's Maple mode are the | |
14883 | various quote symbols, procedures and functional operators, and | |
14884 | inert (@samp{&}) operators. | |
14885 | ||
14886 | @node Compositions, Syntax Tables, Maple Language Mode, Language Modes | |
14887 | @subsection Compositions | |
14888 | ||
14889 | @noindent | |
14890 | @cindex Compositions | |
14891 | There are several @dfn{composition functions} which allow you to get | |
14892 | displays in a variety of formats similar to those in Big language | |
14893 | mode. Most of these functions do not evaluate to anything; they are | |
14894 | placeholders which are left in symbolic form by Calc's evaluator but | |
14895 | are recognized by Calc's display formatting routines. | |
14896 | ||
14897 | Two of these, @code{string} and @code{bstring}, are described elsewhere. | |
14898 | @xref{Strings}. For example, @samp{string("ABC")} is displayed as | |
14899 | @samp{ABC}. When viewed on the stack it will be indistinguishable from | |
14900 | the variable @code{ABC}, but internally it will be stored as | |
14901 | @samp{string([65, 66, 67])} and can still be manipulated this way; for | |
14902 | example, the selection and vector commands @kbd{j 1 v v j u} would | |
14903 | select the vector portion of this object and reverse the elements, then | |
14904 | deselect to reveal a string whose characters had been reversed. | |
14905 | ||
14906 | The composition functions do the same thing in all language modes | |
14907 | (although their components will of course be formatted in the current | |
14908 | language mode). The one exception is Unformatted mode (@kbd{d U}), | |
14909 | which does not give the composition functions any special treatment. | |
14910 | The functions are discussed here because of their relationship to | |
14911 | the language modes. | |
14912 | ||
14913 | @menu | |
14914 | * Composition Basics:: | |
14915 | * Horizontal Compositions:: | |
14916 | * Vertical Compositions:: | |
14917 | * Other Compositions:: | |
14918 | * Information about Compositions:: | |
14919 | * User-Defined Compositions:: | |
14920 | @end menu | |
14921 | ||
14922 | @node Composition Basics, Horizontal Compositions, Compositions, Compositions | |
14923 | @subsubsection Composition Basics | |
14924 | ||
14925 | @noindent | |
14926 | Compositions are generally formed by stacking formulas together | |
14927 | horizontally or vertically in various ways. Those formulas are | |
14928 | themselves compositions. @TeX{} users will find this analogous | |
14929 | to @TeX{}'s ``boxes.'' Each multi-line composition has a | |
14930 | @dfn{baseline}; horizontal compositions use the baselines to | |
14931 | decide how formulas should be positioned relative to one another. | |
14932 | For example, in the Big mode formula | |
14933 | ||
d7b8e6c6 | 14934 | @example |
5d67986c | 14935 | @group |
d7b8e6c6 EZ |
14936 | 2 |
14937 | a + b | |
14938 | 17 + ------ | |
14939 | c | |
d7b8e6c6 | 14940 | @end group |
5d67986c | 14941 | @end example |
d7b8e6c6 EZ |
14942 | |
14943 | @noindent | |
14944 | the second term of the sum is four lines tall and has line three as | |
14945 | its baseline. Thus when the term is combined with 17, line three | |
14946 | is placed on the same level as the baseline of 17. | |
14947 | ||
14948 | @tex | |
14949 | \bigskip | |
14950 | @end tex | |
14951 | ||
14952 | Another important composition concept is @dfn{precedence}. This is | |
14953 | an integer that represents the binding strength of various operators. | |
14954 | For example, @samp{*} has higher precedence (195) than @samp{+} (180), | |
14955 | which means that @samp{(a * b) + c} will be formatted without the | |
14956 | parentheses, but @samp{a * (b + c)} will keep the parentheses. | |
14957 | ||
14958 | The operator table used by normal and Big language modes has the | |
14959 | following precedences: | |
14960 | ||
14961 | @example | |
14962 | _ 1200 @r{(subscripts)} | |
14963 | % 1100 @r{(as in n}%@r{)} | |
14964 | - 1000 @r{(as in }-@r{n)} | |
14965 | ! 1000 @r{(as in }!@r{n)} | |
14966 | mod 400 | |
14967 | +/- 300 | |
14968 | !! 210 @r{(as in n}!!@r{)} | |
14969 | ! 210 @r{(as in n}!@r{)} | |
14970 | ^ 200 | |
14971 | * 195 @r{(or implicit multiplication)} | |
14972 | / % \ 190 | |
14973 | + - 180 @r{(as in a}+@r{b)} | |
14974 | | 170 | |
14975 | < = 160 @r{(and other relations)} | |
14976 | && 110 | |
14977 | || 100 | |
14978 | ? : 90 | |
14979 | !!! 85 | |
14980 | &&& 80 | |
14981 | ||| 75 | |
14982 | := 50 | |
14983 | :: 45 | |
14984 | => 40 | |
14985 | @end example | |
14986 | ||
a4231b04 JB |
14987 | The general rule is that if an operator with precedence @expr{n} |
14988 | occurs as an argument to an operator with precedence @expr{m}, then | |
14989 | the argument is enclosed in parentheses if @expr{n < m}. Top-level | |
d7b8e6c6 EZ |
14990 | expressions and expressions which are function arguments, vector |
14991 | components, etc., are formatted with precedence zero (so that they | |
14992 | normally never get additional parentheses). | |
14993 | ||
14994 | For binary left-associative operators like @samp{+}, the righthand | |
14995 | argument is actually formatted with one-higher precedence than shown | |
14996 | in the table. This makes sure @samp{(a + b) + c} omits the parentheses, | |
14997 | but the unnatural form @samp{a + (b + c)} keeps its parentheses. | |
14998 | Right-associative operators like @samp{^} format the lefthand argument | |
14999 | with one-higher precedence. | |
15000 | ||
5d67986c RS |
15001 | @ignore |
15002 | @starindex | |
15003 | @end ignore | |
d7b8e6c6 EZ |
15004 | @tindex cprec |
15005 | The @code{cprec} function formats an expression with an arbitrary | |
15006 | precedence. For example, @samp{cprec(abc, 185)} will combine into | |
15007 | sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because | |
15008 | this @code{cprec} form has higher precedence than addition, but lower | |
15009 | precedence than multiplication). | |
15010 | ||
15011 | @tex | |
15012 | \bigskip | |
15013 | @end tex | |
15014 | ||
15015 | A final composition issue is @dfn{line breaking}. Calc uses two | |
15016 | different strategies for ``flat'' and ``non-flat'' compositions. | |
15017 | A non-flat composition is anything that appears on multiple lines | |
15018 | (not counting line breaking). Examples would be matrices and Big | |
15019 | mode powers and quotients. Non-flat compositions are displayed | |
15020 | exactly as specified. If they come out wider than the current | |
15021 | window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to | |
15022 | view them. | |
15023 | ||
15024 | Flat compositions, on the other hand, will be broken across several | |
15025 | lines if they are too wide to fit the window. Certain points in a | |
15026 | composition are noted internally as @dfn{break points}. Calc's | |
15027 | general strategy is to fill each line as much as possible, then to | |
15028 | move down to the next line starting at the first break point that | |
15029 | didn't fit. However, the line breaker understands the hierarchical | |
15030 | structure of formulas. It will not break an ``inner'' formula if | |
15031 | it can use an earlier break point from an ``outer'' formula instead. | |
15032 | For example, a vector of sums might be formatted as: | |
15033 | ||
d7b8e6c6 | 15034 | @example |
5d67986c | 15035 | @group |
d7b8e6c6 EZ |
15036 | [ a + b + c, d + e + f, |
15037 | g + h + i, j + k + l, m ] | |
d7b8e6c6 | 15038 | @end group |
5d67986c | 15039 | @end example |
d7b8e6c6 EZ |
15040 | |
15041 | @noindent | |
15042 | If the @samp{m} can fit, then so, it seems, could the @samp{g}. | |
15043 | But Calc prefers to break at the comma since the comma is part | |
15044 | of a ``more outer'' formula. Calc would break at a plus sign | |
15045 | only if it had to, say, if the very first sum in the vector had | |
15046 | itself been too large to fit. | |
15047 | ||
15048 | Of the composition functions described below, only @code{choriz} | |
15049 | generates break points. The @code{bstring} function (@pxref{Strings}) | |
15050 | also generates breakable items: A break point is added after every | |
15051 | space (or group of spaces) except for spaces at the very beginning or | |
15052 | end of the string. | |
15053 | ||
15054 | Composition functions themselves count as levels in the formula | |
15055 | hierarchy, so a @code{choriz} that is a component of a larger | |
15056 | @code{choriz} will be less likely to be broken. As a special case, | |
15057 | if a @code{bstring} occurs as a component of a @code{choriz} or | |
15058 | @code{choriz}-like object (such as a vector or a list of arguments | |
15059 | in a function call), then the break points in that @code{bstring} | |
15060 | will be on the same level as the break points of the surrounding | |
15061 | object. | |
15062 | ||
15063 | @node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions | |
15064 | @subsubsection Horizontal Compositions | |
15065 | ||
15066 | @noindent | |
5d67986c RS |
15067 | @ignore |
15068 | @starindex | |
15069 | @end ignore | |
d7b8e6c6 EZ |
15070 | @tindex choriz |
15071 | The @code{choriz} function takes a vector of objects and composes | |
15072 | them horizontally. For example, @samp{choriz([17, a b/c, d])} formats | |
07ce2eb3 | 15073 | as @w{@samp{17a b / cd}} in Normal language mode, or as |
d7b8e6c6 | 15074 | |
d7b8e6c6 | 15075 | @example |
5d67986c | 15076 | @group |
d7b8e6c6 EZ |
15077 | a b |
15078 | 17---d | |
15079 | c | |
d7b8e6c6 | 15080 | @end group |
5d67986c | 15081 | @end example |
d7b8e6c6 EZ |
15082 | |
15083 | @noindent | |
15084 | in Big language mode. This is actually one case of the general | |
15085 | function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where | |
15086 | either or both of @var{sep} and @var{prec} may be omitted. | |
15087 | @var{Prec} gives the @dfn{precedence} to use when formatting | |
15088 | each of the components of @var{vec}. The default precedence is | |
15089 | the precedence from the surrounding environment. | |
15090 | ||
15091 | @var{Sep} is a string (i.e., a vector of character codes as might | |
15092 | be entered with @code{" "} notation) which should separate components | |
15093 | of the composition. Also, if @var{sep} is given, the line breaker | |
15094 | will allow lines to be broken after each occurrence of @var{sep}. | |
15095 | If @var{sep} is omitted, the composition will not be breakable | |
15096 | (unless any of its component compositions are breakable). | |
15097 | ||
15098 | For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is | |
15099 | formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz} | |
15100 | to have precedence 180 ``outwards'' as well as ``inwards,'' | |
15101 | enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)} | |
15102 | formats as @samp{2 (a + b c + (d = e))}. | |
15103 | ||
15104 | The baseline of a horizontal composition is the same as the | |
15105 | baselines of the component compositions, which are all aligned. | |
15106 | ||
15107 | @node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions | |
15108 | @subsubsection Vertical Compositions | |
15109 | ||
15110 | @noindent | |
5d67986c RS |
15111 | @ignore |
15112 | @starindex | |
15113 | @end ignore | |
d7b8e6c6 EZ |
15114 | @tindex cvert |
15115 | The @code{cvert} function makes a vertical composition. Each | |
15116 | component of the vector is centered in a column. The baseline of | |
15117 | the result is by default the top line of the resulting composition. | |
15118 | For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))} | |
15119 | formats in Big mode as | |
15120 | ||
d7b8e6c6 | 15121 | @example |
5d67986c | 15122 | @group |
d7b8e6c6 EZ |
15123 | f( a , 2 ) |
15124 | bb a + 1 | |
15125 | ccc 2 | |
15126 | b | |
d7b8e6c6 | 15127 | @end group |
5d67986c | 15128 | @end example |
d7b8e6c6 | 15129 | |
5d67986c RS |
15130 | @ignore |
15131 | @starindex | |
15132 | @end ignore | |
d7b8e6c6 EZ |
15133 | @tindex cbase |
15134 | There are several special composition functions that work only as | |
15135 | components of a vertical composition. The @code{cbase} function | |
15136 | controls the baseline of the vertical composition; the baseline | |
15137 | will be the same as the baseline of whatever component is enclosed | |
15138 | in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]), | |
15139 | cvert([a^2 + 1, cbase(b^2)]))} displays as | |
15140 | ||
d7b8e6c6 | 15141 | @example |
5d67986c | 15142 | @group |
d7b8e6c6 EZ |
15143 | 2 |
15144 | a + 1 | |
15145 | a 2 | |
15146 | f(bb , b ) | |
15147 | ccc | |
d7b8e6c6 | 15148 | @end group |
5d67986c | 15149 | @end example |
d7b8e6c6 | 15150 | |
5d67986c RS |
15151 | @ignore |
15152 | @starindex | |
15153 | @end ignore | |
d7b8e6c6 | 15154 | @tindex ctbase |
5d67986c RS |
15155 | @ignore |
15156 | @starindex | |
15157 | @end ignore | |
d7b8e6c6 EZ |
15158 | @tindex cbbase |
15159 | There are also @code{ctbase} and @code{cbbase} functions which | |
15160 | make the baseline of the vertical composition equal to the top | |
15161 | or bottom line (rather than the baseline) of that component. | |
15162 | Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) + | |
15163 | cvert([cbbase(a / b)])} gives | |
15164 | ||
d7b8e6c6 | 15165 | @example |
5d67986c | 15166 | @group |
d7b8e6c6 EZ |
15167 | a |
15168 | a - | |
15169 | - + a + b | |
15170 | b - | |
15171 | b | |
d7b8e6c6 | 15172 | @end group |
5d67986c | 15173 | @end example |
d7b8e6c6 EZ |
15174 | |
15175 | There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase} | |
15176 | function in a given vertical composition. These functions can also | |
15177 | be written with no arguments: @samp{ctbase()} is a zero-height object | |
15178 | which means the baseline is the top line of the following item, and | |
15179 | @samp{cbbase()} means the baseline is the bottom line of the preceding | |
15180 | item. | |
15181 | ||
5d67986c RS |
15182 | @ignore |
15183 | @starindex | |
15184 | @end ignore | |
d7b8e6c6 EZ |
15185 | @tindex crule |
15186 | The @code{crule} function builds a ``rule,'' or horizontal line, | |
15187 | across a vertical composition. By itself @samp{crule()} uses @samp{-} | |
15188 | characters to build the rule. You can specify any other character, | |
15189 | e.g., @samp{crule("=")}. The argument must be a character code or | |
15190 | vector of exactly one character code. It is repeated to match the | |
15191 | width of the widest item in the stack. For example, a quotient | |
15192 | with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}: | |
15193 | ||
d7b8e6c6 | 15194 | @example |
5d67986c | 15195 | @group |
d7b8e6c6 EZ |
15196 | a + 1 |
15197 | ===== | |
15198 | 2 | |
15199 | b | |
d7b8e6c6 | 15200 | @end group |
5d67986c | 15201 | @end example |
d7b8e6c6 | 15202 | |
5d67986c RS |
15203 | @ignore |
15204 | @starindex | |
15205 | @end ignore | |
d7b8e6c6 | 15206 | @tindex clvert |
5d67986c RS |
15207 | @ignore |
15208 | @starindex | |
15209 | @end ignore | |
d7b8e6c6 EZ |
15210 | @tindex crvert |
15211 | Finally, the functions @code{clvert} and @code{crvert} act exactly | |
15212 | like @code{cvert} except that the items are left- or right-justified | |
15213 | in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])} | |
15214 | gives: | |
15215 | ||
d7b8e6c6 | 15216 | @example |
5d67986c | 15217 | @group |
d7b8e6c6 EZ |
15218 | a + a |
15219 | bb bb | |
15220 | ccc ccc | |
d7b8e6c6 | 15221 | @end group |
5d67986c | 15222 | @end example |
d7b8e6c6 EZ |
15223 | |
15224 | Like @code{choriz}, the vertical compositions accept a second argument | |
15225 | which gives the precedence to use when formatting the components. | |
15226 | Vertical compositions do not support separator strings. | |
15227 | ||
15228 | @node Other Compositions, Information about Compositions, Vertical Compositions, Compositions | |
15229 | @subsubsection Other Compositions | |
15230 | ||
15231 | @noindent | |
5d67986c RS |
15232 | @ignore |
15233 | @starindex | |
15234 | @end ignore | |
d7b8e6c6 EZ |
15235 | @tindex csup |
15236 | The @code{csup} function builds a superscripted expression. For | |
15237 | example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big | |
15238 | language mode. This is essentially a horizontal composition of | |
15239 | @samp{a} and @samp{b}, where @samp{b} is shifted up so that its | |
15240 | bottom line is one above the baseline. | |
15241 | ||
5d67986c RS |
15242 | @ignore |
15243 | @starindex | |
15244 | @end ignore | |
d7b8e6c6 EZ |
15245 | @tindex csub |
15246 | Likewise, the @code{csub} function builds a subscripted expression. | |
15247 | This shifts @samp{b} down so that its top line is one below the | |
15248 | bottom line of @samp{a} (note that this is not quite analogous to | |
15249 | @code{csup}). Other arrangements can be obtained by using | |
15250 | @code{choriz} and @code{cvert} directly. | |
15251 | ||
5d67986c RS |
15252 | @ignore |
15253 | @starindex | |
15254 | @end ignore | |
d7b8e6c6 EZ |
15255 | @tindex cflat |
15256 | The @code{cflat} function formats its argument in ``flat'' mode, | |
15257 | as obtained by @samp{d O}, if the current language mode is normal | |
15258 | or Big. It has no effect in other language modes. For example, | |
15259 | @samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))} | |
15260 | to improve its readability. | |
15261 | ||
5d67986c RS |
15262 | @ignore |
15263 | @starindex | |
15264 | @end ignore | |
d7b8e6c6 EZ |
15265 | @tindex cspace |
15266 | The @code{cspace} function creates horizontal space. For example, | |
15267 | @samp{cspace(4)} is effectively the same as @samp{string(" ")}. | |
15268 | A second string (i.e., vector of characters) argument is repeated | |
15269 | instead of the space character. For example, @samp{cspace(4, "ab")} | |
15270 | looks like @samp{abababab}. If the second argument is not a string, | |
15271 | it is formatted in the normal way and then several copies of that | |
15272 | are composed together: @samp{cspace(4, a^2)} yields | |
15273 | ||
d7b8e6c6 | 15274 | @example |
5d67986c | 15275 | @group |
d7b8e6c6 EZ |
15276 | 2 2 2 2 |
15277 | a a a a | |
d7b8e6c6 | 15278 | @end group |
5d67986c | 15279 | @end example |
d7b8e6c6 EZ |
15280 | |
15281 | @noindent | |
15282 | If the number argument is zero, this is a zero-width object. | |
15283 | ||
5d67986c RS |
15284 | @ignore |
15285 | @starindex | |
15286 | @end ignore | |
d7b8e6c6 EZ |
15287 | @tindex cvspace |
15288 | The @code{cvspace} function creates vertical space, or a vertical | |
15289 | stack of copies of a certain string or formatted object. The | |
15290 | baseline is the center line of the resulting stack. A numerical | |
15291 | argument of zero will produce an object which contributes zero | |
15292 | height if used in a vertical composition. | |
15293 | ||
5d67986c RS |
15294 | @ignore |
15295 | @starindex | |
15296 | @end ignore | |
d7b8e6c6 | 15297 | @tindex ctspace |
5d67986c RS |
15298 | @ignore |
15299 | @starindex | |
15300 | @end ignore | |
d7b8e6c6 EZ |
15301 | @tindex cbspace |
15302 | There are also @code{ctspace} and @code{cbspace} functions which | |
15303 | create vertical space with the baseline the same as the baseline | |
15304 | of the top or bottom copy, respectively, of the second argument. | |
15305 | Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)} | |
15306 | displays as: | |
15307 | ||
d7b8e6c6 | 15308 | @example |
5d67986c | 15309 | @group |
d7b8e6c6 EZ |
15310 | a |
15311 | - | |
15312 | a b | |
15313 | - a a | |
15314 | b + - + - | |
15315 | a b b | |
15316 | - a | |
15317 | b - | |
15318 | b | |
d7b8e6c6 | 15319 | @end group |
5d67986c | 15320 | @end example |
d7b8e6c6 EZ |
15321 | |
15322 | @node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions | |
15323 | @subsubsection Information about Compositions | |
15324 | ||
15325 | @noindent | |
15326 | The functions in this section are actual functions; they compose their | |
15327 | arguments according to the current language and other display modes, | |
15328 | then return a certain measurement of the composition as an integer. | |
15329 | ||
5d67986c RS |
15330 | @ignore |
15331 | @starindex | |
15332 | @end ignore | |
d7b8e6c6 EZ |
15333 | @tindex cwidth |
15334 | The @code{cwidth} function measures the width, in characters, of a | |
15335 | composition. For example, @samp{cwidth(a + b)} is 5, and | |
07ce2eb3 | 15336 | @samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in |
d7b8e6c6 EZ |
15337 | @TeX{} mode (for @samp{@{a \over b@}}). The argument may involve |
15338 | the composition functions described in this section. | |
15339 | ||
5d67986c RS |
15340 | @ignore |
15341 | @starindex | |
15342 | @end ignore | |
d7b8e6c6 EZ |
15343 | @tindex cheight |
15344 | The @code{cheight} function measures the height of a composition. | |
15345 | This is the total number of lines in the argument's printed form. | |
15346 | ||
5d67986c RS |
15347 | @ignore |
15348 | @starindex | |
15349 | @end ignore | |
d7b8e6c6 | 15350 | @tindex cascent |
5d67986c RS |
15351 | @ignore |
15352 | @starindex | |
15353 | @end ignore | |
d7b8e6c6 EZ |
15354 | @tindex cdescent |
15355 | The functions @code{cascent} and @code{cdescent} measure the amount | |
15356 | of the height that is above (and including) the baseline, or below | |
15357 | the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})} | |
15358 | always equals @samp{cheight(@var{x})}. For a one-line formula like | |
15359 | @samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0. | |
15360 | For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent} | |
15361 | returns 1. The only formula for which @code{cascent} will return zero | |
15362 | is @samp{cvspace(0)} or equivalents. | |
15363 | ||
15364 | @node User-Defined Compositions, , Information about Compositions, Compositions | |
15365 | @subsubsection User-Defined Compositions | |
15366 | ||
15367 | @noindent | |
15368 | @kindex Z C | |
15369 | @pindex calc-user-define-composition | |
15370 | The @kbd{Z C} (@code{calc-user-define-composition}) command lets you | |
15371 | define the display format for any algebraic function. You provide a | |
15372 | formula containing a certain number of argument variables on the stack. | |
15373 | Any time Calc formats a call to the specified function in the current | |
15374 | language mode and with that number of arguments, Calc effectively | |
15375 | replaces the function call with that formula with the arguments | |
15376 | replaced. | |
15377 | ||
15378 | Calc builds the default argument list by sorting all the variable names | |
15379 | that appear in the formula into alphabetical order. You can edit this | |
15380 | argument list before pressing @key{RET} if you wish. Any variables in | |
15381 | the formula that do not appear in the argument list will be displayed | |
15382 | literally; any arguments that do not appear in the formula will not | |
15383 | affect the display at all. | |
15384 | ||
15385 | You can define formats for built-in functions, for functions you have | |
15386 | defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions | |
15387 | which have no definitions but are being used as purely syntactic objects. | |
15388 | You can define different formats for each language mode, and for each | |
15389 | number of arguments, using a succession of @kbd{Z C} commands. When | |
15390 | Calc formats a function call, it first searches for a format defined | |
15391 | for the current language mode (and number of arguments); if there is | |
15392 | none, it uses the format defined for the Normal language mode. If | |
15393 | neither format exists, Calc uses its built-in standard format for that | |
15394 | function (usually just @samp{@var{func}(@var{args})}). | |
15395 | ||
15396 | If you execute @kbd{Z C} with the number 0 on the stack instead of a | |
15397 | formula, any defined formats for the function in the current language | |
15398 | mode will be removed. The function will revert to its standard format. | |
15399 | ||
15400 | For example, the default format for the binomial coefficient function | |
15401 | @samp{choose(n, m)} in the Big language mode is | |
15402 | ||
d7b8e6c6 | 15403 | @example |
5d67986c | 15404 | @group |
d7b8e6c6 EZ |
15405 | n |
15406 | ( ) | |
15407 | m | |
d7b8e6c6 | 15408 | @end group |
5d67986c | 15409 | @end example |
d7b8e6c6 EZ |
15410 | |
15411 | @noindent | |
15412 | You might prefer the notation, | |
15413 | ||
d7b8e6c6 | 15414 | @example |
5d67986c | 15415 | @group |
d7b8e6c6 EZ |
15416 | C |
15417 | n m | |
d7b8e6c6 | 15418 | @end group |
5d67986c | 15419 | @end example |
d7b8e6c6 EZ |
15420 | |
15421 | @noindent | |
15422 | To define this notation, first make sure you are in Big mode, | |
15423 | then put the formula | |
15424 | ||
15425 | @smallexample | |
15426 | choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])]) | |
15427 | @end smallexample | |
15428 | ||
15429 | @noindent | |
15430 | on the stack and type @kbd{Z C}. Answer the first prompt with | |
15431 | @code{choose}. The second prompt will be the default argument list | |
15432 | of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press | |
15433 | @key{RET}. Now, try it out: For example, turn simplification | |
15434 | off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)} | |
15435 | as an algebraic entry. | |
15436 | ||
d7b8e6c6 | 15437 | @example |
5d67986c | 15438 | @group |
177c0ea7 | 15439 | C + C |
d7b8e6c6 | 15440 | a b 7 3 |
d7b8e6c6 | 15441 | @end group |
5d67986c | 15442 | @end example |
d7b8e6c6 EZ |
15443 | |
15444 | As another example, let's define the usual notation for Stirling | |
15445 | numbers of the first kind, @samp{stir1(n, m)}. This is just like | |
15446 | the regular format for binomial coefficients but with square brackets | |
15447 | instead of parentheses. | |
15448 | ||
15449 | @smallexample | |
15450 | choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")]) | |
15451 | @end smallexample | |
15452 | ||
15453 | Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to | |
15454 | @samp{(n m)}, and type @key{RET}. | |
15455 | ||
15456 | The formula provided to @kbd{Z C} usually will involve composition | |
15457 | functions, but it doesn't have to. Putting the formula @samp{a + b + c} | |
15458 | onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define | |
15459 | the function @samp{foo(x,y,z)} to display like @samp{x + y + z}. | |
15460 | This ``sum'' will act exactly like a real sum for all formatting | |
15461 | purposes (it will be parenthesized the same, and so on). However | |
15462 | it will be computationally unrelated to a sum. For example, the | |
15463 | formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}. | |
15464 | Operator precedences have caused the ``sum'' to be written in | |
15465 | parentheses, but the arguments have not actually been summed. | |
15466 | (Generally a display format like this would be undesirable, since | |
15467 | it can easily be confused with a real sum.) | |
15468 | ||
15469 | The special function @code{eval} can be used inside a @kbd{Z C} | |
15470 | composition formula to cause all or part of the formula to be | |
15471 | evaluated at display time. For example, if the formula is | |
15472 | @samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed | |
15473 | as @samp{1 + 5}. Evaluation will use the default simplifications, | |
15474 | regardless of the current simplification mode. There are also | |
15475 | @code{evalsimp} and @code{evalextsimp} which simplify as if by | |
15476 | @kbd{a s} and @kbd{a e} (respectively). Note that these ``functions'' | |
15477 | operate only in the context of composition formulas (and also in | |
15478 | rewrite rules, where they serve a similar purpose; @pxref{Rewrite | |
15479 | Rules}). On the stack, a call to @code{eval} will be left in | |
15480 | symbolic form. | |
15481 | ||
15482 | It is not a good idea to use @code{eval} except as a last resort. | |
15483 | It can cause the display of formulas to be extremely slow. For | |
15484 | example, while @samp{eval(a + b)} might seem quite fast and simple, | |
15485 | there are several situations where it could be slow. For example, | |
15486 | @samp{a} and/or @samp{b} could be polar complex numbers, in which | |
15487 | case doing the sum requires trigonometry. Or, @samp{a} could be | |
15488 | the factorial @samp{fact(100)} which is unevaluated because you | |
15489 | have typed @kbd{m O}; @code{eval} will evaluate it anyway to | |
15490 | produce a large, unwieldy integer. | |
15491 | ||
15492 | You can save your display formats permanently using the @kbd{Z P} | |
15493 | command (@pxref{Creating User Keys}). | |
15494 | ||
15495 | @node Syntax Tables, , Compositions, Language Modes | |
15496 | @subsection Syntax Tables | |
15497 | ||
15498 | @noindent | |
15499 | @cindex Syntax tables | |
15500 | @cindex Parsing formulas, customized | |
15501 | Syntax tables do for input what compositions do for output: They | |
15502 | allow you to teach custom notations to Calc's formula parser. | |
15503 | Calc keeps a separate syntax table for each language mode. | |
15504 | ||
15505 | (Note that the Calc ``syntax tables'' discussed here are completely | |
15506 | unrelated to the syntax tables described in the Emacs manual.) | |
15507 | ||
15508 | @kindex Z S | |
15509 | @pindex calc-edit-user-syntax | |
15510 | The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the | |
15511 | syntax table for the current language mode. If you want your | |
07ce2eb3 | 15512 | syntax to work in any language, define it in the Normal language |
33108698 JB |
15513 | mode. Type @kbd{C-c C-c} to finish editing the syntax table, or |
15514 | @kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all | |
d7b8e6c6 EZ |
15515 | the syntax tables along with the other mode settings; |
15516 | @pxref{General Mode Commands}. | |
15517 | ||
15518 | @menu | |
15519 | * Syntax Table Basics:: | |
15520 | * Precedence in Syntax Tables:: | |
15521 | * Advanced Syntax Patterns:: | |
15522 | * Conditional Syntax Rules:: | |
15523 | @end menu | |
15524 | ||
15525 | @node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables | |
15526 | @subsubsection Syntax Table Basics | |
15527 | ||
15528 | @noindent | |
15529 | @dfn{Parsing} is the process of converting a raw string of characters, | |
15530 | such as you would type in during algebraic entry, into a Calc formula. | |
15531 | Calc's parser works in two stages. First, the input is broken down | |
15532 | into @dfn{tokens}, such as words, numbers, and punctuation symbols | |
15533 | like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is | |
15534 | ignored (except when it serves to separate adjacent words). Next, | |
15535 | the parser matches this string of tokens against various built-in | |
15536 | syntactic patterns, such as ``an expression followed by @samp{+} | |
15537 | followed by another expression'' or ``a name followed by @samp{(}, | |
15538 | zero or more expressions separated by commas, and @samp{)}.'' | |
15539 | ||
15540 | A @dfn{syntax table} is a list of user-defined @dfn{syntax rules}, | |
15541 | which allow you to specify new patterns to define your own | |
15542 | favorite input notations. Calc's parser always checks the syntax | |
07ce2eb3 | 15543 | table for the current language mode, then the table for the Normal |
d7b8e6c6 EZ |
15544 | language mode, before it uses its built-in rules to parse an |
15545 | algebraic formula you have entered. Each syntax rule should go on | |
15546 | its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol, | |
15547 | and a Calc formula with an optional @dfn{condition}. (Syntax rules | |
15548 | resemble algebraic rewrite rules, but the notation for patterns is | |
15549 | completely different.) | |
15550 | ||
15551 | A syntax pattern is a list of tokens, separated by spaces. | |
15552 | Except for a few special symbols, tokens in syntax patterns are | |
15553 | matched literally, from left to right. For example, the rule, | |
15554 | ||
15555 | @example | |
15556 | foo ( ) := 2+3 | |
15557 | @end example | |
15558 | ||
15559 | @noindent | |
15560 | would cause Calc to parse the formula @samp{4+foo()*5} as if it | |
15561 | were @samp{4+(2+3)*5}. Notice that the parentheses were written | |
15562 | as two separate tokens in the rule. As a result, the rule works | |
15563 | for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written | |
15564 | the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()} | |
15565 | as a single, indivisible token, so that @w{@samp{foo( )}} would | |
15566 | not be recognized by the rule. (It would be parsed as a regular | |
15567 | zero-argument function call instead.) In fact, this rule would | |
15568 | also make trouble for the rest of Calc's parser: An unrelated | |
15569 | formula like @samp{bar()} would now be tokenized into @samp{bar ()} | |
15570 | instead of @samp{bar ( )}, so that the standard parser for function | |
15571 | calls would no longer recognize it! | |
15572 | ||
15573 | While it is possible to make a token with a mixture of letters | |
15574 | and punctuation symbols, this is not recommended. It is better to | |
15575 | break it into several tokens, as we did with @samp{foo()} above. | |
15576 | ||
15577 | The symbol @samp{#} in a syntax pattern matches any Calc expression. | |
15578 | On the righthand side, the things that matched the @samp{#}s can | |
15579 | be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1} | |
15580 | matches the leftmost @samp{#} in the pattern). For example, these | |
15581 | rules match a user-defined function, prefix operator, infix operator, | |
15582 | and postfix operator, respectively: | |
15583 | ||
15584 | @example | |
15585 | foo ( # ) := myfunc(#1) | |
15586 | foo # := myprefix(#1) | |
15587 | # foo # := myinfix(#1,#2) | |
15588 | # foo := mypostfix(#1) | |
15589 | @end example | |
15590 | ||
15591 | Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo} | |
15592 | will parse as @samp{mypostfix(2+3)}. | |
15593 | ||
15594 | It is important to write the first two rules in the order shown, | |
15595 | because Calc tries rules in order from first to last. If the | |
15596 | pattern @samp{foo #} came first, it would match anything that could | |
15597 | match the @samp{foo ( # )} rule, since an expression in parentheses | |
15598 | is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would | |
15599 | never get to match anything. Likewise, the last two rules must be | |
15600 | written in the order shown or else @samp{3 foo 4} will be parsed as | |
15601 | @samp{mypostfix(3) * 4}. (Of course, the best way to avoid these | |
15602 | ambiguities is not to use the same symbol in more than one way at | |
15603 | the same time! In case you're not convinced, try the following | |
15604 | exercise: How will the above rules parse the input @samp{foo(3,4)}, | |
15605 | if at all? Work it out for yourself, then try it in Calc and see.) | |
15606 | ||
15607 | Calc is quite flexible about what sorts of patterns are allowed. | |
15608 | The only rule is that every pattern must begin with a literal | |
15609 | token (like @samp{foo} in the first two patterns above), or with | |
15610 | a @samp{#} followed by a literal token (as in the last two | |
15611 | patterns). After that, any mixture is allowed, although putting | |
15612 | two @samp{#}s in a row will not be very useful since two | |
15613 | expressions with nothing between them will be parsed as one | |
15614 | expression that uses implicit multiplication. | |
15615 | ||
15616 | As a more practical example, Maple uses the notation | |
15617 | @samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't | |
15618 | recognize at present. To handle this syntax, we simply add the | |
15619 | rule, | |
15620 | ||
15621 | @example | |
15622 | sum ( # , # = # .. # ) := sum(#1,#2,#3,#4) | |
15623 | @end example | |
15624 | ||
15625 | @noindent | |
15626 | to the Maple mode syntax table. As another example, C mode can't | |
15627 | read assignment operators like @samp{++} and @samp{*=}. We can | |
15628 | define these operators quite easily: | |
15629 | ||
15630 | @example | |
15631 | # *= # := muleq(#1,#2) | |
15632 | # ++ := postinc(#1) | |
15633 | ++ # := preinc(#1) | |
15634 | @end example | |
15635 | ||
15636 | @noindent | |
15637 | To complete the job, we would use corresponding composition functions | |
15638 | and @kbd{Z C} to cause these functions to display in their respective | |
15639 | Maple and C notations. (Note that the C example ignores issues of | |
15640 | operator precedence, which are discussed in the next section.) | |
15641 | ||
15642 | You can enclose any token in quotes to prevent its usual | |
15643 | interpretation in syntax patterns: | |
15644 | ||
15645 | @example | |
15646 | # ":=" # := becomes(#1,#2) | |
15647 | @end example | |
15648 | ||
15649 | Quotes also allow you to include spaces in a token, although once | |
15650 | again it is generally better to use two tokens than one token with | |
15651 | an embedded space. To include an actual quotation mark in a quoted | |
15652 | token, precede it with a backslash. (This also works to include | |
15653 | backslashes in tokens.) | |
15654 | ||
15655 | @example | |
15656 | # "bad token" # "/\"\\" # := silly(#1,#2,#3) | |
15657 | @end example | |
15658 | ||
15659 | @noindent | |
15660 | This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}. | |
15661 | ||
15662 | The token @kbd{#} has a predefined meaning in Calc's formula parser; | |
2cbd16b9 | 15663 | it is not valid to use @samp{"#"} in a syntax rule. However, longer |
d7b8e6c6 EZ |
15664 | tokens that include the @samp{#} character are allowed. Also, while |
15665 | @samp{"$"} and @samp{"\""} are allowed as tokens, their presence in | |
15666 | the syntax table will prevent those characters from working in their | |
15667 | usual ways (referring to stack entries and quoting strings, | |
15668 | respectively). | |
15669 | ||
15670 | Finally, the notation @samp{%%} anywhere in a syntax table causes | |
15671 | the rest of the line to be ignored as a comment. | |
15672 | ||
15673 | @node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables | |
15674 | @subsubsection Precedence | |
15675 | ||
15676 | @noindent | |
15677 | Different operators are generally assigned different @dfn{precedences}. | |
15678 | By default, an operator defined by a rule like | |
15679 | ||
15680 | @example | |
15681 | # foo # := foo(#1,#2) | |
15682 | @end example | |
15683 | ||
15684 | @noindent | |
15685 | will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6} | |
15686 | will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the | |
15687 | precedence of an operator, use the notation @samp{#/@var{p}} in | |
15688 | place of @samp{#}, where @var{p} is an integer precedence level. | |
15689 | For example, 185 lies between the precedences for @samp{+} and | |
15690 | @samp{*}, so if we change this rule to | |
15691 | ||
15692 | @example | |
15693 | #/185 foo #/186 := foo(#1,#2) | |
15694 | @end example | |
15695 | ||
15696 | @noindent | |
15697 | then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}. | |
15698 | Also, because we've given the righthand expression slightly higher | |
15699 | precedence, our new operator will be left-associative: | |
15700 | @samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}. | |
15701 | By raising the precedence of the lefthand expression instead, we | |
15702 | can create a right-associative operator. | |
15703 | ||
15704 | @xref{Composition Basics}, for a table of precedences of the | |
15705 | standard Calc operators. For the precedences of operators in other | |
15706 | language modes, look in the Calc source file @file{calc-lang.el}. | |
15707 | ||
15708 | @node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables | |
15709 | @subsubsection Advanced Syntax Patterns | |
15710 | ||
15711 | @noindent | |
15712 | To match a function with a variable number of arguments, you could | |
15713 | write | |
15714 | ||
15715 | @example | |
15716 | foo ( # ) := myfunc(#1) | |
15717 | foo ( # , # ) := myfunc(#1,#2) | |
15718 | foo ( # , # , # ) := myfunc(#1,#2,#3) | |
15719 | @end example | |
15720 | ||
15721 | @noindent | |
15722 | but this isn't very elegant. To match variable numbers of items, | |
15723 | Calc uses some notations inspired regular expressions and the | |
15724 | ``extended BNF'' style used by some language designers. | |
15725 | ||
15726 | @example | |
15727 | foo ( @{ # @}*, ) := apply(myfunc,#1) | |
15728 | @end example | |
15729 | ||
15730 | The token @samp{@{} introduces a repeated or optional portion. | |
15731 | One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?} | |
15732 | ends the portion. These will match zero or more, one or more, | |
15733 | or zero or one copies of the enclosed pattern, respectively. | |
15734 | In addition, @samp{@}*} and @samp{@}+} can be followed by a | |
15735 | separator token (with no space in between, as shown above). | |
15736 | Thus @samp{@{ # @}*,} matches nothing, or one expression, or | |
15737 | several expressions separated by commas. | |
15738 | ||
15739 | A complete @samp{@{ ... @}} item matches as a vector of the | |
15740 | items that matched inside it. For example, the above rule will | |
15741 | match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}. | |
15742 | The Calc @code{apply} function takes a function name and a vector | |
15743 | of arguments and builds a call to the function with those | |
15744 | arguments, so the net result is the formula @samp{myfunc(1,2,3)}. | |
15745 | ||
15746 | If the body of a @samp{@{ ... @}} contains several @samp{#}s | |
15747 | (or nested @samp{@{ ... @}} constructs), then the items will be | |
15748 | strung together into the resulting vector. If the body | |
15749 | does not contain anything but literal tokens, the result will | |
15750 | always be an empty vector. | |
15751 | ||
15752 | @example | |
15753 | foo ( @{ # , # @}+, ) := bar(#1) | |
15754 | foo ( @{ @{ # @}*, @}*; ) := matrix(#1) | |
15755 | @end example | |
15756 | ||
15757 | @noindent | |
5d67986c RS |
15758 | will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and |
15759 | @samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after | |
d7b8e6c6 | 15760 | some thought it's easy to see how this pair of rules will parse |
5d67986c | 15761 | @samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first |
d7b8e6c6 EZ |
15762 | rule will only match an even number of arguments. The rule |
15763 | ||
15764 | @example | |
15765 | foo ( # @{ , # , # @}? ) := bar(#1,#2) | |
15766 | @end example | |
15767 | ||
15768 | @noindent | |
15769 | will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and | |
15770 | @samp{foo(2)} as @samp{bar(2,[])}. | |
15771 | ||
15772 | The notation @samp{@{ ... @}?.} (note the trailing period) works | |
15773 | just the same as regular @samp{@{ ... @}?}, except that it does not | |
15774 | count as an argument; the following two rules are equivalent: | |
15775 | ||
15776 | @example | |
15777 | foo ( # , @{ also @}? # ) := bar(#1,#3) | |
15778 | foo ( # , @{ also @}?. # ) := bar(#1,#2) | |
15779 | @end example | |
15780 | ||
15781 | @noindent | |
15782 | Note that in the first case the optional text counts as @samp{#2}, | |
15783 | which will always be an empty vector, but in the second case no | |
15784 | empty vector is produced. | |
15785 | ||
15786 | Another variant is @samp{@{ ... @}?$}, which means the body is | |
15787 | optional only at the end of the input formula. All built-in syntax | |
15788 | rules in Calc use this for closing delimiters, so that during | |
5d67986c | 15789 | algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting |
d7b8e6c6 EZ |
15790 | the closing parenthesis and bracket. Calc does this automatically |
15791 | for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax | |
15792 | rules, but you can use @samp{@{ ... @}?$} explicitly to get | |
15793 | this effect with any token (such as @samp{"@}"} or @samp{end}). | |
15794 | Like @samp{@{ ... @}?.}, this notation does not count as an | |
15795 | argument. Conversely, you can use quotes, as in @samp{")"}, to | |
15796 | prevent a closing-delimiter token from being automatically treated | |
15797 | as optional. | |
15798 | ||
15799 | Calc's parser does not have full backtracking, which means some | |
15800 | patterns will not work as you might expect: | |
15801 | ||
15802 | @example | |
15803 | foo ( @{ # , @}? # , # ) := bar(#1,#2,#3) | |
15804 | @end example | |
15805 | ||
15806 | @noindent | |
15807 | Here we are trying to make the first argument optional, so that | |
15808 | @samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc | |
15809 | first tries to match @samp{2,} against the optional part of the | |
15810 | pattern, finds a match, and so goes ahead to match the rest of the | |
15811 | pattern. Later on it will fail to match the second comma, but it | |
15812 | doesn't know how to go back and try the other alternative at that | |
15813 | point. One way to get around this would be to use two rules: | |
15814 | ||
15815 | @example | |
15816 | foo ( # , # , # ) := bar([#1],#2,#3) | |
15817 | foo ( # , # ) := bar([],#1,#2) | |
15818 | @end example | |
15819 | ||
15820 | More precisely, when Calc wants to match an optional or repeated | |
15821 | part of a pattern, it scans forward attempting to match that part. | |
15822 | If it reaches the end of the optional part without failing, it | |
15823 | ``finalizes'' its choice and proceeds. If it fails, though, it | |
15824 | backs up and tries the other alternative. Thus Calc has ``partial'' | |
15825 | backtracking. A fully backtracking parser would go on to make sure | |
15826 | the rest of the pattern matched before finalizing the choice. | |
15827 | ||
15828 | @node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables | |
15829 | @subsubsection Conditional Syntax Rules | |
15830 | ||
15831 | @noindent | |
15832 | It is possible to attach a @dfn{condition} to a syntax rule. For | |
15833 | example, the rules | |
15834 | ||
15835 | @example | |
15836 | foo ( # ) := ifoo(#1) :: integer(#1) | |
15837 | foo ( # ) := gfoo(#1) | |
15838 | @end example | |
15839 | ||
15840 | @noindent | |
15841 | will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse | |
15842 | @samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any | |
15843 | number of conditions may be attached; all must be true for the | |
15844 | rule to succeed. A condition is ``true'' if it evaluates to a | |
15845 | nonzero number. @xref{Logical Operations}, for a list of Calc | |
15846 | functions like @code{integer} that perform logical tests. | |
15847 | ||
15848 | The exact sequence of events is as follows: When Calc tries a | |
15849 | rule, it first matches the pattern as usual. It then substitutes | |
15850 | @samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the | |
15851 | conditions are simplified and evaluated in order from left to right, | |
15852 | as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}). | |
15853 | Each result is true if it is a nonzero number, or an expression | |
15854 | that can be proven to be nonzero (@pxref{Declarations}). If the | |
15855 | results of all conditions are true, the expression (such as | |
15856 | @samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the | |
15857 | result of the parse. If the result of any condition is false, Calc | |
15858 | goes on to try the next rule in the syntax table. | |
15859 | ||
15860 | Syntax rules also support @code{let} conditions, which operate in | |
15861 | exactly the same way as they do in algebraic rewrite rules. | |
15862 | @xref{Other Features of Rewrite Rules}, for details. A @code{let} | |
15863 | condition is always true, but as a side effect it defines a | |
15864 | variable which can be used in later conditions, and also in the | |
15865 | expression after the @samp{:=} sign: | |
15866 | ||
15867 | @example | |
15868 | foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x) | |
15869 | @end example | |
15870 | ||
15871 | @noindent | |
15872 | The @code{dnumint} function tests if a value is numerically an | |
15873 | integer, i.e., either a true integer or an integer-valued float. | |
15874 | This rule will parse @code{foo} with a half-integer argument, | |
15875 | like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}. | |
15876 | ||
15877 | The lefthand side of a syntax rule @code{let} must be a simple | |
15878 | variable, not the arbitrary pattern that is allowed in rewrite | |
15879 | rules. | |
15880 | ||
15881 | The @code{matches} function is also treated specially in syntax | |
15882 | rule conditions (again, in the same way as in rewrite rules). | |
15883 | @xref{Matching Commands}. If the matching pattern contains | |
15884 | meta-variables, then those meta-variables may be used in later | |
15885 | conditions and in the result expression. The arguments to | |
15886 | @code{matches} are not evaluated in this situation. | |
15887 | ||
15888 | @example | |
15889 | sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c]) | |
15890 | @end example | |
15891 | ||
15892 | @noindent | |
15893 | This is another way to implement the Maple mode @code{sum} notation. | |
15894 | In this approach, we allow @samp{#2} to equal the whole expression | |
15895 | @samp{i=1..10}. Then, we use @code{matches} to break it apart into | |
15896 | its components. If the expression turns out not to match the pattern, | |
15897 | the syntax rule will fail. Note that @kbd{Z S} always uses Calc's | |
07ce2eb3 | 15898 | Normal language mode for editing expressions in syntax rules, so we |
d7b8e6c6 EZ |
15899 | must use regular Calc notation for the interval @samp{[b..c]} that |
15900 | will correspond to the Maple mode interval @samp{1..10}. | |
15901 | ||
15902 | @node Modes Variable, Calc Mode Line, Language Modes, Mode Settings | |
15903 | @section The @code{Modes} Variable | |
15904 | ||
15905 | @noindent | |
15906 | @kindex m g | |
15907 | @pindex calc-get-modes | |
15908 | The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack | |
15909 | a vector of numbers that describes the various mode settings that | |
15910 | are in effect. With a numeric prefix argument, it pushes only the | |
15911 | @var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard | |
15912 | macros can use the @kbd{m g} command to modify their behavior based | |
15913 | on the current mode settings. | |
15914 | ||
15915 | @cindex @code{Modes} variable | |
15916 | @vindex Modes | |
15917 | The modes vector is also available in the special variable | |
5d67986c | 15918 | @code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}. |
d7b8e6c6 EZ |
15919 | It will not work to store into this variable; in fact, if you do, |
15920 | @code{Modes} will cease to track the current modes. (The @kbd{m g} | |
15921 | command will continue to work, however.) | |
15922 | ||
15923 | In general, each number in this vector is suitable as a numeric | |
15924 | prefix argument to the associated mode-setting command. (Recall | |
15925 | that the @kbd{~} key takes a number from the stack and gives it as | |
15926 | a numeric prefix to the next command.) | |
15927 | ||
15928 | The elements of the modes vector are as follows: | |
15929 | ||
15930 | @enumerate | |
15931 | @item | |
15932 | Current precision. Default is 12; associated command is @kbd{p}. | |
15933 | ||
15934 | @item | |
15935 | Binary word size. Default is 32; associated command is @kbd{b w}. | |
15936 | ||
15937 | @item | |
15938 | Stack size (not counting the value about to be pushed by @kbd{m g}). | |
15939 | This is zero if @kbd{m g} is executed with an empty stack. | |
15940 | ||
15941 | @item | |
15942 | Number radix. Default is 10; command is @kbd{d r}. | |
15943 | ||
15944 | @item | |
15945 | Floating-point format. This is the number of digits, plus the | |
15946 | constant 0 for normal notation, 10000 for scientific notation, | |
15947 | 20000 for engineering notation, or 30000 for fixed-point notation. | |
15948 | These codes are acceptable as prefix arguments to the @kbd{d n} | |
15949 | command, but note that this may lose information: For example, | |
15950 | @kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite | |
15951 | identical) effects if the current precision is 12, but they both | |
15952 | produce a code of 10012, which will be treated by @kbd{d n} as | |
15953 | @kbd{C-u 12 d s}. If the precision then changes, the float format | |
15954 | will still be frozen at 12 significant figures. | |
15955 | ||
15956 | @item | |
15957 | Angular mode. Default is 1 (degrees). Other values are 2 (radians) | |
15958 | and 3 (HMS). The @kbd{m d} command accepts these prefixes. | |
15959 | ||
15960 | @item | |
15961 | Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}. | |
15962 | ||
177c0ea7 | 15963 | @item |
d7b8e6c6 EZ |
15964 | Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}. |
15965 | ||
15966 | @item | |
15967 | Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0. | |
15968 | Command is @kbd{m p}. | |
15969 | ||
15970 | @item | |
07ce2eb3 | 15971 | Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar |
fe7d6d98 JB |
15972 | mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode, |
15973 | or @var{N} for | |
8e04863e | 15974 | @texline @math{N\times N} |
a4231b04 | 15975 | @infoline @var{N}x@var{N} |
07ce2eb3 | 15976 | Matrix mode. Command is @kbd{m v}. |
d7b8e6c6 EZ |
15977 | |
15978 | @item | |
8e04863e | 15979 | Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}), |
d7b8e6c6 EZ |
15980 | 0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E}, |
15981 | or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes. | |
15982 | ||
15983 | @item | |
8e04863e | 15984 | Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on, |
d7b8e6c6 EZ |
15985 | or 0 if the mode is on with positive zeros. Command is @kbd{m i}. |
15986 | @end enumerate | |
15987 | ||
5d67986c | 15988 | For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the |
d7b8e6c6 EZ |
15989 | precision by two, leaving a copy of the old precision on the stack. |
15990 | Later, @kbd{~ p} will restore the original precision using that | |
15991 | stack value. (This sequence might be especially useful inside a | |
15992 | keyboard macro.) | |
15993 | ||
5d67986c | 15994 | As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the |
d7b8e6c6 EZ |
15995 | oldest (bottommost) stack entry. |
15996 | ||
15997 | Yet another example: The HP-48 ``round'' command rounds a number | |
15998 | to the current displayed precision. You could roughly emulate this | |
15999 | in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This | |
16000 | would not work for fixed-point mode, but it wouldn't be hard to | |
16001 | do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]} | |
16002 | programming commands. @xref{Conditionals in Macros}.) | |
16003 | ||
16004 | @node Calc Mode Line, , Modes Variable, Mode Settings | |
16005 | @section The Calc Mode Line | |
16006 | ||
16007 | @noindent | |
16008 | @cindex Mode line indicators | |
16009 | This section is a summary of all symbols that can appear on the | |
16010 | Calc mode line, the highlighted bar that appears under the Calc | |
07ce2eb3 | 16011 | stack window (or under an editing window in Embedded mode). |
d7b8e6c6 EZ |
16012 | |
16013 | The basic mode line format is: | |
16014 | ||
16015 | @example | |
16016 | --%%-Calc: 12 Deg @var{other modes} (Calculator) | |
16017 | @end example | |
16018 | ||
16019 | The @samp{%%} is the Emacs symbol for ``read-only''; it shows that | |
16020 | regular Emacs commands are not allowed to edit the stack buffer | |
16021 | as if it were text. | |
16022 | ||
07ce2eb3 | 16023 | The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode |
d7b8e6c6 EZ |
16024 | is enabled. The words after this describe the various Calc modes |
16025 | that are in effect. | |
16026 | ||
16027 | The first mode is always the current precision, an integer. | |
16028 | The second mode is always the angular mode, either @code{Deg}, | |
16029 | @code{Rad}, or @code{Hms}. | |
16030 | ||
16031 | Here is a complete list of the remaining symbols that can appear | |
16032 | on the mode line: | |
16033 | ||
16034 | @table @code | |
16035 | @item Alg | |
16036 | Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}). | |
16037 | ||
16038 | @item Alg[( | |
16039 | Incomplete algebraic mode (@kbd{C-u m a}). | |
16040 | ||
16041 | @item Alg* | |
16042 | Total algebraic mode (@kbd{m t}). | |
16043 | ||
16044 | @item Symb | |
16045 | Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}). | |
16046 | ||
16047 | @item Matrix | |
16048 | Matrix mode (@kbd{m v}; @pxref{Matrix Mode}). | |
16049 | ||
16050 | @item Matrix@var{n} | |
fe7d6d98 JB |
16051 | Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}). |
16052 | ||
16053 | @item SqMatrix | |
16054 | Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}). | |
d7b8e6c6 EZ |
16055 | |
16056 | @item Scalar | |
16057 | Scalar mode (@kbd{m v}; @pxref{Matrix Mode}). | |
16058 | ||
16059 | @item Polar | |
16060 | Polar complex mode (@kbd{m p}; @pxref{Polar Mode}). | |
16061 | ||
16062 | @item Frac | |
16063 | Fraction mode (@kbd{m f}; @pxref{Fraction Mode}). | |
16064 | ||
16065 | @item Inf | |
16066 | Infinite mode (@kbd{m i}; @pxref{Infinite Mode}). | |
16067 | ||
16068 | @item +Inf | |
07ce2eb3 | 16069 | Positive Infinite mode (@kbd{C-u 0 m i}). |
d7b8e6c6 EZ |
16070 | |
16071 | @item NoSimp | |
16072 | Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}). | |
16073 | ||
16074 | @item NumSimp | |
16075 | Default simplifications for numeric arguments only (@kbd{m N}). | |
16076 | ||
16077 | @item BinSimp@var{w} | |
16078 | Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}). | |
16079 | ||
16080 | @item AlgSimp | |
16081 | Algebraic simplification mode (@kbd{m A}). | |
16082 | ||
16083 | @item ExtSimp | |
16084 | Extended algebraic simplification mode (@kbd{m E}). | |
16085 | ||
16086 | @item UnitSimp | |
16087 | Units simplification mode (@kbd{m U}). | |
16088 | ||
16089 | @item Bin | |
16090 | Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}). | |
16091 | ||
16092 | @item Oct | |
16093 | Current radix is 8 (@kbd{d 8}). | |
16094 | ||
16095 | @item Hex | |
16096 | Current radix is 16 (@kbd{d 6}). | |
16097 | ||
16098 | @item Radix@var{n} | |
16099 | Current radix is @var{n} (@kbd{d r}). | |
16100 | ||
16101 | @item Zero | |
16102 | Leading zeros (@kbd{d z}; @pxref{Radix Modes}). | |
16103 | ||
16104 | @item Big | |
16105 | Big language mode (@kbd{d B}; @pxref{Normal Language Modes}). | |
16106 | ||
16107 | @item Flat | |
16108 | One-line normal language mode (@kbd{d O}). | |
16109 | ||
16110 | @item Unform | |
16111 | Unformatted language mode (@kbd{d U}). | |
16112 | ||
16113 | @item C | |
16114 | C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}). | |
16115 | ||
16116 | @item Pascal | |
16117 | Pascal language mode (@kbd{d P}). | |
16118 | ||
16119 | @item Fortran | |
16120 | FORTRAN language mode (@kbd{d F}). | |
16121 | ||
16122 | @item TeX | |
8ed713c6 JB |
16123 | @TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}). |
16124 | ||
16125 | @item LaTeX | |
053bc283 | 16126 | La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}). |
d7b8e6c6 EZ |
16127 | |
16128 | @item Eqn | |
16129 | @dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}). | |
16130 | ||
16131 | @item Math | |
16132 | Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}). | |
16133 | ||
16134 | @item Maple | |
16135 | Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}). | |
16136 | ||
16137 | @item Norm@var{n} | |
16138 | Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}). | |
16139 | ||
16140 | @item Fix@var{n} | |
16141 | Fixed point mode with @var{n} digits after the point (@kbd{d f}). | |
16142 | ||
16143 | @item Sci | |
16144 | Scientific notation mode (@kbd{d s}). | |
16145 | ||
16146 | @item Sci@var{n} | |
16147 | Scientific notation with @var{n} digits (@kbd{d s}). | |
16148 | ||
16149 | @item Eng | |
16150 | Engineering notation mode (@kbd{d e}). | |
16151 | ||
16152 | @item Eng@var{n} | |
16153 | Engineering notation with @var{n} digits (@kbd{d e}). | |
16154 | ||
16155 | @item Left@var{n} | |
16156 | Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}). | |
16157 | ||
16158 | @item Right | |
16159 | Right-justified display (@kbd{d >}). | |
16160 | ||
16161 | @item Right@var{n} | |
16162 | Right-justified display with width @var{n} (@kbd{d >}). | |
16163 | ||
16164 | @item Center | |
16165 | Centered display (@kbd{d =}). | |
16166 | ||
16167 | @item Center@var{n} | |
16168 | Centered display with center column @var{n} (@kbd{d =}). | |
16169 | ||
16170 | @item Wid@var{n} | |
16171 | Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}). | |
16172 | ||
16173 | @item Wide | |
16174 | No line breaking (@kbd{d b}). | |
16175 | ||
16176 | @item Break | |
16177 | Selections show deep structure (@kbd{j b}; @pxref{Making Selections}). | |
16178 | ||
16179 | @item Save | |
3b846359 | 16180 | Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}). |
d7b8e6c6 EZ |
16181 | |
16182 | @item Local | |
16183 | Record modes in Embedded buffer (@kbd{m R}). | |
16184 | ||
16185 | @item LocEdit | |
16186 | Record modes as editing-only in Embedded buffer (@kbd{m R}). | |
16187 | ||
16188 | @item LocPerm | |
16189 | Record modes as permanent-only in Embedded buffer (@kbd{m R}). | |
16190 | ||
16191 | @item Global | |
16192 | Record modes as global in Embedded buffer (@kbd{m R}). | |
16193 | ||
16194 | @item Manual | |
16195 | Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic | |
16196 | Recomputation}). | |
16197 | ||
16198 | @item Graph | |
16199 | GNUPLOT process is alive in background (@pxref{Graphics}). | |
16200 | ||
16201 | @item Sel | |
16202 | Top-of-stack has a selection (Embedded only; @pxref{Making Selections}). | |
16203 | ||
16204 | @item Dirty | |
16205 | The stack display may not be up-to-date (@pxref{Display Modes}). | |
16206 | ||
16207 | @item Inv | |
16208 | ``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}). | |
16209 | ||
16210 | @item Hyp | |
16211 | ``Hyperbolic'' prefix was pressed (@kbd{H}). | |
16212 | ||
16213 | @item Keep | |
16214 | ``Keep-arguments'' prefix was pressed (@kbd{K}). | |
16215 | ||
16216 | @item Narrow | |
16217 | Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}). | |
16218 | @end table | |
16219 | ||
16220 | In addition, the symbols @code{Active} and @code{~Active} can appear | |
16221 | as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}. | |
16222 | ||
16223 | @node Arithmetic, Scientific Functions, Mode Settings, Top | |
16224 | @chapter Arithmetic Functions | |
16225 | ||
16226 | @noindent | |
16227 | This chapter describes the Calc commands for doing simple calculations | |
16228 | on numbers, such as addition, absolute value, and square roots. These | |
16229 | commands work by removing the top one or two values from the stack, | |
16230 | performing the desired operation, and pushing the result back onto the | |
16231 | stack. If the operation cannot be performed, the result pushed is a | |
16232 | formula instead of a number, such as @samp{2/0} (because division by zero | |
ce7c7522 | 16233 | is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula). |
d7b8e6c6 EZ |
16234 | |
16235 | Most of the commands described here can be invoked by a single keystroke. | |
16236 | Some of the more obscure ones are two-letter sequences beginning with | |
16237 | the @kbd{f} (``functions'') prefix key. | |
16238 | ||
16239 | @xref{Prefix Arguments}, for a discussion of the effect of numeric | |
16240 | prefix arguments on commands in this chapter which do not otherwise | |
16241 | interpret a prefix argument. | |
16242 | ||
16243 | @menu | |
16244 | * Basic Arithmetic:: | |
16245 | * Integer Truncation:: | |
16246 | * Complex Number Functions:: | |
16247 | * Conversions:: | |
16248 | * Date Arithmetic:: | |
16249 | * Financial Functions:: | |
16250 | * Binary Functions:: | |
16251 | @end menu | |
16252 | ||
16253 | @node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic | |
16254 | @section Basic Arithmetic | |
16255 | ||
16256 | @noindent | |
16257 | @kindex + | |
16258 | @pindex calc-plus | |
5d67986c RS |
16259 | @ignore |
16260 | @mindex @null | |
16261 | @end ignore | |
d7b8e6c6 EZ |
16262 | @tindex + |
16263 | The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may | |
16264 | be any of the standard Calc data types. The resulting sum is pushed back | |
16265 | onto the stack. | |
16266 | ||
16267 | If both arguments of @kbd{+} are vectors or matrices (of matching dimensions), | |
16268 | the result is a vector or matrix sum. If one argument is a vector and the | |
16269 | other a scalar (i.e., a non-vector), the scalar is added to each of the | |
16270 | elements of the vector to form a new vector. If the scalar is not a | |
16271 | number, the operation is left in symbolic form: Suppose you added @samp{x} | |
16272 | to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or | |
16273 | you may plan to substitute a 2-vector for @samp{x} in the future. Since | |
16274 | the Calculator can't tell which interpretation you want, it makes the | |
16275 | safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x} | |
16276 | to every element of a vector. | |
16277 | ||
16278 | If either argument of @kbd{+} is a complex number, the result will in general | |
16279 | be complex. If one argument is in rectangular form and the other polar, | |
07ce2eb3 JB |
16280 | the current Polar mode determines the form of the result. If Symbolic |
16281 | mode is enabled, the sum may be left as a formula if the necessary | |
d7b8e6c6 EZ |
16282 | conversions for polar addition are non-trivial. |
16283 | ||
16284 | If both arguments of @kbd{+} are HMS forms, the forms are added according to | |
16285 | the usual conventions of hours-minutes-seconds notation. If one argument | |
16286 | is an HMS form and the other is a number, that number is converted from | |
07ce2eb3 | 16287 | degrees or radians (depending on the current Angular mode) to HMS format |
d7b8e6c6 EZ |
16288 | and then the two HMS forms are added. |
16289 | ||
16290 | If one argument of @kbd{+} is a date form, the other can be either a | |
16291 | real number, which advances the date by a certain number of days, or | |
16292 | an HMS form, which advances the date by a certain amount of time. | |
16293 | Subtracting two date forms yields the number of days between them. | |
16294 | Adding two date forms is meaningless, but Calc interprets it as the | |
16295 | subtraction of one date form and the negative of the other. (The | |
16296 | negative of a date form can be understood by remembering that dates | |
16297 | are stored as the number of days before or after Jan 1, 1 AD.) | |
16298 | ||
16299 | If both arguments of @kbd{+} are error forms, the result is an error form | |
16300 | with an appropriately computed standard deviation. If one argument is an | |
16301 | error form and the other is a number, the number is taken to have zero error. | |
16302 | Error forms may have symbolic formulas as their mean and/or error parts; | |
16303 | adding these will produce a symbolic error form result. However, adding an | |
16304 | error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not | |
16305 | work, for the same reasons just mentioned for vectors. Instead you must | |
16306 | write @samp{(a +/- b) + (c +/- 0)}. | |
16307 | ||
a4231b04 | 16308 | If both arguments of @kbd{+} are modulo forms with equal values of @expr{M}, |
d7b8e6c6 | 16309 | or if one argument is a modulo form and the other a plain number, the |
a4231b04 | 16310 | result is a modulo form which represents the sum, modulo @expr{M}, of |
d7b8e6c6 EZ |
16311 | the two values. |
16312 | ||
16313 | If both arguments of @kbd{+} are intervals, the result is an interval | |
16314 | which describes all possible sums of the possible input values. If | |
16315 | one argument is a plain number, it is treated as the interval | |
16316 | @w{@samp{[x ..@: x]}}. | |
16317 | ||
16318 | If one argument of @kbd{+} is an infinity and the other is not, the | |
16319 | result is that same infinity. If both arguments are infinite and in | |
16320 | the same direction, the result is the same infinity, but if they are | |
16321 | infinite in different directions the result is @code{nan}. | |
16322 | ||
16323 | @kindex - | |
16324 | @pindex calc-minus | |
5d67986c RS |
16325 | @ignore |
16326 | @mindex @null | |
16327 | @end ignore | |
d7b8e6c6 EZ |
16328 | @tindex - |
16329 | The @kbd{-} (@code{calc-minus}) command subtracts two values. The top | |
16330 | number on the stack is subtracted from the one behind it, so that the | |
8e04863e | 16331 | computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options |
d7b8e6c6 EZ |
16332 | available for @kbd{+} are available for @kbd{-} as well. |
16333 | ||
16334 | @kindex * | |
16335 | @pindex calc-times | |
5d67986c RS |
16336 | @ignore |
16337 | @mindex @null | |
16338 | @end ignore | |
d7b8e6c6 EZ |
16339 | @tindex * |
16340 | The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one | |
16341 | argument is a vector and the other a scalar, the scalar is multiplied by | |
16342 | the elements of the vector to produce a new vector. If both arguments | |
16343 | are vectors, the interpretation depends on the dimensions of the | |
16344 | vectors: If both arguments are matrices, a matrix multiplication is | |
16345 | done. If one argument is a matrix and the other a plain vector, the | |
16346 | vector is interpreted as a row vector or column vector, whichever is | |
16347 | dimensionally correct. If both arguments are plain vectors, the result | |
16348 | is a single scalar number which is the dot product of the two vectors. | |
16349 | ||
16350 | If one argument of @kbd{*} is an HMS form and the other a number, the | |
16351 | HMS form is multiplied by that amount. It is an error to multiply two | |
16352 | HMS forms together, or to attempt any multiplication involving date | |
16353 | forms. Error forms, modulo forms, and intervals can be multiplied; | |
16354 | see the comments for addition of those forms. When two error forms | |
16355 | or intervals are multiplied they are considered to be statistically | |
16356 | independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]}, | |
16357 | whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}. | |
16358 | ||
16359 | @kindex / | |
16360 | @pindex calc-divide | |
5d67986c RS |
16361 | @ignore |
16362 | @mindex @null | |
16363 | @end ignore | |
d7b8e6c6 EZ |
16364 | @tindex / |
16365 | The @kbd{/} (@code{calc-divide}) command divides two numbers. When | |
a4231b04 JB |
16366 | dividing a scalar @expr{B} by a square matrix @expr{A}, the computation |
16367 | performed is @expr{B} times the inverse of @expr{A}. This also occurs | |
16368 | if @expr{B} is itself a vector or matrix, in which case the effect is | |
16369 | to solve the set of linear equations represented by @expr{B}. If @expr{B} | |
16370 | is a matrix with the same number of rows as @expr{A}, or a plain vector | |
d7b8e6c6 | 16371 | (which is interpreted here as a column vector), then the equation |
a4231b04 JB |
16372 | @expr{A X = B} is solved for the vector or matrix @expr{X}. Otherwise, |
16373 | if @expr{B} is a non-square matrix with the same number of @emph{columns} | |
16374 | as @expr{A}, the equation @expr{X A = B} is solved. If you wish a vector | |
16375 | @expr{B} to be interpreted as a row vector to be solved as @expr{X A = B}, | |
d7b8e6c6 | 16376 | make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a |
a4231b04 JB |
16377 | left-handed solution with a square matrix @expr{B}, transpose @expr{A} and |
16378 | @expr{B} before dividing, then transpose the result. | |
d7b8e6c6 EZ |
16379 | |
16380 | HMS forms can be divided by real numbers or by other HMS forms. Error | |
16381 | forms can be divided in any combination of ways. Modulo forms where both | |
16382 | values and the modulo are integers can be divided to get an integer modulo | |
16383 | form result. Intervals can be divided; dividing by an interval that | |
16384 | encompasses zero or has zero as a limit will result in an infinite | |
16385 | interval. | |
16386 | ||
16387 | @kindex ^ | |
16388 | @pindex calc-power | |
5d67986c RS |
16389 | @ignore |
16390 | @mindex @null | |
16391 | @end ignore | |
d7b8e6c6 EZ |
16392 | @tindex ^ |
16393 | The @kbd{^} (@code{calc-power}) command raises a number to a power. If | |
16394 | the power is an integer, an exact result is computed using repeated | |
16395 | multiplications. For non-integer powers, Calc uses Newton's method or | |
16396 | logarithms and exponentials. Square matrices can be raised to integer | |
16397 | powers. If either argument is an error (or interval or modulo) form, | |
16398 | the result is also an error (or interval or modulo) form. | |
16399 | ||
16400 | @kindex I ^ | |
16401 | @tindex nroot | |
16402 | If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command | |
5d67986c RS |
16403 | computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5. |
16404 | (This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.) | |
d7b8e6c6 EZ |
16405 | |
16406 | @kindex \ | |
16407 | @pindex calc-idiv | |
16408 | @tindex idiv | |
5d67986c RS |
16409 | @ignore |
16410 | @mindex @null | |
16411 | @end ignore | |
d7b8e6c6 EZ |
16412 | @tindex \ |
16413 | The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack | |
16414 | to produce an integer result. It is equivalent to dividing with | |
16415 | @key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit | |
16416 | more convenient and efficient. Also, since it is an all-integer | |
16417 | operation when the arguments are integers, it avoids problems that | |
16418 | @kbd{/ F} would have with floating-point roundoff. | |
16419 | ||
16420 | @kindex % | |
16421 | @pindex calc-mod | |
5d67986c RS |
16422 | @ignore |
16423 | @mindex @null | |
16424 | @end ignore | |
d7b8e6c6 EZ |
16425 | @tindex % |
16426 | The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'') | |
16427 | operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined | |
a4231b04 JB |
16428 | for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For |
16429 | positive @expr{b}, the result will always be between 0 (inclusive) and | |
16430 | @expr{b} (exclusive). Modulo does not work for HMS forms and error forms. | |
16431 | If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which | |
d7b8e6c6 EZ |
16432 | must be positive real number. |
16433 | ||
16434 | @kindex : | |
16435 | @pindex calc-fdiv | |
16436 | @tindex fdiv | |
029b2a44 | 16437 | The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command |
d7b8e6c6 | 16438 | divides the two integers on the top of the stack to produce a fractional |
07ce2eb3 | 16439 | result. This is a convenient shorthand for enabling Fraction mode (with |
d7b8e6c6 EZ |
16440 | @kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry |
16441 | the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6 | |
16442 | you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in | |
16443 | this case, it would be much easier simply to enter the fraction directly | |
16444 | as @kbd{8:6 @key{RET}}!) | |
16445 | ||
16446 | @kindex n | |
16447 | @pindex calc-change-sign | |
16448 | The @kbd{n} (@code{calc-change-sign}) command negates the number on the top | |
16449 | of the stack. It works on numbers, vectors and matrices, HMS forms, date | |
16450 | forms, error forms, intervals, and modulo forms. | |
16451 | ||
16452 | @kindex A | |
16453 | @pindex calc-abs | |
16454 | @tindex abs | |
16455 | The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute | |
16456 | value of a number. The result of @code{abs} is always a nonnegative | |
16457 | real number: With a complex argument, it computes the complex magnitude. | |
16458 | With a vector or matrix argument, it computes the Frobenius norm, i.e., | |
16459 | the square root of the sum of the squares of the absolute values of the | |
16460 | elements. The absolute value of an error form is defined by replacing | |
16461 | the mean part with its absolute value and leaving the error part the same. | |
16462 | The absolute value of a modulo form is undefined. The absolute value of | |
16463 | an interval is defined in the obvious way. | |
16464 | ||
16465 | @kindex f A | |
16466 | @pindex calc-abssqr | |
16467 | @tindex abssqr | |
16468 | The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the | |
16469 | absolute value squared of a number, vector or matrix, or error form. | |
16470 | ||
16471 | @kindex f s | |
16472 | @pindex calc-sign | |
16473 | @tindex sign | |
16474 | The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its | |
8e04863e | 16475 | argument is positive, @mathit{-1} if its argument is negative, or 0 if its |
d7b8e6c6 EZ |
16476 | argument is zero. In algebraic form, you can also write @samp{sign(a,x)} |
16477 | which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or | |
16478 | zero depending on the sign of @samp{a}. | |
16479 | ||
16480 | @kindex & | |
16481 | @pindex calc-inv | |
16482 | @tindex inv | |
16483 | @cindex Reciprocal | |
16484 | The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the | |
a4231b04 | 16485 | reciprocal of a number, i.e., @expr{1 / x}. Operating on a square |
d7b8e6c6 EZ |
16486 | matrix, it computes the inverse of that matrix. |
16487 | ||
16488 | @kindex Q | |
16489 | @pindex calc-sqrt | |
16490 | @tindex sqrt | |
16491 | The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square | |
16492 | root of a number. For a negative real argument, the result will be a | |
07ce2eb3 | 16493 | complex number whose form is determined by the current Polar mode. |
d7b8e6c6 EZ |
16494 | |
16495 | @kindex f h | |
16496 | @pindex calc-hypot | |
16497 | @tindex hypot | |
16498 | The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square | |
16499 | root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)} | |
a4231b04 JB |
16500 | is the length of the hypotenuse of a right triangle with sides @expr{a} |
16501 | and @expr{b}. If the arguments are complex numbers, their squared | |
d7b8e6c6 EZ |
16502 | magnitudes are used. |
16503 | ||
16504 | @kindex f Q | |
16505 | @pindex calc-isqrt | |
16506 | @tindex isqrt | |
16507 | The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the | |
16508 | integer square root of an integer. This is the true square root of the | |
16509 | number, rounded down to an integer. For example, @samp{isqrt(10)} | |
16510 | produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact | |
16511 | integer arithmetic throughout to avoid roundoff problems. If the input | |
16512 | is a floating-point number or other non-integer value, this is exactly | |
16513 | the same as @samp{floor(sqrt(x))}. | |
16514 | ||
16515 | @kindex f n | |
16516 | @kindex f x | |
16517 | @pindex calc-min | |
16518 | @tindex min | |
16519 | @pindex calc-max | |
16520 | @tindex max | |
16521 | The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max}) | |
16522 | [@code{max}] commands take the minimum or maximum of two real numbers, | |
16523 | respectively. These commands also work on HMS forms, date forms, | |
16524 | intervals, and infinities. (In algebraic expressions, these functions | |
16525 | take any number of arguments and return the maximum or minimum among | |
a4231b04 | 16526 | all the arguments.) |
d7b8e6c6 EZ |
16527 | |
16528 | @kindex f M | |
16529 | @kindex f X | |
16530 | @pindex calc-mant-part | |
16531 | @tindex mant | |
16532 | @pindex calc-xpon-part | |
16533 | @tindex xpon | |
16534 | The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts | |
a4231b04 | 16535 | the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X} |
d7b8e6c6 | 16536 | (@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part |
a4231b04 | 16537 | @expr{e}. The original number is equal to |
8e04863e | 16538 | @texline @math{m \times 10^e}, |
a4231b04 JB |
16539 | @infoline @expr{m * 10^e}, |
16540 | where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that | |
16541 | @expr{m=e=0} if the original number is zero. For integers | |
d7b8e6c6 EZ |
16542 | and fractions, @code{mant} returns the number unchanged and @code{xpon} |
16543 | returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be | |
16544 | used to ``unpack'' a floating-point number; this produces an integer | |
16545 | mantissa and exponent, with the constraint that the mantissa is not | |
a4231b04 | 16546 | a multiple of ten (again except for the @expr{m=e=0} case). |
d7b8e6c6 EZ |
16547 | |
16548 | @kindex f S | |
16549 | @pindex calc-scale-float | |
16550 | @tindex scf | |
16551 | The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number | |
16552 | by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any | |
16553 | real @samp{x}. The second argument must be an integer, but the first | |
16554 | may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05} | |
07ce2eb3 | 16555 | or @samp{1:20} depending on the current Fraction mode. |
d7b8e6c6 EZ |
16556 | |
16557 | @kindex f [ | |
16558 | @kindex f ] | |
16559 | @pindex calc-decrement | |
16560 | @pindex calc-increment | |
16561 | @tindex decr | |
16562 | @tindex incr | |
16563 | The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]} | |
16564 | (@code{calc-increment}) [@code{incr}] functions decrease or increase | |
16565 | a number by one unit. For integers, the effect is obvious. For | |
16566 | floating-point numbers, the change is by one unit in the last place. | |
16567 | For example, incrementing @samp{12.3456} when the current precision | |
16568 | is 6 digits yields @samp{12.3457}. If the current precision had been | |
16569 | 8 digits, the result would have been @samp{12.345601}. Incrementing | |
a4231b04 | 16570 | @samp{0.0} produces |
8e04863e | 16571 | @texline @math{10^{-p}}, |
a4231b04 JB |
16572 | @infoline @expr{10^-p}, |
16573 | where @expr{p} is the current | |
d7b8e6c6 | 16574 | precision. These operations are defined only on integers and floats. |
a4231b04 | 16575 | With numeric prefix arguments, they change the number by @expr{n} units. |
d7b8e6c6 EZ |
16576 | |
16577 | Note that incrementing followed by decrementing, or vice-versa, will | |
16578 | almost but not quite always cancel out. Suppose the precision is | |
16579 | 6 digits and the number @samp{9.99999} is on the stack. Incrementing | |
16580 | will produce @samp{10.0000}; decrementing will produce @samp{9.9999}. | |
16581 | One digit has been dropped. This is an unavoidable consequence of the | |
16582 | way floating-point numbers work. | |
16583 | ||
16584 | Incrementing a date/time form adjusts it by a certain number of seconds. | |
16585 | Incrementing a pure date form adjusts it by a certain number of days. | |
16586 | ||
16587 | @node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic | |
16588 | @section Integer Truncation | |
16589 | ||
16590 | @noindent | |
16591 | There are four commands for truncating a real number to an integer, | |
16592 | differing mainly in their treatment of negative numbers. All of these | |
16593 | commands have the property that if the argument is an integer, the result | |
16594 | is the same integer. An integer-valued floating-point argument is converted | |
16595 | to integer form. | |
16596 | ||
16597 | If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be | |
16598 | expressed as an integer-valued floating-point number. | |
16599 | ||
16600 | @cindex Integer part of a number | |
16601 | @kindex F | |
16602 | @pindex calc-floor | |
16603 | @tindex floor | |
16604 | @tindex ffloor | |
5d67986c RS |
16605 | @ignore |
16606 | @mindex @null | |
16607 | @end ignore | |
d7b8e6c6 EZ |
16608 | @kindex H F |
16609 | The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command | |
16610 | truncates a real number to the next lower integer, i.e., toward minus | |
16611 | infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces | |
8e04863e | 16612 | @mathit{-4}. |
d7b8e6c6 EZ |
16613 | |
16614 | @kindex I F | |
16615 | @pindex calc-ceiling | |
16616 | @tindex ceil | |
16617 | @tindex fceil | |
5d67986c RS |
16618 | @ignore |
16619 | @mindex @null | |
16620 | @end ignore | |
d7b8e6c6 EZ |
16621 | @kindex H I F |
16622 | The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}] | |
16623 | command truncates toward positive infinity. Thus @kbd{3.6 I F} produces | |
8e04863e | 16624 | 4, and @kbd{_3.6 I F} produces @mathit{-3}. |
d7b8e6c6 EZ |
16625 | |
16626 | @kindex R | |
16627 | @pindex calc-round | |
16628 | @tindex round | |
16629 | @tindex fround | |
5d67986c RS |
16630 | @ignore |
16631 | @mindex @null | |
16632 | @end ignore | |
d7b8e6c6 EZ |
16633 | @kindex H R |
16634 | The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command | |
16635 | rounds to the nearest integer. When the fractional part is .5 exactly, | |
16636 | this command rounds away from zero. (All other rounding in the | |
16637 | Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4 | |
8e04863e | 16638 | but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}. |
d7b8e6c6 EZ |
16639 | |
16640 | @kindex I R | |
16641 | @pindex calc-trunc | |
16642 | @tindex trunc | |
16643 | @tindex ftrunc | |
5d67986c RS |
16644 | @ignore |
16645 | @mindex @null | |
16646 | @end ignore | |
d7b8e6c6 EZ |
16647 | @kindex H I R |
16648 | The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}] | |
16649 | command truncates toward zero. In other words, it ``chops off'' | |
16650 | everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and | |
8e04863e | 16651 | @kbd{_3.6 I R} produces @mathit{-3}. |
d7b8e6c6 EZ |
16652 | |
16653 | These functions may not be applied meaningfully to error forms, but they | |
16654 | do work for intervals. As a convenience, applying @code{floor} to a | |
16655 | modulo form floors the value part of the form. Applied to a vector, | |
16656 | these functions operate on all elements of the vector one by one. | |
16657 | Applied to a date form, they operate on the internal numerical | |
16658 | representation of dates, converting a date/time form into a pure date. | |
16659 | ||
5d67986c RS |
16660 | @ignore |
16661 | @starindex | |
16662 | @end ignore | |
d7b8e6c6 | 16663 | @tindex rounde |
5d67986c RS |
16664 | @ignore |
16665 | @starindex | |
16666 | @end ignore | |
d7b8e6c6 | 16667 | @tindex roundu |
5d67986c RS |
16668 | @ignore |
16669 | @starindex | |
16670 | @end ignore | |
d7b8e6c6 | 16671 | @tindex frounde |
5d67986c RS |
16672 | @ignore |
16673 | @starindex | |
16674 | @end ignore | |
d7b8e6c6 EZ |
16675 | @tindex froundu |
16676 | There are two more rounding functions which can only be entered in | |
16677 | algebraic notation. The @code{roundu} function is like @code{round} | |
16678 | except that it rounds up, toward plus infinity, when the fractional | |
16679 | part is .5. This distinction matters only for negative arguments. | |
16680 | Also, @code{rounde} rounds to an even number in the case of a tie, | |
16681 | rounding up or down as necessary. For example, @samp{rounde(3.5)} and | |
16682 | @samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6. | |
16683 | The advantage of round-to-even is that the net error due to rounding | |
16684 | after a long calculation tends to cancel out to zero. An important | |
16685 | subtle point here is that the number being fed to @code{rounde} will | |
16686 | already have been rounded to the current precision before @code{rounde} | |
16687 | begins. For example, @samp{rounde(2.500001)} with a current precision | |
16688 | of 6 will incorrectly, or at least surprisingly, yield 2 because the | |
a4231b04 | 16689 | argument will first have been rounded down to @expr{2.5} (which |
d7b8e6c6 EZ |
16690 | @code{rounde} sees as an exact tie between 2 and 3). |
16691 | ||
16692 | Each of these functions, when written in algebraic formulas, allows | |
16693 | a second argument which specifies the number of digits after the | |
16694 | decimal point to keep. For example, @samp{round(123.4567, 2)} will | |
16695 | produce the answer 123.46, and @samp{round(123.4567, -1)} will | |
16696 | produce 120 (i.e., the cutoff is one digit to the @emph{left} of | |
16697 | the decimal point). A second argument of zero is equivalent to | |
16698 | no second argument at all. | |
16699 | ||
16700 | @cindex Fractional part of a number | |
16701 | To compute the fractional part of a number (i.e., the amount which, when | |
bd712b70 | 16702 | added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n} |
a4231b04 | 16703 | modulo 1 using the @code{%} command. |
d7b8e6c6 EZ |
16704 | |
16705 | Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm), | |
16706 | and @kbd{f Q} (integer square root) commands, which are analogous to | |
16707 | @kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer | |
16708 | arguments and return the result rounded down to an integer. | |
16709 | ||
16710 | @node Complex Number Functions, Conversions, Integer Truncation, Arithmetic | |
16711 | @section Complex Number Functions | |
16712 | ||
16713 | @noindent | |
16714 | @kindex J | |
16715 | @pindex calc-conj | |
16716 | @tindex conj | |
16717 | The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the | |
a4231b04 JB |
16718 | complex conjugate of a number. For complex number @expr{a+bi}, the |
16719 | complex conjugate is @expr{a-bi}. If the argument is a real number, | |
d7b8e6c6 EZ |
16720 | this command leaves it the same. If the argument is a vector or matrix, |
16721 | this command replaces each element by its complex conjugate. | |
16722 | ||
16723 | @kindex G | |
16724 | @pindex calc-argument | |
16725 | @tindex arg | |
16726 | The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the | |
16727 | ``argument'' or polar angle of a complex number. For a number in polar | |
16728 | notation, this is simply the second component of the pair | |
bd712b70 JB |
16729 | @texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'. |
16730 | @infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'. | |
d7b8e6c6 | 16731 | The result is expressed according to the current angular mode and will |
8e04863e | 16732 | be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees |
a4231b04 | 16733 | (inclusive), or the equivalent range in radians. |
d7b8e6c6 EZ |
16734 | |
16735 | @pindex calc-imaginary | |
16736 | The @code{calc-imaginary} command multiplies the number on the | |
a4231b04 | 16737 | top of the stack by the imaginary number @expr{i = (0,1)}. This |
d7b8e6c6 | 16738 | command is not normally bound to a key in Calc, but it is available |
07ce2eb3 | 16739 | on the @key{IMAG} button in Keypad mode. |
d7b8e6c6 EZ |
16740 | |
16741 | @kindex f r | |
16742 | @pindex calc-re | |
16743 | @tindex re | |
16744 | The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number | |
16745 | by its real part. This command has no effect on real numbers. (As an | |
16746 | added convenience, @code{re} applied to a modulo form extracts | |
a4231b04 | 16747 | the value part.) |
d7b8e6c6 EZ |
16748 | |
16749 | @kindex f i | |
16750 | @pindex calc-im | |
16751 | @tindex im | |
16752 | The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number | |
16753 | by its imaginary part; real numbers are converted to zero. With a vector | |
a4231b04 | 16754 | or matrix argument, these functions operate element-wise. |
d7b8e6c6 | 16755 | |
5d67986c RS |
16756 | @ignore |
16757 | @mindex v p | |
16758 | @end ignore | |
d7b8e6c6 EZ |
16759 | @kindex v p (complex) |
16760 | @pindex calc-pack | |
16761 | The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on | |
269b7745 | 16762 | the stack into a composite object such as a complex number. With |
8e04863e JB |
16763 | a prefix argument of @mathit{-1}, it produces a rectangular complex number; |
16764 | with an argument of @mathit{-2}, it produces a polar complex number. | |
d7b8e6c6 EZ |
16765 | (Also, @pxref{Building Vectors}.) |
16766 | ||
5d67986c RS |
16767 | @ignore |
16768 | @mindex v u | |
16769 | @end ignore | |
d7b8e6c6 EZ |
16770 | @kindex v u (complex) |
16771 | @pindex calc-unpack | |
16772 | The @kbd{v u} (@code{calc-unpack}) command takes the complex number | |
16773 | (or other composite object) on the top of the stack and unpacks it | |
16774 | into its separate components. | |
16775 | ||
16776 | @node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic | |
16777 | @section Conversions | |
16778 | ||
16779 | @noindent | |
16780 | The commands described in this section convert numbers from one form | |
16781 | to another; they are two-key sequences beginning with the letter @kbd{c}. | |
16782 | ||
16783 | @kindex c f | |
16784 | @pindex calc-float | |
16785 | @tindex pfloat | |
16786 | The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the | |
16787 | number on the top of the stack to floating-point form. For example, | |
a4231b04 JB |
16788 | @expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to |
16789 | @expr{1.5}, and @expr{2.3} is left the same. If the value is a composite | |
d7b8e6c6 EZ |
16790 | object such as a complex number or vector, each of the components is |
16791 | converted to floating-point. If the value is a formula, all numbers | |
16792 | in the formula are converted to floating-point. Note that depending | |
16793 | on the current floating-point precision, conversion to floating-point | |
a4231b04 | 16794 | format may lose information. |
d7b8e6c6 EZ |
16795 | |
16796 | As a special exception, integers which appear as powers or subscripts | |
16797 | are not floated by @kbd{c f}. If you really want to float a power, | |
16798 | you can use a @kbd{j s} command to select the power followed by @kbd{c f}. | |
16799 | Because @kbd{c f} cannot examine the formula outside of the selection, | |
16800 | it does not notice that the thing being floated is a power. | |
16801 | @xref{Selecting Subformulas}. | |
16802 | ||
16803 | The normal @kbd{c f} command is ``pervasive'' in the sense that it | |
16804 | applies to all numbers throughout the formula. The @code{pfloat} | |
16805 | algebraic function never stays around in a formula; @samp{pfloat(a + 1)} | |
16806 | changes to @samp{a + 1.0} as soon as it is evaluated. | |
16807 | ||
16808 | @kindex H c f | |
16809 | @tindex float | |
16810 | With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates | |
16811 | only on the number or vector of numbers at the top level of its | |
16812 | argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)} | |
16813 | is left unevaluated because its argument is not a number. | |
16814 | ||
16815 | You should use @kbd{H c f} if you wish to guarantee that the final | |
16816 | value, once all the variables have been assigned, is a float; you | |
16817 | would use @kbd{c f} if you wish to do the conversion on the numbers | |
16818 | that appear right now. | |
16819 | ||
16820 | @kindex c F | |
16821 | @pindex calc-fraction | |
16822 | @tindex pfrac | |
16823 | The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a | |
16824 | floating-point number into a fractional approximation. By default, it | |
16825 | produces a fraction whose decimal representation is the same as the | |
16826 | input number, to within the current precision. You can also give a | |
16827 | numeric prefix argument to specify a tolerance, either directly, or, | |
16828 | if the prefix argument is zero, by using the number on top of the stack | |
16829 | as the tolerance. If the tolerance is a positive integer, the fraction | |
16830 | is correct to within that many significant figures. If the tolerance is | |
16831 | a non-positive integer, it specifies how many digits fewer than the current | |
16832 | precision to use. If the tolerance is a floating-point number, the | |
16833 | fraction is correct to within that absolute amount. | |
16834 | ||
16835 | @kindex H c F | |
16836 | @tindex frac | |
16837 | The @code{pfrac} function is pervasive, like @code{pfloat}. | |
16838 | There is also a non-pervasive version, @kbd{H c F} [@code{frac}], | |
16839 | which is analogous to @kbd{H c f} discussed above. | |
16840 | ||
16841 | @kindex c d | |
16842 | @pindex calc-to-degrees | |
16843 | @tindex deg | |
16844 | The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a | |
16845 | number into degrees form. The value on the top of the stack may be an | |
16846 | HMS form (interpreted as degrees-minutes-seconds), or a real number which | |
a4231b04 | 16847 | will be interpreted in radians regardless of the current angular mode. |
d7b8e6c6 EZ |
16848 | |
16849 | @kindex c r | |
16850 | @pindex calc-to-radians | |
16851 | @tindex rad | |
16852 | The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an | |
16853 | HMS form or angle in degrees into an angle in radians. | |
16854 | ||
16855 | @kindex c h | |
16856 | @pindex calc-to-hms | |
16857 | @tindex hms | |
16858 | The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real | |
16859 | number, interpreted according to the current angular mode, to an HMS | |
16860 | form describing the same angle. In algebraic notation, the @code{hms} | |
16861 | function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}. | |
16862 | (The three-argument version is independent of the current angular mode.) | |
16863 | ||
16864 | @pindex calc-from-hms | |
16865 | The @code{calc-from-hms} command converts the HMS form on the top of the | |
16866 | stack into a real number according to the current angular mode. | |
16867 | ||
16868 | @kindex c p | |
16869 | @kindex I c p | |
16870 | @pindex calc-polar | |
16871 | @tindex polar | |
16872 | @tindex rect | |
16873 | The @kbd{c p} (@code{calc-polar}) command converts the complex number on | |
16874 | the top of the stack from polar to rectangular form, or from rectangular | |
16875 | to polar form, whichever is appropriate. Real numbers are left the same. | |
16876 | This command is equivalent to the @code{rect} or @code{polar} | |
16877 | functions in algebraic formulas, depending on the direction of | |
16878 | conversion. (It uses @code{polar}, except that if the argument is | |
16879 | already a polar complex number, it uses @code{rect} instead. The | |
a4231b04 | 16880 | @kbd{I c p} command always uses @code{rect}.) |
d7b8e6c6 EZ |
16881 | |
16882 | @kindex c c | |
16883 | @pindex calc-clean | |
16884 | @tindex pclean | |
16885 | The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the | |
16886 | number on the top of the stack. Floating point numbers are re-rounded | |
16887 | according to the current precision. Polar numbers whose angular | |
8e04863e | 16888 | components have strayed from the @mathit{-180} to @mathit{+180} degree range |
d7b8e6c6 EZ |
16889 | are normalized. (Note that results will be undesirable if the current |
16890 | angular mode is different from the one under which the number was | |
16891 | produced!) Integers and fractions are generally unaffected by this | |
16892 | operation. Vectors and formulas are cleaned by cleaning each component | |
a4231b04 | 16893 | number (i.e., pervasively). |
d7b8e6c6 EZ |
16894 | |
16895 | If the simplification mode is set below the default level, it is raised | |
16896 | to the default level for the purposes of this command. Thus, @kbd{c c} | |
16897 | applies the default simplifications even if their automatic application | |
16898 | is disabled. @xref{Simplification Modes}. | |
16899 | ||
16900 | @cindex Roundoff errors, correcting | |
16901 | A numeric prefix argument to @kbd{c c} sets the floating-point precision | |
16902 | to that value for the duration of the command. A positive prefix (of at | |
16903 | least 3) sets the precision to the specified value; a negative or zero | |
16904 | prefix decreases the precision by the specified amount. | |
16905 | ||
16906 | @kindex c 0-9 | |
16907 | @pindex calc-clean-num | |
16908 | The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent | |
16909 | to @kbd{c c} with the corresponding negative prefix argument. If roundoff | |
16910 | errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one | |
16911 | decimal place often conveniently does the trick. | |
16912 | ||
16913 | The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0} | |
16914 | through @kbd{c 9} commands, also ``clip'' very small floating-point | |
16915 | numbers to zero. If the exponent is less than or equal to the negative | |
16916 | of the specified precision, the number is changed to 0.0. For example, | |
16917 | if the current precision is 12, then @kbd{c 2} changes the vector | |
16918 | @samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}. | |
16919 | Numbers this small generally arise from roundoff noise. | |
16920 | ||
16921 | If the numbers you are using really are legitimately this small, | |
16922 | you should avoid using the @kbd{c 0} through @kbd{c 9} commands. | |
16923 | (The plain @kbd{c c} command rounds to the current precision but | |
16924 | does not clip small numbers.) | |
16925 | ||
16926 | One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with | |
16927 | a prefix argument, is that integer-valued floats are converted to | |
16928 | plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]} | |
16929 | produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge | |
16930 | numbers (@samp{1e100} is technically an integer-valued float, but | |
16931 | you wouldn't want it automatically converted to a 100-digit integer). | |
16932 | ||
16933 | @kindex H c 0-9 | |
16934 | @kindex H c c | |
16935 | @tindex clean | |
16936 | With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9} | |
16937 | operate non-pervasively [@code{clean}]. | |
16938 | ||
16939 | @node Date Arithmetic, Financial Functions, Conversions, Arithmetic | |
16940 | @section Date Arithmetic | |
16941 | ||
16942 | @noindent | |
16943 | @cindex Date arithmetic, additional functions | |
16944 | The commands described in this section perform various conversions | |
16945 | and calculations involving date forms (@pxref{Date Forms}). They | |
16946 | use the @kbd{t} (for time/date) prefix key followed by shifted | |
16947 | letters. | |
16948 | ||
16949 | The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-} | |
16950 | commands. In particular, adding a number to a date form advances the | |
16951 | date form by a certain number of days; adding an HMS form to a date | |
16952 | form advances the date by a certain amount of time; and subtracting two | |
16953 | date forms produces a difference measured in days. The commands | |
16954 | described here provide additional, more specialized operations on dates. | |
16955 | ||
16956 | Many of these commands accept a numeric prefix argument; if you give | |
16957 | plain @kbd{C-u} as the prefix, these commands will instead take the | |
16958 | additional argument from the top of the stack. | |
16959 | ||
16960 | @menu | |
16961 | * Date Conversions:: | |
16962 | * Date Functions:: | |
16963 | * Time Zones:: | |
16964 | * Business Days:: | |
16965 | @end menu | |
16966 | ||
16967 | @node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic | |
16968 | @subsection Date Conversions | |
16969 | ||
16970 | @noindent | |
16971 | @kindex t D | |
16972 | @pindex calc-date | |
16973 | @tindex date | |
16974 | The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a | |
16975 | date form into a number, measured in days since Jan 1, 1 AD. The | |
16976 | result will be an integer if @var{date} is a pure date form, or a | |
16977 | fraction or float if @var{date} is a date/time form. Or, if its | |
16978 | argument is a number, it converts this number into a date form. | |
16979 | ||
16980 | With a numeric prefix argument, @kbd{t D} takes that many objects | |
16981 | (up to six) from the top of the stack and interprets them in one | |
16982 | of the following ways: | |
16983 | ||
16984 | The @samp{date(@var{year}, @var{month}, @var{day})} function | |
16985 | builds a pure date form out of the specified year, month, and | |
16986 | day, which must all be integers. @var{Year} is a year number, | |
16987 | such as 1991 (@emph{not} the same as 91!). @var{Month} must be | |
16988 | an integer in the range 1 to 12; @var{day} must be in the range | |
16989 | 1 to 31. If the specified month has fewer than 31 days and | |
16990 | @var{day} is too large, the equivalent day in the following | |
16991 | month will be used. | |
16992 | ||
16993 | The @samp{date(@var{month}, @var{day})} function builds a | |
16994 | pure date form using the current year, as determined by the | |
16995 | real-time clock. | |
16996 | ||
16997 | The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})} | |
16998 | function builds a date/time form using an @var{hms} form. | |
16999 | ||
17000 | The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour}, | |
17001 | @var{minute}, @var{second})} function builds a date/time form. | |
17002 | @var{hour} should be an integer in the range 0 to 23; | |
17003 | @var{minute} should be an integer in the range 0 to 59; | |
17004 | @var{second} should be any real number in the range @samp{[0 .. 60)}. | |
17005 | The last two arguments default to zero if omitted. | |
17006 | ||
17007 | @kindex t J | |
17008 | @pindex calc-julian | |
17009 | @tindex julian | |
17010 | @cindex Julian day counts, conversions | |
17011 | The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts | |
17012 | a date form into a Julian day count, which is the number of days | |
17013 | since noon on Jan 1, 4713 BC. A pure date is converted to an integer | |
17014 | Julian count representing noon of that day. A date/time form is | |
17015 | converted to an exact floating-point Julian count, adjusted to | |
17016 | interpret the date form in the current time zone but the Julian | |
17017 | day count in Greenwich Mean Time. A numeric prefix argument allows | |
17018 | you to specify the time zone; @pxref{Time Zones}. Use a prefix of | |
17019 | zero to suppress the time zone adjustment. Note that pure date forms | |
17020 | are never time-zone adjusted. | |
17021 | ||
17022 | This command can also do the opposite conversion, from a Julian day | |
17023 | count (either an integer day, or a floating-point day and time in | |
17024 | the GMT zone), into a pure date form or a date/time form in the | |
17025 | current or specified time zone. | |
17026 | ||
17027 | @kindex t U | |
17028 | @pindex calc-unix-time | |
17029 | @tindex unixtime | |
17030 | @cindex Unix time format, conversions | |
17031 | The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command | |
17032 | converts a date form into a Unix time value, which is the number of | |
17033 | seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result | |
17034 | will be an integer if the current precision is 12 or less; for higher | |
5d67986c | 17035 | precisions, the result may be a float with (@var{precision}@minus{}12) |
d7b8e6c6 EZ |
17036 | digits after the decimal. Just as for @kbd{t J}, the numeric time |
17037 | is interpreted in the GMT time zone and the date form is interpreted | |
17038 | in the current or specified zone. Some systems use Unix-like | |
17039 | numbering but with the local time zone; give a prefix of zero to | |
17040 | suppress the adjustment if so. | |
17041 | ||
17042 | @kindex t C | |
17043 | @pindex calc-convert-time-zones | |
17044 | @tindex tzconv | |
17045 | @cindex Time Zones, converting between | |
17046 | The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}] | |
17047 | command converts a date form from one time zone to another. You | |
17048 | are prompted for each time zone name in turn; you can answer with | |
17049 | any suitable Calc time zone expression (@pxref{Time Zones}). | |
17050 | If you answer either prompt with a blank line, the local time | |
17051 | zone is used for that prompt. You can also answer the first | |
17052 | prompt with @kbd{$} to take the two time zone names from the | |
17053 | stack (and the date to be converted from the third stack level). | |
17054 | ||
17055 | @node Date Functions, Business Days, Date Conversions, Date Arithmetic | |
17056 | @subsection Date Functions | |
17057 | ||
17058 | @noindent | |
17059 | @kindex t N | |
17060 | @pindex calc-now | |
17061 | @tindex now | |
17062 | The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the | |
17063 | current date and time on the stack as a date form. The time is | |
17064 | reported in terms of the specified time zone; with no numeric prefix | |
17065 | argument, @kbd{t N} reports for the current time zone. | |
17066 | ||
17067 | @kindex t P | |
17068 | @pindex calc-date-part | |
17069 | The @kbd{t P} (@code{calc-date-part}) command extracts one part | |
17070 | of a date form. The prefix argument specifies the part; with no | |
17071 | argument, this command prompts for a part code from 1 to 9. | |
17072 | The various part codes are described in the following paragraphs. | |
17073 | ||
17074 | @tindex year | |
17075 | The @kbd{M-1 t P} [@code{year}] function extracts the year number | |
17076 | from a date form as an integer, e.g., 1991. This and the | |
17077 | following functions will also accept a real number for an | |
17078 | argument, which is interpreted as a standard Calc day number. | |
17079 | Note that this function will never return zero, since the year | |
17080 | 1 BC immediately precedes the year 1 AD. | |
17081 | ||
17082 | @tindex month | |
17083 | The @kbd{M-2 t P} [@code{month}] function extracts the month number | |
17084 | from a date form as an integer in the range 1 to 12. | |
17085 | ||
17086 | @tindex day | |
17087 | The @kbd{M-3 t P} [@code{day}] function extracts the day number | |
17088 | from a date form as an integer in the range 1 to 31. | |
17089 | ||
17090 | @tindex hour | |
17091 | The @kbd{M-4 t P} [@code{hour}] function extracts the hour from | |
17092 | a date form as an integer in the range 0 (midnight) to 23. Note | |
17093 | that 24-hour time is always used. This returns zero for a pure | |
17094 | date form. This function (and the following two) also accept | |
17095 | HMS forms as input. | |
17096 | ||
17097 | @tindex minute | |
17098 | The @kbd{M-5 t P} [@code{minute}] function extracts the minute | |
17099 | from a date form as an integer in the range 0 to 59. | |
17100 | ||
17101 | @tindex second | |
17102 | The @kbd{M-6 t P} [@code{second}] function extracts the second | |
17103 | from a date form. If the current precision is 12 or less, | |
17104 | the result is an integer in the range 0 to 59. For higher | |
17105 | precisions, the result may instead be a floating-point number. | |
17106 | ||
17107 | @tindex weekday | |
17108 | The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday | |
17109 | number from a date form as an integer in the range 0 (Sunday) | |
17110 | to 6 (Saturday). | |
17111 | ||
17112 | @tindex yearday | |
17113 | The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year | |
17114 | number from a date form as an integer in the range 1 (January 1) | |
17115 | to 366 (December 31 of a leap year). | |
17116 | ||
17117 | @tindex time | |
17118 | The @kbd{M-9 t P} [@code{time}] function extracts the time portion | |
17119 | of a date form as an HMS form. This returns @samp{0@@ 0' 0"} | |
17120 | for a pure date form. | |
17121 | ||
17122 | @kindex t M | |
17123 | @pindex calc-new-month | |
17124 | @tindex newmonth | |
17125 | The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command | |
17126 | computes a new date form that represents the first day of the month | |
17127 | specified by the input date. The result is always a pure date | |
17128 | form; only the year and month numbers of the input are retained. | |
17129 | With a numeric prefix argument @var{n} in the range from 1 to 31, | |
17130 | @kbd{t M} computes the @var{n}th day of the month. (If @var{n} | |
17131 | is greater than the actual number of days in the month, or if | |
17132 | @var{n} is zero, the last day of the month is used.) | |
17133 | ||
17134 | @kindex t Y | |
17135 | @pindex calc-new-year | |
17136 | @tindex newyear | |
17137 | The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command | |
17138 | computes a new pure date form that represents the first day of | |
17139 | the year specified by the input. The month, day, and time | |
17140 | of the input date form are lost. With a numeric prefix argument | |
17141 | @var{n} in the range from 1 to 366, @kbd{t Y} computes the | |
17142 | @var{n}th day of the year (366 is treated as 365 in non-leap | |
17143 | years). A prefix argument of 0 computes the last day of the | |
8e04863e JB |
17144 | year (December 31). A negative prefix argument from @mathit{-1} to |
17145 | @mathit{-12} computes the first day of the @var{n}th month of the year. | |
d7b8e6c6 EZ |
17146 | |
17147 | @kindex t W | |
17148 | @pindex calc-new-week | |
17149 | @tindex newweek | |
17150 | The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command | |
17151 | computes a new pure date form that represents the Sunday on or before | |
17152 | the input date. With a numeric prefix argument, it can be made to | |
17153 | use any day of the week as the starting day; the argument must be in | |
17154 | the range from 0 (Sunday) to 6 (Saturday). This function always | |
17155 | subtracts between 0 and 6 days from the input date. | |
17156 | ||
17157 | Here's an example use of @code{newweek}: Find the date of the next | |
17158 | Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)} | |
17159 | will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)} | |
17160 | will give you the following Wednesday. A further look at the definition | |
17161 | of @code{newweek} shows that if the input date is itself a Wednesday, | |
17162 | this formula will return the Wednesday one week in the future. An | |
17163 | exercise for the reader is to modify this formula to yield the same day | |
17164 | if the input is already a Wednesday. Another interesting exercise is | |
17165 | to preserve the time-of-day portion of the input (@code{newweek} resets | |
17166 | the time to midnight; hint:@: how can @code{newweek} be defined in terms | |
17167 | of the @code{weekday} function?). | |
17168 | ||
5d67986c RS |
17169 | @ignore |
17170 | @starindex | |
17171 | @end ignore | |
d7b8e6c6 EZ |
17172 | @tindex pwday |
17173 | The @samp{pwday(@var{date})} function (not on any key) computes the | |
17174 | day-of-month number of the Sunday on or before @var{date}. With | |
17175 | two arguments, @samp{pwday(@var{date}, @var{day})} computes the day | |
17176 | number of the Sunday on or before day number @var{day} of the month | |
17177 | specified by @var{date}. The @var{day} must be in the range from | |
17178 | 7 to 31; if the day number is greater than the actual number of days | |
17179 | in the month, the true number of days is used instead. Thus | |
17180 | @samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and | |
17181 | @samp{pwday(@var{date}, 31)} finds the last Sunday of the month. | |
17182 | With a third @var{weekday} argument, @code{pwday} can be made to look | |
17183 | for any day of the week instead of Sunday. | |
17184 | ||
17185 | @kindex t I | |
17186 | @pindex calc-inc-month | |
17187 | @tindex incmonth | |
17188 | The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command | |
17189 | increases a date form by one month, or by an arbitrary number of | |
17190 | months specified by a numeric prefix argument. The time portion, | |
17191 | if any, of the date form stays the same. The day also stays the | |
17192 | same, except that if the new month has fewer days the day | |
17193 | number may be reduced to lie in the valid range. For example, | |
17194 | @samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}. | |
17195 | Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give | |
17196 | the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>} | |
17197 | in this case). | |
17198 | ||
5d67986c RS |
17199 | @ignore |
17200 | @starindex | |
17201 | @end ignore | |
d7b8e6c6 EZ |
17202 | @tindex incyear |
17203 | The @samp{incyear(@var{date}, @var{step})} function increases | |
17204 | a date form by the specified number of years, which may be | |
17205 | any positive or negative integer. Note that @samp{incyear(d, n)} | |
17206 | is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have | |
17207 | simple equivalents in terms of day arithmetic because | |
17208 | months and years have varying lengths. If the @var{step} | |
17209 | argument is omitted, 1 year is assumed. There is no keyboard | |
17210 | command for this function; use @kbd{C-u 12 t I} instead. | |
17211 | ||
17212 | There is no @code{newday} function at all because @kbd{F} [@code{floor}] | |
17213 | serves this purpose. Similarly, instead of @code{incday} and | |
a4231b04 | 17214 | @code{incweek} simply use @expr{d + n} or @expr{d + 7 n}. |
d7b8e6c6 EZ |
17215 | |
17216 | @xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command | |
17217 | which can adjust a date/time form by a certain number of seconds. | |
17218 | ||
17219 | @node Business Days, Time Zones, Date Functions, Date Arithmetic | |
17220 | @subsection Business Days | |
17221 | ||
17222 | @noindent | |
17223 | Often time is measured in ``business days'' or ``working days,'' | |
17224 | where weekends and holidays are skipped. Calc's normal date | |
17225 | arithmetic functions use calendar days, so that subtracting two | |
17226 | consecutive Mondays will yield a difference of 7 days. By contrast, | |
17227 | subtracting two consecutive Mondays would yield 5 business days | |
17228 | (assuming two-day weekends and the absence of holidays). | |
17229 | ||
17230 | @kindex t + | |
17231 | @kindex t - | |
17232 | @tindex badd | |
17233 | @tindex bsub | |
17234 | @pindex calc-business-days-plus | |
17235 | @pindex calc-business-days-minus | |
17236 | The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}] | |
17237 | and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}] | |
17238 | commands perform arithmetic using business days. For @kbd{t +}, | |
17239 | one argument must be a date form and the other must be a real | |
17240 | number (positive or negative). If the number is not an integer, | |
17241 | then a certain amount of time is added as well as a number of | |
17242 | days; for example, adding 0.5 business days to a time in Friday | |
17243 | evening will produce a time in Monday morning. It is also | |
17244 | possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds | |
17245 | half a business day. For @kbd{t -}, the arguments are either a | |
17246 | date form and a number or HMS form, or two date forms, in which | |
17247 | case the result is the number of business days between the two | |
17248 | dates. | |
17249 | ||
17250 | @cindex @code{Holidays} variable | |
17251 | @vindex Holidays | |
17252 | By default, Calc considers any day that is not a Saturday or | |
17253 | Sunday to be a business day. You can define any number of | |
17254 | additional holidays by editing the variable @code{Holidays}. | |
17255 | (There is an @w{@kbd{s H}} convenience command for editing this | |
17256 | variable.) Initially, @code{Holidays} contains the vector | |
17257 | @samp{[sat, sun]}. Entries in the @code{Holidays} vector may | |
17258 | be any of the following kinds of objects: | |
17259 | ||
17260 | @itemize @bullet | |
17261 | @item | |
17262 | Date forms (pure dates, not date/time forms). These specify | |
17263 | particular days which are to be treated as holidays. | |
17264 | ||
17265 | @item | |
17266 | Intervals of date forms. These specify a range of days, all of | |
17267 | which are holidays (e.g., Christmas week). @xref{Interval Forms}. | |
17268 | ||
17269 | @item | |
17270 | Nested vectors of date forms. Each date form in the vector is | |
17271 | considered to be a holiday. | |
17272 | ||
17273 | @item | |
17274 | Any Calc formula which evaluates to one of the above three things. | |
a4231b04 JB |
17275 | If the formula involves the variable @expr{y}, it stands for a |
17276 | yearly repeating holiday; @expr{y} will take on various year | |
d7b8e6c6 EZ |
17277 | numbers like 1992. For example, @samp{date(y, 12, 25)} specifies |
17278 | Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies | |
17279 | Thanksgiving (which is held on the fourth Thursday of November). | |
a4231b04 | 17280 | If the formula involves the variable @expr{m}, that variable |
d7b8e6c6 EZ |
17281 | takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is |
17282 | a holiday that takes place on the 15th of every month. | |
17283 | ||
17284 | @item | |
17285 | A weekday name, such as @code{sat} or @code{sun}. This is really | |
17286 | a variable whose name is a three-letter, lower-case day name. | |
17287 | ||
17288 | @item | |
17289 | An interval of year numbers (integers). This specifies the span of | |
17290 | years over which this holiday list is to be considered valid. Any | |
17291 | business-day arithmetic that goes outside this range will result | |
17292 | in an error message. Use this if you are including an explicit | |
17293 | list of holidays, rather than a formula to generate them, and you | |
17294 | want to make sure you don't accidentally go beyond the last point | |
17295 | where the holidays you entered are complete. If there is no | |
17296 | limiting interval in the @code{Holidays} vector, the default | |
17297 | @samp{[1 .. 2737]} is used. (This is the absolute range of years | |
17298 | for which Calc's business-day algorithms will operate.) | |
17299 | ||
17300 | @item | |
17301 | An interval of HMS forms. This specifies the span of hours that | |
17302 | are to be considered one business day. For example, if this | |
17303 | range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then | |
17304 | the business day is only eight hours long, so that @kbd{1.5 t +} | |
17305 | on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and | |
17306 | four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}. | |
17307 | Likewise, @kbd{t -} will now express differences in time as | |
17308 | fractions of an eight-hour day. Times before 9am will be treated | |
17309 | as 9am by business date arithmetic, and times at or after 5pm will | |
17310 | be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays}, | |
17311 | the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed. | |
17312 | (Regardless of the type of bounds you specify, the interval is | |
17313 | treated as inclusive on the low end and exclusive on the high end, | |
17314 | so that the work day goes from 9am up to, but not including, 5pm.) | |
17315 | @end itemize | |
17316 | ||
17317 | If the @code{Holidays} vector is empty, then @kbd{t +} and | |
17318 | @kbd{t -} will act just like @kbd{+} and @kbd{-} because there will | |
17319 | then be no difference between business days and calendar days. | |
17320 | ||
17321 | Calc expands the intervals and formulas you give into a complete | |
17322 | list of holidays for internal use. This is done mainly to make | |
17323 | sure it can detect multiple holidays. (For example, | |
17324 | @samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but | |
17325 | Calc's algorithms take care to count it only once when figuring | |
17326 | the number of holidays between two dates.) | |
17327 | ||
17328 | Since the complete list of holidays for all the years from 1 to | |
17329 | 2737 would be huge, Calc actually computes only the part of the | |
17330 | list between the smallest and largest years that have been involved | |
17331 | in business-day calculations so far. Normally, you won't have to | |
17332 | worry about this. Keep in mind, however, that if you do one | |
17333 | calculation for 1992, and another for 1792, even if both involve | |
17334 | only a small range of years, Calc will still work out all the | |
17335 | holidays that fall in that 200-year span. | |
17336 | ||
17337 | If you add a (positive) number of days to a date form that falls on a | |
17338 | weekend or holiday, the date form is treated as if it were the most | |
17339 | recent business day. (Thus adding one business day to a Friday, | |
17340 | Saturday, or Sunday will all yield the following Monday.) If you | |
17341 | subtract a number of days from a weekend or holiday, the date is | |
17342 | effectively on the following business day. (So subtracting one business | |
17343 | day from Saturday, Sunday, or Monday yields the preceding Friday.) The | |
17344 | difference between two dates one or both of which fall on holidays | |
17345 | equals the number of actual business days between them. These | |
17346 | conventions are consistent in the sense that, if you add @var{n} | |
17347 | business days to any date, the difference between the result and the | |
17348 | original date will come out to @var{n} business days. (It can't be | |
17349 | completely consistent though; a subtraction followed by an addition | |
17350 | might come out a bit differently, since @kbd{t +} is incapable of | |
17351 | producing a date that falls on a weekend or holiday.) | |
17352 | ||
5d67986c RS |
17353 | @ignore |
17354 | @starindex | |
17355 | @end ignore | |
d7b8e6c6 EZ |
17356 | @tindex holiday |
17357 | There is a @code{holiday} function, not on any keys, that takes | |
17358 | any date form and returns 1 if that date falls on a weekend or | |
17359 | holiday, as defined in @code{Holidays}, or 0 if the date is a | |
17360 | business day. | |
17361 | ||
17362 | @node Time Zones, , Business Days, Date Arithmetic | |
17363 | @subsection Time Zones | |
17364 | ||
17365 | @noindent | |
17366 | @cindex Time zones | |
17367 | @cindex Daylight savings time | |
17368 | Time zones and daylight savings time are a complicated business. | |
17369 | The conversions to and from Julian and Unix-style dates automatically | |
17370 | compute the correct time zone and daylight savings adjustment to use, | |
17371 | provided they can figure out this information. This section describes | |
17372 | Calc's time zone adjustment algorithm in detail, in case you want to | |
17373 | do conversions in different time zones or in case Calc's algorithms | |
17374 | can't determine the right correction to use. | |
17375 | ||
17376 | Adjustments for time zones and daylight savings time are done by | |
17377 | @kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other | |
17378 | commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates | |
17379 | to exactly 30 days even though there is a daylight-savings | |
17380 | transition in between. This is also true for Julian pure dates: | |
17381 | @samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian | |
17382 | and Unix date/times will adjust for daylight savings time: | |
17383 | @samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)} | |
17384 | evaluates to @samp{29.95834} (that's 29 days and 23 hours) | |
17385 | because one hour was lost when daylight savings commenced on | |
17386 | April 7, 1991. | |
17387 | ||
17388 | In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})} | |
17389 | computes the actual number of 24-hour periods between two dates, whereas | |
17390 | @samp{@var{date1} - @var{date2}} computes the number of calendar | |
17391 | days between two dates without taking daylight savings into account. | |
17392 | ||
17393 | @pindex calc-time-zone | |
5d67986c RS |
17394 | @ignore |
17395 | @starindex | |
17396 | @end ignore | |
d7b8e6c6 EZ |
17397 | @tindex tzone |
17398 | The @code{calc-time-zone} [@code{tzone}] command converts the time | |
17399 | zone specified by its numeric prefix argument into a number of | |
17400 | seconds difference from Greenwich mean time (GMT). If the argument | |
17401 | is a number, the result is simply that value multiplied by 3600. | |
17402 | Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If | |
17403 | Daylight Savings time is in effect, one hour should be subtracted from | |
17404 | the normal difference. | |
17405 | ||
17406 | If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other | |
17407 | date arithmetic commands that include a time zone argument) takes the | |
17408 | zone argument from the top of the stack. (In the case of @kbd{t J} | |
17409 | and @kbd{t U}, the normal argument is then taken from the second-to-top | |
17410 | stack position.) This allows you to give a non-integer time zone | |
17411 | adjustment. The time-zone argument can also be an HMS form, or | |
17412 | it can be a variable which is a time zone name in upper- or lower-case. | |
17413 | For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)} | |
17414 | (for Pacific standard and daylight savings times, respectively). | |
17415 | ||
17416 | North American and European time zone names are defined as follows; | |
17417 | note that for each time zone there is one name for standard time, | |
17418 | another for daylight savings time, and a third for ``generalized'' time | |
17419 | in which the daylight savings adjustment is computed from context. | |
17420 | ||
d7b8e6c6 | 17421 | @smallexample |
5d67986c | 17422 | @group |
d7b8e6c6 EZ |
17423 | YST PST MST CST EST AST NST GMT WET MET MEZ |
17424 | 9 8 7 6 5 4 3.5 0 -1 -2 -2 | |
17425 | ||
17426 | YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ | |
17427 | 8 7 6 5 4 3 2.5 -1 -2 -3 -3 | |
17428 | ||
17429 | YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ | |
17430 | 9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3 | |
d7b8e6c6 | 17431 | @end group |
5d67986c | 17432 | @end smallexample |
d7b8e6c6 EZ |
17433 | |
17434 | @vindex math-tzone-names | |
17435 | To define time zone names that do not appear in the above table, | |
17436 | you must modify the Lisp variable @code{math-tzone-names}. This | |
17437 | is a list of lists describing the different time zone names; its | |
17438 | structure is best explained by an example. The three entries for | |
17439 | Pacific Time look like this: | |
17440 | ||
d7b8e6c6 | 17441 | @smallexample |
5d67986c | 17442 | @group |
d7b8e6c6 EZ |
17443 | ( ( "PST" 8 0 ) ; Name as an upper-case string, then standard |
17444 | ( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment. | |
17445 | ( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone. | |
d7b8e6c6 | 17446 | @end group |
5d67986c | 17447 | @end smallexample |
d7b8e6c6 EZ |
17448 | |
17449 | @cindex @code{TimeZone} variable | |
17450 | @vindex TimeZone | |
17451 | With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an | |
17452 | argument from the Calc variable @code{TimeZone} if a value has been | |
17453 | stored for that variable. If not, Calc runs the Unix @samp{date} | |
17454 | command and looks for one of the above time zone names in the output; | |
17455 | if this does not succeed, @samp{tzone()} leaves itself unevaluated. | |
17456 | The time zone name in the @samp{date} output may be followed by a signed | |
17457 | adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a | |
17458 | number of hours and minutes to be added to the base time zone. | |
17459 | Calc stores the time zone it finds into @code{TimeZone} to speed | |
17460 | later calls to @samp{tzone()}. | |
17461 | ||
17462 | The special time zone name @code{local} is equivalent to no argument, | |
17463 | i.e., it uses the local time zone as obtained from the @code{date} | |
17464 | command. | |
17465 | ||
17466 | If the time zone name found is one of the standard or daylight | |
17467 | savings zone names from the above table, and Calc's internal | |
17468 | daylight savings algorithm says that time and zone are consistent | |
17469 | (e.g., @code{PDT} accompanies a date that Calc's algorithm would also | |
17470 | consider to be daylight savings, or @code{PST} accompanies a date | |
17471 | that Calc would consider to be standard time), then Calc substitutes | |
17472 | the corresponding generalized time zone (like @code{PGT}). | |
17473 | ||
17474 | If your system does not have a suitable @samp{date} command, you | |
17475 | may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs | |
4f38ed98 JB |
17476 | initialization file to set the time zone. (Since you are interacting |
17477 | with the variable @code{TimeZone} directly from Emacs Lisp, the | |
17478 | @code{var-} prefix needs to be present.) The easiest way to do | |
d7b8e6c6 EZ |
17479 | this is to edit the @code{TimeZone} variable using Calc's @kbd{s T} |
17480 | command, then use the @kbd{s p} (@code{calc-permanent-variable}) | |
17481 | command to save the value of @code{TimeZone} permanently. | |
17482 | ||
17483 | The @kbd{t J} and @code{t U} commands with no numeric prefix | |
17484 | arguments do the same thing as @samp{tzone()}. If the current | |
17485 | time zone is a generalized time zone, e.g., @code{EGT}, Calc | |
17486 | examines the date being converted to tell whether to use standard | |
17487 | or daylight savings time. But if the current time zone is explicit, | |
17488 | e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly | |
17489 | and Calc's daylight savings algorithm is not consulted. | |
17490 | ||
17491 | Some places don't follow the usual rules for daylight savings time. | |
17492 | The state of Arizona, for example, does not observe daylight savings | |
17493 | time. If you run Calc during the winter season in Arizona, the | |
17494 | Unix @code{date} command will report @code{MST} time zone, which | |
17495 | Calc will change to @code{MGT}. If you then convert a time that | |
17496 | lies in the summer months, Calc will apply an incorrect daylight | |
17497 | savings time adjustment. To avoid this, set your @code{TimeZone} | |
17498 | variable explicitly to @code{MST} to force the use of standard, | |
17499 | non-daylight-savings time. | |
17500 | ||
17501 | @vindex math-daylight-savings-hook | |
17502 | @findex math-std-daylight-savings | |
17503 | By default Calc always considers daylight savings time to begin at | |
17504 | 2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the | |
17505 | last Sunday of October. This is the rule that has been in effect | |
17506 | in North America since 1987. If you are in a country that uses | |
17507 | different rules for computing daylight savings time, you have two | |
17508 | choices: Write your own daylight savings hook, or control time | |
17509 | zones explicitly by setting the @code{TimeZone} variable and/or | |
17510 | always giving a time-zone argument for the conversion functions. | |
17511 | ||
17512 | The Lisp variable @code{math-daylight-savings-hook} holds the | |
17513 | name of a function that is used to compute the daylight savings | |
17514 | adjustment for a given date. The default is | |
17515 | @code{math-std-daylight-savings}, which computes an adjustment | |
8e04863e | 17516 | (either 0 or @mathit{-1}) using the North American rules given above. |
d7b8e6c6 EZ |
17517 | |
17518 | The daylight savings hook function is called with four arguments: | |
17519 | The date, as a floating-point number in standard Calc format; | |
17520 | a six-element list of the date decomposed into year, month, day, | |
17521 | hour, minute, and second, respectively; a string which contains | |
17522 | the generalized time zone name in upper-case, e.g., @code{"WEGT"}; | |
17523 | and a special adjustment to be applied to the hour value when | |
17524 | converting into a generalized time zone (see below). | |
17525 | ||
17526 | @findex math-prev-weekday-in-month | |
17527 | The Lisp function @code{math-prev-weekday-in-month} is useful for | |
17528 | daylight savings computations. This is an internal version of | |
17529 | the user-level @code{pwday} function described in the previous | |
17530 | section. It takes four arguments: The floating-point date value, | |
17531 | the corresponding six-element date list, the day-of-month number, | |
17532 | and the weekday number (0-6). | |
17533 | ||
17534 | The default daylight savings hook ignores the time zone name, but a | |
17535 | more sophisticated hook could use different algorithms for different | |
17536 | time zones. It would also be possible to use different algorithms | |
17537 | depending on the year number, but the default hook always uses the | |
17538 | algorithm for 1987 and later. Here is a listing of the default | |
17539 | daylight savings hook: | |
17540 | ||
17541 | @smallexample | |
17542 | (defun math-std-daylight-savings (date dt zone bump) | |
17543 | (cond ((< (nth 1 dt) 4) 0) | |
17544 | ((= (nth 1 dt) 4) | |
17545 | (let ((sunday (math-prev-weekday-in-month date dt 7 0))) | |
17546 | (cond ((< (nth 2 dt) sunday) 0) | |
17547 | ((= (nth 2 dt) sunday) | |
17548 | (if (>= (nth 3 dt) (+ 3 bump)) -1 0)) | |
17549 | (t -1)))) | |
17550 | ((< (nth 1 dt) 10) -1) | |
17551 | ((= (nth 1 dt) 10) | |
17552 | (let ((sunday (math-prev-weekday-in-month date dt 31 0))) | |
17553 | (cond ((< (nth 2 dt) sunday) -1) | |
17554 | ((= (nth 2 dt) sunday) | |
17555 | (if (>= (nth 3 dt) (+ 2 bump)) 0 -1)) | |
17556 | (t 0)))) | |
17557 | (t 0)) | |
17558 | ) | |
17559 | @end smallexample | |
17560 | ||
17561 | @noindent | |
17562 | The @code{bump} parameter is equal to zero when Calc is converting | |
17563 | from a date form in a generalized time zone into a GMT date value. | |
8e04863e | 17564 | It is @mathit{-1} when Calc is converting in the other direction. The |
d7b8e6c6 EZ |
17565 | adjustments shown above ensure that the conversion behaves correctly |
17566 | and reasonably around the 2 a.m.@: transition in each direction. | |
17567 | ||
17568 | There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the | |
17569 | beginning of daylight savings time; converting a date/time form that | |
17570 | falls in this hour results in a time value for the following hour, | |
17571 | from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the | |
17572 | hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time | |
12874db7 | 17573 | form that falls in this hour results in a time value for the first |
28665d46 | 17574 | manifestation of that time (@emph{not} the one that occurs one hour later). |
d7b8e6c6 EZ |
17575 | |
17576 | If @code{math-daylight-savings-hook} is @code{nil}, then the | |
17577 | daylight savings adjustment is always taken to be zero. | |
17578 | ||
17579 | In algebraic formulas, @samp{tzone(@var{zone}, @var{date})} | |
17580 | computes the time zone adjustment for a given zone name at a | |
17581 | given date. The @var{date} is ignored unless @var{zone} is a | |
17582 | generalized time zone. If @var{date} is a date form, the | |
17583 | daylight savings computation is applied to it as it appears. | |
17584 | If @var{date} is a numeric date value, it is adjusted for the | |
17585 | daylight-savings version of @var{zone} before being given to | |
17586 | the daylight savings hook. This odd-sounding rule ensures | |
17587 | that the daylight-savings computation is always done in | |
17588 | local time, not in the GMT time that a numeric @var{date} | |
17589 | is typically represented in. | |
17590 | ||
5d67986c RS |
17591 | @ignore |
17592 | @starindex | |
17593 | @end ignore | |
d7b8e6c6 EZ |
17594 | @tindex dsadj |
17595 | The @samp{dsadj(@var{date}, @var{zone})} function computes the | |
17596 | daylight savings adjustment that is appropriate for @var{date} in | |
17597 | time zone @var{zone}. If @var{zone} is explicitly in or not in | |
17598 | daylight savings time (e.g., @code{PDT} or @code{PST}) the | |
17599 | @var{date} is ignored. If @var{zone} is a generalized time zone, | |
17600 | the algorithms described above are used. If @var{zone} is omitted, | |
17601 | the computation is done for the current time zone. | |
17602 | ||
17603 | @xref{Reporting Bugs}, for the address of Calc's author, if you | |
17604 | should wish to contribute your improved versions of | |
17605 | @code{math-tzone-names} and @code{math-daylight-savings-hook} | |
17606 | to the Calc distribution. | |
17607 | ||
17608 | @node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic | |
17609 | @section Financial Functions | |
17610 | ||
17611 | @noindent | |
17612 | Calc's financial or business functions use the @kbd{b} prefix | |
17613 | key followed by a shifted letter. (The @kbd{b} prefix followed by | |
17614 | a lower-case letter is used for operations on binary numbers.) | |
17615 | ||
17616 | Note that the rate and the number of intervals given to these | |
17617 | functions must be on the same time scale, e.g., both months or | |
17618 | both years. Mixing an annual interest rate with a time expressed | |
17619 | in months will give you very wrong answers! | |
17620 | ||
17621 | It is wise to compute these functions to a higher precision than | |
17622 | you really need, just to make sure your answer is correct to the | |
17623 | last penny; also, you may wish to check the definitions at the end | |
17624 | of this section to make sure the functions have the meaning you expect. | |
17625 | ||
17626 | @menu | |
17627 | * Percentages:: | |
17628 | * Future Value:: | |
17629 | * Present Value:: | |
17630 | * Related Financial Functions:: | |
17631 | * Depreciation Functions:: | |
17632 | * Definitions of Financial Functions:: | |
17633 | @end menu | |
17634 | ||
17635 | @node Percentages, Future Value, Financial Functions, Financial Functions | |
17636 | @subsection Percentages | |
17637 | ||
17638 | @kindex M-% | |
17639 | @pindex calc-percent | |
17640 | @tindex % | |
17641 | @tindex percent | |
17642 | The @kbd{M-%} (@code{calc-percent}) command takes a percentage value, | |
17643 | say 5.4, and converts it to an equivalent actual number. For example, | |
17644 | @kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or | |
17645 | @key{ESC} key combined with @kbd{%}.) | |
17646 | ||
17647 | Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}. | |
17648 | You can enter @samp{5.4%} yourself during algebraic entry. The | |
17649 | @samp{%} operator simply means, ``the preceding value divided by | |
17650 | 100.'' The @samp{%} operator has very high precedence, so that | |
17651 | @samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}. | |
17652 | (The @samp{%} operator is just a postfix notation for the | |
17653 | @code{percent} function, just like @samp{20!} is the notation for | |
17654 | @samp{fact(20)}, or twenty-factorial.) | |
17655 | ||
17656 | The formula @samp{5.4%} would normally evaluate immediately to | |
17657 | 0.054, but the @kbd{M-%} command suppresses evaluation as it puts | |
17658 | the formula onto the stack. However, the next Calc command that | |
17659 | uses the formula @samp{5.4%} will evaluate it as its first step. | |
17660 | The net effect is that you get to look at @samp{5.4%} on the stack, | |
17661 | but Calc commands see it as @samp{0.054}, which is what they expect. | |
17662 | ||
17663 | In particular, @samp{5.4%} and @samp{0.054} are suitable values | |
17664 | for the @var{rate} arguments of the various financial functions, | |
17665 | but the number @samp{5.4} is probably @emph{not} suitable---it | |
17666 | represents a rate of 540 percent! | |
17667 | ||
17668 | The key sequence @kbd{M-% *} effectively means ``percent-of.'' | |
5d67986c | 17669 | For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of |
d7b8e6c6 EZ |
17670 | 68 (and also 68% of 25, which comes out to the same thing). |
17671 | ||
17672 | @kindex c % | |
17673 | @pindex calc-convert-percent | |
17674 | The @kbd{c %} (@code{calc-convert-percent}) command converts the | |
17675 | value on the top of the stack from numeric to percentage form. | |
17676 | For example, if 0.08 is on the stack, @kbd{c %} converts it to | |
17677 | @samp{8%}. The quantity is the same, it's just represented | |
17678 | differently. (Contrast this with @kbd{M-%}, which would convert | |
17679 | this number to @samp{0.08%}.) The @kbd{=} key is a convenient way | |
17680 | to convert a formula like @samp{8%} back to numeric form, 0.08. | |
17681 | ||
17682 | To compute what percentage one quantity is of another quantity, | |
5d67986c | 17683 | use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays |
d7b8e6c6 EZ |
17684 | @samp{25%}. |
17685 | ||
17686 | @kindex b % | |
17687 | @pindex calc-percent-change | |
17688 | @tindex relch | |
17689 | The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command | |
17690 | calculates the percentage change from one number to another. | |
5d67986c | 17691 | For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%}, |
d7b8e6c6 | 17692 | since 50 is 25% larger than 40. A negative result represents a |
5d67986c | 17693 | decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is |
d7b8e6c6 EZ |
17694 | 20% smaller than 50. (The answers are different in magnitude |
17695 | because, in the first case, we're increasing by 25% of 40, but | |
17696 | in the second case, we're decreasing by 20% of 50.) The effect | |
a4231b04 | 17697 | of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting |
d7b8e6c6 EZ |
17698 | the answer to percentage form as if by @kbd{c %}. |
17699 | ||
17700 | @node Future Value, Present Value, Percentages, Financial Functions | |
17701 | @subsection Future Value | |
17702 | ||
17703 | @noindent | |
17704 | @kindex b F | |
17705 | @pindex calc-fin-fv | |
17706 | @tindex fv | |
17707 | The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes | |
17708 | the future value of an investment. It takes three arguments | |
17709 | from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}. | |
17710 | If you give payments of @var{payment} every year for @var{n} | |
17711 | years, and the money you have paid earns interest at @var{rate} per | |
17712 | year, then this function tells you what your investment would be | |
17713 | worth at the end of the period. (The actual interval doesn't | |
17714 | have to be years, as long as @var{n} and @var{rate} are expressed | |
17715 | in terms of the same intervals.) This function assumes payments | |
17716 | occur at the @emph{end} of each interval. | |
17717 | ||
17718 | @kindex I b F | |
17719 | @tindex fvb | |
17720 | The @kbd{I b F} [@code{fvb}] command does the same computation, | |
17721 | but assuming your payments are at the beginning of each interval. | |
17722 | Suppose you plan to deposit $1000 per year in a savings account | |
17723 | earning 5.4% interest, starting right now. How much will be | |
17724 | in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}. | |
17725 | Thus you will have earned $870 worth of interest over the years. | |
17726 | Using the stack, this calculation would have been | |
5d67986c | 17727 | @kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed |
d7b8e6c6 EZ |
17728 | as a number between 0 and 1, @emph{not} as a percentage. |
17729 | ||
17730 | @kindex H b F | |
17731 | @tindex fvl | |
17732 | The @kbd{H b F} [@code{fvl}] command computes the future value | |
17733 | of an initial lump sum investment. Suppose you could deposit | |
17734 | those five thousand dollars in the bank right now; how much would | |
17735 | they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}. | |
17736 | ||
17737 | The algebraic functions @code{fv} and @code{fvb} accept an optional | |
17738 | fourth argument, which is used as an initial lump sum in the sense | |
17739 | of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n}, | |
17740 | @var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment}) | |
a4231b04 | 17741 | + fvl(@var{rate}, @var{n}, @var{initial})}. |
d7b8e6c6 EZ |
17742 | |
17743 | To illustrate the relationships between these functions, we could | |
17744 | do the @code{fvb} calculation ``by hand'' using @code{fvl}. The | |
17745 | final balance will be the sum of the contributions of our five | |
17746 | deposits at various times. The first deposit earns interest for | |
17747 | five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second | |
17748 | deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) = | |
17749 | 1234.13}. And so on down to the last deposit, which earns one | |
17750 | year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of | |
17751 | these five values is, sure enough, $5870.73, just as was computed | |
17752 | by @code{fvb} directly. | |
17753 | ||
17754 | What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments | |
17755 | are now at the ends of the periods. The end of one year is the same | |
17756 | as the beginning of the next, so what this really means is that we've | |
17757 | lost the payment at year zero (which contributed $1300.78), but we're | |
17758 | now counting the payment at year five (which, since it didn't have | |
a4231b04 | 17759 | a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 = |
d7b8e6c6 EZ |
17760 | 5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error). |
17761 | ||
17762 | @node Present Value, Related Financial Functions, Future Value, Financial Functions | |
17763 | @subsection Present Value | |
17764 | ||
17765 | @noindent | |
17766 | @kindex b P | |
17767 | @pindex calc-fin-pv | |
17768 | @tindex pv | |
17769 | The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes | |
17770 | the present value of an investment. Like @code{fv}, it takes | |
17771 | three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}. | |
17772 | It computes the present value of a series of regular payments. | |
17773 | Suppose you have the chance to make an investment that will | |
17774 | pay $2000 per year over the next four years; as you receive | |
17775 | these payments you can put them in the bank at 9% interest. | |
17776 | You want to know whether it is better to make the investment, or | |
17777 | to keep the money in the bank where it earns 9% interest right | |
17778 | from the start. The calculation @code{pv(9%, 4, 2000)} gives the | |
17779 | result 6479.44. If your initial investment must be less than this, | |
17780 | say, $6000, then the investment is worthwhile. But if you had to | |
17781 | put up $7000, then it would be better just to leave it in the bank. | |
17782 | ||
17783 | Here is the interpretation of the result of @code{pv}: You are | |
17784 | trying to compare the return from the investment you are | |
17785 | considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with | |
17786 | the return from leaving the money in the bank, which is | |
17787 | @code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money | |
17788 | you would have to put up in advance. The @code{pv} function | |
a4231b04 | 17789 | finds the break-even point, @expr{x = 6479.44}, at which |
d7b8e6c6 EZ |
17790 | @code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is |
17791 | the largest amount you should be willing to invest. | |
17792 | ||
17793 | @kindex I b P | |
17794 | @tindex pvb | |
17795 | The @kbd{I b P} [@code{pvb}] command solves the same problem, | |
17796 | but with payments occurring at the beginning of each interval. | |
17797 | It has the same relationship to @code{fvb} as @code{pv} has | |
17798 | to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59}, | |
17799 | a larger number than @code{pv} produced because we get to start | |
17800 | earning interest on the return from our investment sooner. | |
17801 | ||
17802 | @kindex H b P | |
17803 | @tindex pvl | |
17804 | The @kbd{H b P} [@code{pvl}] command computes the present value of | |
17805 | an investment that will pay off in one lump sum at the end of the | |
17806 | period. For example, if we get our $8000 all at the end of the | |
17807 | four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much | |
17808 | less than @code{pv} reported, because we don't earn any interest | |
17809 | on the return from this investment. Note that @code{pvl} and | |
17810 | @code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}. | |
17811 | ||
17812 | You can give an optional fourth lump-sum argument to @code{pv} | |
17813 | and @code{pvb}; this is handled in exactly the same way as the | |
17814 | fourth argument for @code{fv} and @code{fvb}. | |
17815 | ||
17816 | @kindex b N | |
17817 | @pindex calc-fin-npv | |
17818 | @tindex npv | |
17819 | The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes | |
17820 | the net present value of a series of irregular investments. | |
17821 | The first argument is the interest rate. The second argument is | |
17822 | a vector which represents the expected return from the investment | |
17823 | at the end of each interval. For example, if the rate represents | |
17824 | a yearly interest rate, then the vector elements are the return | |
17825 | from the first year, second year, and so on. | |
17826 | ||
17827 | Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}. | |
17828 | Obviously this function is more interesting when the payments are | |
17829 | not all the same! | |
17830 | ||
17831 | The @code{npv} function can actually have two or more arguments. | |
17832 | Multiple arguments are interpreted in the same way as for the | |
17833 | vector statistical functions like @code{vsum}. | |
17834 | @xref{Single-Variable Statistics}. Basically, if there are several | |
17835 | payment arguments, each either a vector or a plain number, all these | |
17836 | values are collected left-to-right into the complete list of payments. | |
17837 | A numeric prefix argument on the @kbd{b N} command says how many | |
a4231b04 | 17838 | payment values or vectors to take from the stack. |
d7b8e6c6 EZ |
17839 | |
17840 | @kindex I b N | |
17841 | @tindex npvb | |
17842 | The @kbd{I b N} [@code{npvb}] command computes the net present | |
17843 | value where payments occur at the beginning of each interval | |
17844 | rather than at the end. | |
17845 | ||
17846 | @node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions | |
17847 | @subsection Related Financial Functions | |
17848 | ||
17849 | @noindent | |
17850 | The functions in this section are basically inverses of the | |
17851 | present value functions with respect to the various arguments. | |
17852 | ||
17853 | @kindex b M | |
17854 | @pindex calc-fin-pmt | |
17855 | @tindex pmt | |
17856 | The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes | |
17857 | the amount of periodic payment necessary to amortize a loan. | |
17858 | Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the | |
17859 | value of @var{payment} such that @code{pv(@var{rate}, @var{n}, | |
a4231b04 | 17860 | @var{payment}) = @var{amount}}. |
d7b8e6c6 EZ |
17861 | |
17862 | @kindex I b M | |
17863 | @tindex pmtb | |
17864 | The @kbd{I b M} [@code{pmtb}] command does the same computation | |
17865 | but using @code{pvb} instead of @code{pv}. Like @code{pv} and | |
17866 | @code{pvb}, these functions can also take a fourth argument which | |
17867 | represents an initial lump-sum investment. | |
17868 | ||
17869 | @kindex H b M | |
17870 | The @kbd{H b M} key just invokes the @code{fvl} function, which is | |
17871 | the inverse of @code{pvl}. There is no explicit @code{pmtl} function. | |
17872 | ||
17873 | @kindex b # | |
17874 | @pindex calc-fin-nper | |
17875 | @tindex nper | |
17876 | The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes | |
17877 | the number of regular payments necessary to amortize a loan. | |
17878 | Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals | |
17879 | the value of @var{n} such that @code{pv(@var{rate}, @var{n}, | |
17880 | @var{payment}) = @var{amount}}. If @var{payment} is too small | |
17881 | ever to amortize a loan for @var{amount} at interest rate @var{rate}, | |
a4231b04 | 17882 | the @code{nper} function is left in symbolic form. |
d7b8e6c6 EZ |
17883 | |
17884 | @kindex I b # | |
17885 | @tindex nperb | |
17886 | The @kbd{I b #} [@code{nperb}] command does the same computation | |
17887 | but using @code{pvb} instead of @code{pv}. You can give a fourth | |
17888 | lump-sum argument to these functions, but the computation will be | |
a4231b04 | 17889 | rather slow in the four-argument case. |
d7b8e6c6 EZ |
17890 | |
17891 | @kindex H b # | |
17892 | @tindex nperl | |
17893 | The @kbd{H b #} [@code{nperl}] command does the same computation | |
17894 | using @code{pvl}. By exchanging @var{payment} and @var{amount} you | |
17895 | can also get the solution for @code{fvl}. For example, | |
17896 | @code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a | |
a4231b04 | 17897 | bank account earning 8%, it will take nine years to grow to $2000. |
d7b8e6c6 EZ |
17898 | |
17899 | @kindex b T | |
17900 | @pindex calc-fin-rate | |
17901 | @tindex rate | |
17902 | The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes | |
17903 | the rate of return on an investment. This is also an inverse of @code{pv}: | |
17904 | @code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of | |
17905 | @var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) = | |
a4231b04 | 17906 | @var{amount}}. The result is expressed as a formula like @samp{6.3%}. |
d7b8e6c6 EZ |
17907 | |
17908 | @kindex I b T | |
17909 | @kindex H b T | |
17910 | @tindex rateb | |
17911 | @tindex ratel | |
17912 | The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}] | |
17913 | commands solve the analogous equations with @code{pvb} or @code{pvl} | |
17914 | in place of @code{pv}. Also, @code{rate} and @code{rateb} can | |
17915 | accept an optional fourth argument just like @code{pv} and @code{pvb}. | |
17916 | To redo the above example from a different perspective, | |
17917 | @code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an | |
a4231b04 | 17918 | interest rate of 8% in order to double your account in nine years. |
d7b8e6c6 EZ |
17919 | |
17920 | @kindex b I | |
17921 | @pindex calc-fin-irr | |
17922 | @tindex irr | |
17923 | The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the | |
17924 | analogous function to @code{rate} but for net present value. | |
17925 | Its argument is a vector of payments. Thus @code{irr(@var{payments})} | |
17926 | computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0}; | |
17927 | this rate is known as the @dfn{internal rate of return}. | |
17928 | ||
17929 | @kindex I b I | |
17930 | @tindex irrb | |
17931 | The @kbd{I b I} [@code{irrb}] command computes the internal rate of | |
17932 | return assuming payments occur at the beginning of each period. | |
17933 | ||
17934 | @node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions | |
17935 | @subsection Depreciation Functions | |
17936 | ||
17937 | @noindent | |
17938 | The functions in this section calculate @dfn{depreciation}, which is | |
17939 | the amount of value that a possession loses over time. These functions | |
17940 | are characterized by three parameters: @var{cost}, the original cost | |
17941 | of the asset; @var{salvage}, the value the asset will have at the end | |
17942 | of its expected ``useful life''; and @var{life}, the number of years | |
17943 | (or other periods) of the expected useful life. | |
17944 | ||
17945 | There are several methods for calculating depreciation that differ in | |
17946 | the way they spread the depreciation over the lifetime of the asset. | |
17947 | ||
17948 | @kindex b S | |
17949 | @pindex calc-fin-sln | |
17950 | @tindex sln | |
17951 | The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the | |
17952 | ``straight-line'' depreciation. In this method, the asset depreciates | |
17953 | by the same amount every year (or period). For example, | |
17954 | @samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000 | |
17955 | initially and will be worth $2000 after five years; it loses $2000 | |
17956 | per year. | |
17957 | ||
17958 | @kindex b Y | |
17959 | @pindex calc-fin-syd | |
17960 | @tindex syd | |
17961 | The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the | |
17962 | accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation | |
17963 | is higher during the early years of the asset's life. Since the | |
17964 | depreciation is different each year, @kbd{b Y} takes a fourth @var{period} | |
17965 | parameter which specifies which year is requested, from 1 to @var{life}. | |
17966 | If @var{period} is outside this range, the @code{syd} function will | |
17967 | return zero. | |
17968 | ||
17969 | @kindex b D | |
17970 | @pindex calc-fin-ddb | |
17971 | @tindex ddb | |
17972 | The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an | |
17973 | accelerated depreciation using the double-declining balance method. | |
17974 | It also takes a fourth @var{period} parameter. | |
17975 | ||
17976 | For symmetry, the @code{sln} function will accept a @var{period} | |
17977 | parameter as well, although it will ignore its value except that the | |
17978 | return value will as usual be zero if @var{period} is out of range. | |
17979 | ||
a4231b04 | 17980 | For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5}) |
d7b8e6c6 | 17981 | and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$), |
5d67986c | 17982 | ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare |
d7b8e6c6 EZ |
17983 | the three depreciation methods: |
17984 | ||
d7b8e6c6 | 17985 | @example |
5d67986c | 17986 | @group |
d7b8e6c6 EZ |
17987 | [ [ 2000, 3333, 4800 ] |
17988 | [ 2000, 2667, 2880 ] | |
17989 | [ 2000, 2000, 1728 ] | |
17990 | [ 2000, 1333, 592 ] | |
17991 | [ 2000, 667, 0 ] ] | |
d7b8e6c6 | 17992 | @end group |
5d67986c | 17993 | @end example |
d7b8e6c6 EZ |
17994 | |
17995 | @noindent | |
17996 | (Values have been rounded to nearest integers in this figure.) | |
17997 | We see that @code{sln} depreciates by the same amount each year, | |
17998 | @kbd{syd} depreciates more at the beginning and less at the end, | |
17999 | and @kbd{ddb} weights the depreciation even more toward the beginning. | |
18000 | ||
a4231b04 | 18001 | Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]}; |
d7b8e6c6 EZ |
18002 | the total depreciation in any method is (by definition) the |
18003 | difference between the cost and the salvage value. | |
18004 | ||
18005 | @node Definitions of Financial Functions, , Depreciation Functions, Financial Functions | |
18006 | @subsection Definitions | |
18007 | ||
18008 | @noindent | |
18009 | For your reference, here are the actual formulas used to compute | |
18010 | Calc's financial functions. | |
18011 | ||
18012 | Calc will not evaluate a financial function unless the @var{rate} or | |
18013 | @var{n} argument is known. However, @var{payment} or @var{amount} can | |
18014 | be a variable. Calc expands these functions according to the | |
18015 | formulas below for symbolic arguments only when you use the @kbd{a "} | |
18016 | (@code{calc-expand-formula}) command, or when taking derivatives or | |
18017 | integrals or solving equations involving the functions. | |
18018 | ||
18019 | @ifinfo | |
07ce2eb3 | 18020 | These formulas are shown using the conventions of Big display |
d7b8e6c6 EZ |
18021 | mode (@kbd{d B}); for example, the formula for @code{fv} written |
18022 | linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}. | |
18023 | ||
18024 | @example | |
18025 | n | |
18026 | (1 + rate) - 1 | |
18027 | fv(rate, n, pmt) = pmt * --------------- | |
18028 | rate | |
18029 | ||
18030 | n | |
18031 | ((1 + rate) - 1) (1 + rate) | |
18032 | fvb(rate, n, pmt) = pmt * ---------------------------- | |
18033 | rate | |
18034 | ||
18035 | n | |
18036 | fvl(rate, n, pmt) = pmt * (1 + rate) | |
18037 | ||
18038 | -n | |
177c0ea7 | 18039 | 1 - (1 + rate) |
d7b8e6c6 EZ |
18040 | pv(rate, n, pmt) = pmt * ---------------- |
18041 | rate | |
18042 | ||
18043 | -n | |
18044 | (1 - (1 + rate) ) (1 + rate) | |
18045 | pvb(rate, n, pmt) = pmt * ----------------------------- | |
18046 | rate | |
18047 | ||
18048 | -n | |
18049 | pvl(rate, n, pmt) = pmt * (1 + rate) | |
18050 | ||
18051 | -1 -2 -3 | |
18052 | npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate) | |
18053 | ||
18054 | -1 -2 | |
18055 | npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate) | |
18056 | ||
18057 | -n | |
18058 | (amt - x * (1 + rate) ) * rate | |
18059 | pmt(rate, n, amt, x) = ------------------------------- | |
18060 | -n | |
18061 | 1 - (1 + rate) | |
18062 | ||
18063 | -n | |
18064 | (amt - x * (1 + rate) ) * rate | |
18065 | pmtb(rate, n, amt, x) = ------------------------------- | |
18066 | -n | |
18067 | (1 - (1 + rate) ) (1 + rate) | |
18068 | ||
18069 | amt * rate | |
18070 | nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate) | |
18071 | pmt | |
18072 | ||
18073 | amt * rate | |
18074 | nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate) | |
18075 | pmt * (1 + rate) | |
18076 | ||
18077 | amt | |
18078 | nperl(rate, pmt, amt) = - log(---, 1 + rate) | |
18079 | pmt | |
18080 | ||
18081 | 1/n | |
18082 | pmt | |
18083 | ratel(n, pmt, amt) = ------ - 1 | |
18084 | 1/n | |
18085 | amt | |
18086 | ||
18087 | cost - salv | |
18088 | sln(cost, salv, life) = ----------- | |
18089 | life | |
18090 | ||
18091 | (cost - salv) * (life - per + 1) | |
18092 | syd(cost, salv, life, per) = -------------------------------- | |
18093 | life * (life + 1) / 2 | |
18094 | ||
18095 | book * 2 | |
18096 | ddb(cost, salv, life, per) = --------, book = cost - depreciation so far | |
18097 | life | |
18098 | @end example | |
18099 | @end ifinfo | |
18100 | @tex | |
18101 | \turnoffactive | |
18102 | $$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$ | |
18103 | $$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$ | |
18104 | $$ \code{fvl}(r, n, p) = p (1 + r)^n $$ | |
18105 | $$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$ | |
18106 | $$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$ | |
18107 | $$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$ | |
18108 | $$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$ | |
18109 | $$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$ | |
18110 | $$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$ | |
18111 | $$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over | |
18112 | (1 - (1 + r)^{-n}) (1 + r) } $$ | |
18113 | $$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$ | |
18114 | $$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$ | |
18115 | $$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$ | |
18116 | $$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$ | |
18117 | $$ \code{sln}(c, s, l) = { c - s \over l } $$ | |
18118 | $$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$ | |
18119 | $$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$ | |
18120 | @end tex | |
18121 | ||
18122 | @noindent | |
a4231b04 | 18123 | In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted. |
d7b8e6c6 EZ |
18124 | |
18125 | These functions accept any numeric objects, including error forms, | |
18126 | intervals, and even (though not very usefully) complex numbers. The | |
18127 | above formulas specify exactly the behavior of these functions with | |
18128 | all sorts of inputs. | |
18129 | ||
18130 | Note that if the first argument to the @code{log} in @code{nper} is | |
18131 | negative, @code{nper} leaves itself in symbolic form rather than | |
18132 | returning a (financially meaningless) complex number. | |
18133 | ||
18134 | @samp{rate(num, pmt, amt)} solves the equation | |
18135 | @samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R} | |
18136 | (@code{calc-find-root}), with the interval @samp{[.01% .. 100%]} | |
18137 | for an initial guess. The @code{rateb} function is the same except | |
18138 | that it uses @code{pvb}. Note that @code{ratel} can be solved | |
18139 | directly; its formula is shown in the above list. | |
18140 | ||
18141 | Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0} | |
18142 | for @samp{rate}. | |
18143 | ||
18144 | If you give a fourth argument to @code{nper} or @code{nperb}, Calc | |
18145 | will also use @kbd{H a R} to solve the equation using an initial | |
18146 | guess interval of @samp{[0 .. 100]}. | |
18147 | ||
18148 | A fourth argument to @code{fv} simply sums the two components | |
18149 | calculated from the above formulas for @code{fv} and @code{fvl}. | |
18150 | The same is true of @code{fvb}, @code{pv}, and @code{pvb}. | |
18151 | ||
18152 | The @kbd{ddb} function is computed iteratively; the ``book'' value | |
18153 | starts out equal to @var{cost}, and decreases according to the above | |
18154 | formula for the specified number of periods. If the book value | |
18155 | would decrease below @var{salvage}, it only decreases to @var{salvage} | |
18156 | and the depreciation is zero for all subsequent periods. The @code{ddb} | |
18157 | function returns the amount the book value decreased in the specified | |
18158 | period. | |
18159 | ||
d7b8e6c6 EZ |
18160 | @node Binary Functions, , Financial Functions, Arithmetic |
18161 | @section Binary Number Functions | |
18162 | ||
18163 | @noindent | |
18164 | The commands in this chapter all use two-letter sequences beginning with | |
18165 | the @kbd{b} prefix. | |
18166 | ||
18167 | @cindex Binary numbers | |
18168 | The ``binary'' operations actually work regardless of the currently | |
18169 | displayed radix, although their results make the most sense in a radix | |
18170 | like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}} | |
18171 | commands, respectively). You may also wish to enable display of leading | |
18172 | zeros with @kbd{d z}. @xref{Radix Modes}. | |
18173 | ||
18174 | @cindex Word size for binary operations | |
a4231b04 | 18175 | The Calculator maintains a current @dfn{word size} @expr{w}, an |
d7b8e6c6 | 18176 | arbitrary positive or negative integer. For a positive word size, all |
a4231b04 | 18177 | of the binary operations described here operate modulo @expr{2^w}. In |
d7b8e6c6 | 18178 | particular, negative arguments are converted to positive integers modulo |
a4231b04 | 18179 | @expr{2^w} by all binary functions. |
d7b8e6c6 EZ |
18180 | |
18181 | If the word size is negative, binary operations produce 2's complement | |
a4231b04 | 18182 | integers from |
8e04863e | 18183 | @texline @math{-2^{-w-1}} |
a4231b04 JB |
18184 | @infoline @expr{-(2^(-w-1))} |
18185 | to | |
8e04863e | 18186 | @texline @math{2^{-w-1}-1} |
a4231b04 JB |
18187 | @infoline @expr{2^(-w-1)-1} |
18188 | inclusive. Either mode accepts inputs in any range; the sign of | |
18189 | @expr{w} affects only the results produced. | |
d7b8e6c6 EZ |
18190 | |
18191 | @kindex b c | |
18192 | @pindex calc-clip | |
18193 | @tindex clip | |
18194 | The @kbd{b c} (@code{calc-clip}) | |
18195 | [@code{clip}] command can be used to clip a number by reducing it modulo | |
a4231b04 | 18196 | @expr{2^w}. The commands described in this chapter automatically clip |
d7b8e6c6 EZ |
18197 | their results to the current word size. Note that other operations like |
18198 | addition do not use the current word size, since integer addition | |
18199 | generally is not ``binary.'' (However, @pxref{Simplification Modes}, | |
18200 | @code{calc-bin-simplify-mode}.) For example, with a word size of 8 | |
18201 | bits @kbd{b c} converts a number to the range 0 to 255; with a word | |
8e04863e | 18202 | size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127. |
d7b8e6c6 EZ |
18203 | |
18204 | @kindex b w | |
18205 | @pindex calc-word-size | |
18206 | The default word size is 32 bits. All operations except the shifts and | |
18207 | rotates allow you to specify a different word size for that one | |
18208 | operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the | |
18209 | top of stack to the range 0 to 255 regardless of the current word size. | |
18210 | To set the word size permanently, use @kbd{b w} (@code{calc-word-size}). | |
18211 | This command displays a prompt with the current word size; press @key{RET} | |
18212 | immediately to keep this word size, or type a new word size at the prompt. | |
18213 | ||
18214 | When the binary operations are written in symbolic form, they take an | |
18215 | optional second (or third) word-size parameter. When a formula like | |
18216 | @samp{and(a,b)} is finally evaluated, the word size current at that time | |
18217 | will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of | |
8e04863e | 18218 | @mathit{-8} will always be used. A symbolic binary function will be left |
d7b8e6c6 EZ |
18219 | in symbolic form unless the all of its argument(s) are integers or |
18220 | integer-valued floats. | |
18221 | ||
a4231b04 | 18222 | If either or both arguments are modulo forms for which @expr{M} is a |
d7b8e6c6 EZ |
18223 | power of two, that power of two is taken as the word size unless a |
18224 | numeric prefix argument overrides it. The current word size is never | |
18225 | consulted when modulo-power-of-two forms are involved. | |
18226 | ||
18227 | @kindex b a | |
18228 | @pindex calc-and | |
18229 | @tindex and | |
18230 | The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise | |
18231 | AND of the two numbers on the top of the stack. In other words, for each | |
a4231b04 | 18232 | of the @expr{w} binary digits of the two numbers (pairwise), the corresponding |
d7b8e6c6 EZ |
18233 | bit of the result is 1 if and only if both input bits are 1: |
18234 | @samp{and(2#1100, 2#1010) = 2#1000}. | |
18235 | ||
18236 | @kindex b o | |
18237 | @pindex calc-or | |
18238 | @tindex or | |
18239 | The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise | |
18240 | inclusive OR of two numbers. A bit is 1 if either of the input bits, or | |
18241 | both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}. | |
18242 | ||
18243 | @kindex b x | |
18244 | @pindex calc-xor | |
18245 | @tindex xor | |
18246 | The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise | |
18247 | exclusive OR of two numbers. A bit is 1 if exactly one of the input bits | |
18248 | is 1: @samp{xor(2#1100, 2#1010) = 2#0110}. | |
18249 | ||
18250 | @kindex b d | |
18251 | @pindex calc-diff | |
18252 | @tindex diff | |
18253 | The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise | |
18254 | difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))}, | |
18255 | so that @samp{diff(2#1100, 2#1010) = 2#0100}. | |
18256 | ||
18257 | @kindex b n | |
18258 | @pindex calc-not | |
18259 | @tindex not | |
18260 | The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise | |
18261 | NOT of a number. A bit is 1 if the input bit is 0 and vice-versa. | |
18262 | ||
18263 | @kindex b l | |
18264 | @pindex calc-lshift-binary | |
18265 | @tindex lsh | |
18266 | The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a | |
18267 | number left by one bit, or by the number of bits specified in the numeric | |
18268 | prefix argument. A negative prefix argument performs a logical right shift, | |
18269 | in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)} | |
18270 | is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}. | |
18271 | Bits shifted ``off the end,'' according to the current word size, are lost. | |
18272 | ||
18273 | @kindex H b l | |
18274 | @kindex H b r | |
5d67986c RS |
18275 | @ignore |
18276 | @mindex @idots | |
18277 | @end ignore | |
d7b8e6c6 | 18278 | @kindex H b L |
5d67986c RS |
18279 | @ignore |
18280 | @mindex @null | |
18281 | @end ignore | |
d7b8e6c6 | 18282 | @kindex H b R |
5d67986c RS |
18283 | @ignore |
18284 | @mindex @null | |
18285 | @end ignore | |
d7b8e6c6 EZ |
18286 | @kindex H b t |
18287 | The @kbd{H b l} command also does a left shift, but it takes two arguments | |
18288 | from the stack (the value to shift, and, at top-of-stack, the number of | |
18289 | bits to shift). This version interprets the prefix argument just like | |
18290 | the regular binary operations, i.e., as a word size. The Hyperbolic flag | |
18291 | has a similar effect on the rest of the binary shift and rotate commands. | |
18292 | ||
18293 | @kindex b r | |
18294 | @pindex calc-rshift-binary | |
18295 | @tindex rsh | |
18296 | The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a | |
18297 | number right by one bit, or by the number of bits specified in the numeric | |
18298 | prefix argument: @samp{rsh(a,n) = lsh(a,-n)}. | |
18299 | ||
18300 | @kindex b L | |
18301 | @pindex calc-lshift-arith | |
18302 | @tindex ash | |
18303 | The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a | |
18304 | number left. It is analogous to @code{lsh}, except that if the shift | |
18305 | is rightward (the prefix argument is negative), an arithmetic shift | |
18306 | is performed as described below. | |
18307 | ||
18308 | @kindex b R | |
18309 | @pindex calc-rshift-arith | |
18310 | @tindex rash | |
18311 | The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs | |
18312 | an ``arithmetic'' shift to the right, in which the leftmost bit (according | |
18313 | to the current word size) is duplicated rather than shifting in zeros. | |
18314 | This corresponds to dividing by a power of two where the input is interpreted | |
18315 | as a signed, twos-complement number. (The distinction between the @samp{rsh} | |
18316 | and @samp{rash} operations is totally independent from whether the word | |
18317 | size is positive or negative.) With a negative prefix argument, this | |
18318 | performs a standard left shift. | |
18319 | ||
18320 | @kindex b t | |
18321 | @pindex calc-rotate-binary | |
18322 | @tindex rot | |
18323 | The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a | |
18324 | number one bit to the left. The leftmost bit (according to the current | |
18325 | word size) is dropped off the left and shifted in on the right. With a | |
18326 | numeric prefix argument, the number is rotated that many bits to the left | |
18327 | or right. | |
18328 | ||
18329 | @xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that | |
18330 | pack and unpack binary integers into sets. (For example, @kbd{b u} | |
18331 | unpacks the number @samp{2#11001} to the set of bit-numbers | |
18332 | @samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1'' | |
18333 | bits in a binary integer. | |
18334 | ||
18335 | Another interesting use of the set representation of binary integers | |
18336 | is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to | |
5d67986c | 18337 | unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set |
d7b8e6c6 EZ |
18338 | with 31 minus that bit-number; type @kbd{b p} to pack the set back |
18339 | into a binary integer. | |
18340 | ||
18341 | @node Scientific Functions, Matrix Functions, Arithmetic, Top | |
18342 | @chapter Scientific Functions | |
18343 | ||
18344 | @noindent | |
18345 | The functions described here perform trigonometric and other transcendental | |
18346 | calculations. They generally produce floating-point answers correct to the | |
18347 | full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse) | |
18348 | flag keys must be used to get some of these functions from the keyboard. | |
18349 | ||
18350 | @kindex P | |
18351 | @pindex calc-pi | |
18352 | @cindex @code{pi} variable | |
18353 | @vindex pi | |
18354 | @kindex H P | |
18355 | @cindex @code{e} variable | |
18356 | @vindex e | |
18357 | @kindex I P | |
18358 | @cindex @code{gamma} variable | |
18359 | @vindex gamma | |
18360 | @cindex Gamma constant, Euler's | |
18361 | @cindex Euler's gamma constant | |
18362 | @kindex H I P | |
18363 | @cindex @code{phi} variable | |
18364 | @cindex Phi, golden ratio | |
18365 | @cindex Golden ratio | |
28665d46 | 18366 | One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes |
a4231b04 JB |
18367 | the value of @cpi{} (at the current precision) onto the stack. With the |
18368 | Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms. | |
18369 | With the Inverse flag, it pushes Euler's constant | |
8e04863e | 18370 | @texline @math{\gamma} |
a4231b04 JB |
18371 | @infoline @expr{gamma} |
18372 | (about 0.5772). With both Inverse and Hyperbolic, it | |
18373 | pushes the ``golden ratio'' | |
8e04863e | 18374 | @texline @math{\phi} |
a4231b04 JB |
18375 | @infoline @expr{phi} |
18376 | (about 1.618). (At present, Euler's constant is not available | |
d7b8e6c6 EZ |
18377 | to unlimited precision; Calc knows only the first 100 digits.) |
18378 | In Symbolic mode, these commands push the | |
18379 | actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi}, | |
a4231b04 | 18380 | respectively, instead of their values; @pxref{Symbolic Mode}. |
d7b8e6c6 | 18381 | |
5d67986c RS |
18382 | @ignore |
18383 | @mindex Q | |
18384 | @end ignore | |
18385 | @ignore | |
18386 | @mindex I Q | |
18387 | @end ignore | |
d7b8e6c6 EZ |
18388 | @kindex I Q |
18389 | @tindex sqr | |
18390 | The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere; | |
18391 | @pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command | |
18392 | computes the square of the argument. | |
18393 | ||
18394 | @xref{Prefix Arguments}, for a discussion of the effect of numeric | |
18395 | prefix arguments on commands in this chapter which do not otherwise | |
18396 | interpret a prefix argument. | |
18397 | ||
18398 | @menu | |
18399 | * Logarithmic Functions:: | |
18400 | * Trigonometric and Hyperbolic Functions:: | |
18401 | * Advanced Math Functions:: | |
18402 | * Branch Cuts:: | |
18403 | * Random Numbers:: | |
18404 | * Combinatorial Functions:: | |
18405 | * Probability Distribution Functions:: | |
18406 | @end menu | |
18407 | ||
18408 | @node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions | |
18409 | @section Logarithmic Functions | |
18410 | ||
18411 | @noindent | |
18412 | @kindex L | |
18413 | @pindex calc-ln | |
18414 | @tindex ln | |
5d67986c RS |
18415 | @ignore |
18416 | @mindex @null | |
18417 | @end ignore | |
d7b8e6c6 EZ |
18418 | @kindex I E |
18419 | The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural | |
18420 | logarithm of the real or complex number on the top of the stack. With | |
18421 | the Inverse flag it computes the exponential function instead, although | |
18422 | this is redundant with the @kbd{E} command. | |
18423 | ||
18424 | @kindex E | |
18425 | @pindex calc-exp | |
18426 | @tindex exp | |
5d67986c RS |
18427 | @ignore |
18428 | @mindex @null | |
18429 | @end ignore | |
d7b8e6c6 EZ |
18430 | @kindex I L |
18431 | The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the | |
a4231b04 | 18432 | exponential, i.e., @expr{e} raised to the power of the number on the stack. |
d7b8e6c6 EZ |
18433 | The meanings of the Inverse and Hyperbolic flags follow from those for |
18434 | the @code{calc-ln} command. | |
18435 | ||
18436 | @kindex H L | |
18437 | @kindex H E | |
18438 | @pindex calc-log10 | |
18439 | @tindex log10 | |
18440 | @tindex exp10 | |
5d67986c RS |
18441 | @ignore |
18442 | @mindex @null | |
18443 | @end ignore | |
d7b8e6c6 | 18444 | @kindex H I L |
5d67986c RS |
18445 | @ignore |
18446 | @mindex @null | |
18447 | @end ignore | |
d7b8e6c6 EZ |
18448 | @kindex H I E |
18449 | The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common | |
18450 | (base-10) logarithm of a number. (With the Inverse flag [@code{exp10}], | |
18451 | it raises ten to a given power.) Note that the common logarithm of a | |
18452 | complex number is computed by taking the natural logarithm and dividing | |
a4231b04 | 18453 | by |
8e04863e | 18454 | @texline @math{\ln10}. |
a4231b04 | 18455 | @infoline @expr{ln(10)}. |
d7b8e6c6 EZ |
18456 | |
18457 | @kindex B | |
18458 | @kindex I B | |
18459 | @pindex calc-log | |
18460 | @tindex log | |
18461 | @tindex alog | |
18462 | The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm | |
18463 | to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since | |
8e04863e | 18464 | @texline @math{2^{10} = 1024}. |
a4231b04 JB |
18465 | @infoline @expr{2^10 = 1024}. |
18466 | In certain cases like @samp{log(3,9)}, the result | |
18467 | will be either @expr{1:2} or @expr{0.5} depending on the current Fraction | |
07ce2eb3 | 18468 | mode setting. With the Inverse flag [@code{alog}], this command is |
d7b8e6c6 EZ |
18469 | similar to @kbd{^} except that the order of the arguments is reversed. |
18470 | ||
18471 | @kindex f I | |
18472 | @pindex calc-ilog | |
18473 | @tindex ilog | |
18474 | The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the | |
18475 | integer logarithm of a number to any base. The number and the base must | |
18476 | themselves be positive integers. This is the true logarithm, rounded | |
a4231b04 | 18477 | down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the |
d7b8e6c6 EZ |
18478 | range from 1000 to 9999. If both arguments are positive integers, exact |
18479 | integer arithmetic is used; otherwise, this is equivalent to | |
18480 | @samp{floor(log(x,b))}. | |
18481 | ||
18482 | @kindex f E | |
18483 | @pindex calc-expm1 | |
18484 | @tindex expm1 | |
18485 | The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes | |
8e04863e | 18486 | @texline @math{e^x - 1}, |
a4231b04 JB |
18487 | @infoline @expr{exp(x)-1}, |
18488 | but using an algorithm that produces a more accurate | |
18489 | answer when the result is close to zero, i.e., when | |
8e04863e | 18490 | @texline @math{e^x} |
a4231b04 JB |
18491 | @infoline @expr{exp(x)} |
18492 | is close to one. | |
d7b8e6c6 EZ |
18493 | |
18494 | @kindex f L | |
18495 | @pindex calc-lnp1 | |
18496 | @tindex lnp1 | |
18497 | The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes | |
8e04863e | 18498 | @texline @math{\ln(x+1)}, |
a4231b04 JB |
18499 | @infoline @expr{ln(x+1)}, |
18500 | producing a more accurate answer when @expr{x} is close to zero. | |
d7b8e6c6 EZ |
18501 | |
18502 | @node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions | |
18503 | @section Trigonometric/Hyperbolic Functions | |
18504 | ||
18505 | @noindent | |
18506 | @kindex S | |
18507 | @pindex calc-sin | |
18508 | @tindex sin | |
18509 | The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine | |
18510 | of an angle or complex number. If the input is an HMS form, it is interpreted | |
18511 | as degrees-minutes-seconds; otherwise, the input is interpreted according | |
18512 | to the current angular mode. It is best to use Radians mode when operating | |
a4231b04 | 18513 | on complex numbers. |
d7b8e6c6 EZ |
18514 | |
18515 | Calc's ``units'' mechanism includes angular units like @code{deg}, | |
18516 | @code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated | |
18517 | all the time, the @kbd{u s} (@code{calc-simplify-units}) command will | |
18518 | simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless | |
18519 | of the current angular mode. @xref{Basic Operations on Units}. | |
18520 | ||
18521 | Also, the symbolic variable @code{pi} is not ordinarily recognized in | |
18522 | arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but | |
18523 | the @kbd{a s} (@code{calc-simplify}) command recognizes many such | |
07ce2eb3 | 18524 | formulas when the current angular mode is Radians @emph{and} Symbolic |
d7b8e6c6 EZ |
18525 | mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}. |
18526 | @xref{Symbolic Mode}. Beware, this simplification occurs even if you | |
18527 | have stored a different value in the variable @samp{pi}; this is one | |
18528 | reason why changing built-in variables is a bad idea. Arguments of | |
a4231b04 JB |
18529 | the form @expr{x} plus a multiple of @cpiover{2} are also simplified. |
18530 | Calc includes similar formulas for @code{cos} and @code{tan}. | |
d7b8e6c6 EZ |
18531 | |
18532 | The @kbd{a s} command knows all angles which are integer multiples of | |
07ce2eb3 | 18533 | @cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode, |
d7b8e6c6 EZ |
18534 | analogous simplifications occur for integer multiples of 15 or 18 |
18535 | degrees, and for arguments plus multiples of 90 degrees. | |
18536 | ||
18537 | @kindex I S | |
18538 | @pindex calc-arcsin | |
18539 | @tindex arcsin | |
18540 | With the Inverse flag, @code{calc-sin} computes an arcsine. This is also | |
18541 | available as the @code{calc-arcsin} command or @code{arcsin} algebraic | |
18542 | function. The returned argument is converted to degrees, radians, or HMS | |
18543 | notation depending on the current angular mode. | |
18544 | ||
18545 | @kindex H S | |
18546 | @pindex calc-sinh | |
18547 | @tindex sinh | |
18548 | @kindex H I S | |
18549 | @pindex calc-arcsinh | |
18550 | @tindex arcsinh | |
18551 | With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic | |
18552 | sine, also available as @code{calc-sinh} [@code{sinh}]. With the | |
18553 | Hyperbolic and Inverse flags, it computes the hyperbolic arcsine | |
18554 | (@code{calc-arcsinh}) [@code{arcsinh}]. | |
18555 | ||
18556 | @kindex C | |
18557 | @pindex calc-cos | |
18558 | @tindex cos | |
5d67986c RS |
18559 | @ignore |
18560 | @mindex @idots | |
18561 | @end ignore | |
d7b8e6c6 EZ |
18562 | @kindex I C |
18563 | @pindex calc-arccos | |
5d67986c RS |
18564 | @ignore |
18565 | @mindex @null | |
18566 | @end ignore | |
d7b8e6c6 | 18567 | @tindex arccos |
5d67986c RS |
18568 | @ignore |
18569 | @mindex @null | |
18570 | @end ignore | |
d7b8e6c6 EZ |
18571 | @kindex H C |
18572 | @pindex calc-cosh | |
5d67986c RS |
18573 | @ignore |
18574 | @mindex @null | |
18575 | @end ignore | |
d7b8e6c6 | 18576 | @tindex cosh |
5d67986c RS |
18577 | @ignore |
18578 | @mindex @null | |
18579 | @end ignore | |
d7b8e6c6 EZ |
18580 | @kindex H I C |
18581 | @pindex calc-arccosh | |
5d67986c RS |
18582 | @ignore |
18583 | @mindex @null | |
18584 | @end ignore | |
d7b8e6c6 | 18585 | @tindex arccosh |
5d67986c RS |
18586 | @ignore |
18587 | @mindex @null | |
18588 | @end ignore | |
d7b8e6c6 EZ |
18589 | @kindex T |
18590 | @pindex calc-tan | |
5d67986c RS |
18591 | @ignore |
18592 | @mindex @null | |
18593 | @end ignore | |
d7b8e6c6 | 18594 | @tindex tan |
5d67986c RS |
18595 | @ignore |
18596 | @mindex @null | |
18597 | @end ignore | |
d7b8e6c6 EZ |
18598 | @kindex I T |
18599 | @pindex calc-arctan | |
5d67986c RS |
18600 | @ignore |
18601 | @mindex @null | |
18602 | @end ignore | |
d7b8e6c6 | 18603 | @tindex arctan |
5d67986c RS |
18604 | @ignore |
18605 | @mindex @null | |
18606 | @end ignore | |
d7b8e6c6 EZ |
18607 | @kindex H T |
18608 | @pindex calc-tanh | |
5d67986c RS |
18609 | @ignore |
18610 | @mindex @null | |
18611 | @end ignore | |
d7b8e6c6 | 18612 | @tindex tanh |
5d67986c RS |
18613 | @ignore |
18614 | @mindex @null | |
18615 | @end ignore | |
d7b8e6c6 EZ |
18616 | @kindex H I T |
18617 | @pindex calc-arctanh | |
5d67986c RS |
18618 | @ignore |
18619 | @mindex @null | |
18620 | @end ignore | |
d7b8e6c6 EZ |
18621 | @tindex arctanh |
18622 | The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine | |
18623 | of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}] | |
18624 | computes the tangent, along with all the various inverse and hyperbolic | |
18625 | variants of these functions. | |
18626 | ||
18627 | @kindex f T | |
18628 | @pindex calc-arctan2 | |
18629 | @tindex arctan2 | |
18630 | The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two | |
18631 | numbers from the stack and computes the arc tangent of their ratio. The | |
8e04863e | 18632 | result is in the full range from @mathit{-180} (exclusive) to @mathit{+180} |
d7b8e6c6 EZ |
18633 | (inclusive) degrees, or the analogous range in radians. A similar |
18634 | result would be obtained with @kbd{/} followed by @kbd{I T}, but the | |
8e04863e | 18635 | value would only be in the range from @mathit{-90} to @mathit{+90} degrees |
d7b8e6c6 EZ |
18636 | since the division loses information about the signs of the two |
18637 | components, and an error might result from an explicit division by zero | |
18638 | which @code{arctan2} would avoid. By (arbitrary) definition, | |
18639 | @samp{arctan2(0,0)=0}. | |
18640 | ||
18641 | @pindex calc-sincos | |
5d67986c RS |
18642 | @ignore |
18643 | @starindex | |
18644 | @end ignore | |
d7b8e6c6 | 18645 | @tindex sincos |
5d67986c RS |
18646 | @ignore |
18647 | @starindex | |
18648 | @end ignore | |
18649 | @ignore | |
18650 | @mindex arc@idots | |
18651 | @end ignore | |
d7b8e6c6 EZ |
18652 | @tindex arcsincos |
18653 | The @code{calc-sincos} [@code{sincos}] command computes the sine and | |
18654 | cosine of a number, returning them as a vector of the form | |
18655 | @samp{[@var{cos}, @var{sin}]}. | |
18656 | With the Inverse flag [@code{arcsincos}], this command takes a two-element | |
18657 | vector as an argument and computes @code{arctan2} of the elements. | |
a4231b04 | 18658 | (This command does not accept the Hyperbolic flag.) |
d7b8e6c6 | 18659 | |
31c912fc JB |
18660 | @pindex calc-sec |
18661 | @tindex sec | |
18662 | @pindex calc-csc | |
18663 | @tindex csc | |
18664 | @pindex calc-cot | |
18665 | @tindex cot | |
18666 | @pindex calc-sech | |
18667 | @tindex sech | |
18668 | @pindex calc-csch | |
18669 | @tindex csch | |
18670 | @pindex calc-coth | |
18671 | @tindex coth | |
18672 | The remaining trigonometric functions, @code{calc-sec} [@code{sec}], | |
18673 | @code{calc-csc} [@code{csc}] and @code{calc-sec} [@code{sec}], are also | |
18674 | available. With the Hyperbolic flag, these compute their hyperbolic | |
18675 | counterparts, which are also available separately as @code{calc-sech} | |
18676 | [@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-sech} | |
18677 | [@code{sech}]. (These commmands do not accept the Inverse flag.) | |
18678 | ||
d7b8e6c6 EZ |
18679 | @node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions |
18680 | @section Advanced Mathematical Functions | |
18681 | ||
18682 | @noindent | |
18683 | Calc can compute a variety of less common functions that arise in | |
18684 | various branches of mathematics. All of the functions described in | |
18685 | this section allow arbitrary complex arguments and, except as noted, | |
18686 | will work to arbitrarily large precisions. They can not at present | |
18687 | handle error forms or intervals as arguments. | |
18688 | ||
18689 | NOTE: These functions are still experimental. In particular, their | |
18690 | accuracy is not guaranteed in all domains. It is advisable to set the | |
18691 | current precision comfortably higher than you actually need when | |
18692 | using these functions. Also, these functions may be impractically | |
18693 | slow for some values of the arguments. | |
18694 | ||
18695 | @kindex f g | |
18696 | @pindex calc-gamma | |
18697 | @tindex gamma | |
18698 | The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler | |
18699 | gamma function. For positive integer arguments, this is related to the | |
18700 | factorial function: @samp{gamma(n+1) = fact(n)}. For general complex | |
18701 | arguments the gamma function can be defined by the following definite | |
a4231b04 | 18702 | integral: |
8e04863e | 18703 | @texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}. |
a4231b04 | 18704 | @infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}. |
d7b8e6c6 EZ |
18705 | (The actual implementation uses far more efficient computational methods.) |
18706 | ||
18707 | @kindex f G | |
18708 | @tindex gammaP | |
5d67986c RS |
18709 | @ignore |
18710 | @mindex @idots | |
18711 | @end ignore | |
d7b8e6c6 | 18712 | @kindex I f G |
5d67986c RS |
18713 | @ignore |
18714 | @mindex @null | |
18715 | @end ignore | |
d7b8e6c6 | 18716 | @kindex H f G |
5d67986c RS |
18717 | @ignore |
18718 | @mindex @null | |
18719 | @end ignore | |
d7b8e6c6 EZ |
18720 | @kindex H I f G |
18721 | @pindex calc-inc-gamma | |
5d67986c RS |
18722 | @ignore |
18723 | @mindex @null | |
18724 | @end ignore | |
d7b8e6c6 | 18725 | @tindex gammaQ |
5d67986c RS |
18726 | @ignore |
18727 | @mindex @null | |
18728 | @end ignore | |
d7b8e6c6 | 18729 | @tindex gammag |
5d67986c RS |
18730 | @ignore |
18731 | @mindex @null | |
18732 | @end ignore | |
d7b8e6c6 EZ |
18733 | @tindex gammaG |
18734 | The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes | |
18735 | the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by | |
a4231b04 | 18736 | the integral, |
8e04863e | 18737 | @texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}. |
a4231b04 JB |
18738 | @infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}. |
18739 | This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the | |
d7b8e6c6 EZ |
18740 | definition of the normal gamma function). |
18741 | ||
18742 | Several other varieties of incomplete gamma function are defined. | |
a4231b04 | 18743 | The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by |
d7b8e6c6 EZ |
18744 | some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command. |
18745 | You can think of this as taking the other half of the integral, from | |
a4231b04 | 18746 | @expr{x} to infinity. |
d7b8e6c6 EZ |
18747 | |
18748 | @ifinfo | |
a4231b04 JB |
18749 | The functions corresponding to the integrals that define @expr{P(a,x)} |
18750 | and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)} | |
18751 | factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively | |
18752 | (where @expr{g} and @expr{G} represent the lower- and upper-case Greek | |
d7b8e6c6 EZ |
18753 | letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}] |
18754 | and @kbd{H I f G} [@code{gammaG}] commands. | |
18755 | @end ifinfo | |
18756 | @tex | |
18757 | \turnoffactive | |
18758 | The functions corresponding to the integrals that define $P(a,x)$ | |
18759 | and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$ | |
18760 | factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively. | |
18761 | You can obtain these using the \kbd{H f G} [\code{gammag}] and | |
18762 | \kbd{I H f G} [\code{gammaG}] commands. | |
18763 | @end tex | |
18764 | ||
18765 | @kindex f b | |
18766 | @pindex calc-beta | |
18767 | @tindex beta | |
18768 | The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the | |
18769 | Euler beta function, which is defined in terms of the gamma function as | |
8e04863e | 18770 | @texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)}, |
a4231b04 JB |
18771 | @infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)}, |
18772 | or by | |
8e04863e | 18773 | @texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}. |
a4231b04 | 18774 | @infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}. |
d7b8e6c6 EZ |
18775 | |
18776 | @kindex f B | |
18777 | @kindex H f B | |
18778 | @pindex calc-inc-beta | |
18779 | @tindex betaI | |
18780 | @tindex betaB | |
18781 | The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes | |
a4231b04 | 18782 | the incomplete beta function @expr{I(x,a,b)}. It is defined by |
8e04863e | 18783 | @texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}. |
a4231b04 | 18784 | @infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}. |
d7b8e6c6 EZ |
18785 | Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding |
18786 | un-normalized version [@code{betaB}]. | |
18787 | ||
18788 | @kindex f e | |
18789 | @kindex I f e | |
18790 | @pindex calc-erf | |
18791 | @tindex erf | |
18792 | @tindex erfc | |
18793 | The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the | |
a4231b04 | 18794 | error function |
8e04863e | 18795 | @texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}. |
a4231b04 | 18796 | @infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}. |
d7b8e6c6 EZ |
18797 | The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}] |
18798 | is the corresponding integral from @samp{x} to infinity; the sum | |
8e04863e | 18799 | @texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}. |
a4231b04 | 18800 | @infoline @expr{erf(x) + erfc(x) = 1}. |
d7b8e6c6 EZ |
18801 | |
18802 | @kindex f j | |
18803 | @kindex f y | |
18804 | @pindex calc-bessel-J | |
18805 | @pindex calc-bessel-Y | |
18806 | @tindex besJ | |
18807 | @tindex besY | |
18808 | The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y} | |
18809 | (@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel | |
18810 | functions of the first and second kinds, respectively. | |
18811 | In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter | |
a4231b04 | 18812 | @expr{n} is often an integer, but is not required to be one. |
d7b8e6c6 EZ |
18813 | Calc's implementation of the Bessel functions currently limits the |
18814 | precision to 8 digits, and may not be exact even to that precision. | |
a4231b04 | 18815 | Use with care! |
d7b8e6c6 EZ |
18816 | |
18817 | @node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions | |
18818 | @section Branch Cuts and Principal Values | |
18819 | ||
18820 | @noindent | |
18821 | @cindex Branch cuts | |
18822 | @cindex Principal values | |
18823 | All of the logarithmic, trigonometric, and other scientific functions are | |
18824 | defined for complex numbers as well as for reals. | |
18825 | This section describes the values | |
18826 | returned in cases where the general result is a family of possible values. | |
18827 | Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language}, | |
18828 | second edition, in these matters. This section will describe each | |
18829 | function briefly; for a more detailed discussion (including some nifty | |
18830 | diagrams), consult Steele's book. | |
18831 | ||
18832 | Note that the branch cuts for @code{arctan} and @code{arctanh} were | |
18833 | changed between the first and second editions of Steele. Versions of | |
18834 | Calc starting with 2.00 follow the second edition. | |
18835 | ||
18836 | The new branch cuts exactly match those of the HP-28/48 calculators. | |
18837 | They also match those of Mathematica 1.2, except that Mathematica's | |
18838 | @code{arctan} cut is always in the right half of the complex plane, | |
18839 | and its @code{arctanh} cut is always in the top half of the plane. | |
18840 | Calc's cuts are continuous with quadrants I and III for @code{arctan}, | |
18841 | or II and IV for @code{arctanh}. | |
18842 | ||
18843 | Note: The current implementations of these functions with complex arguments | |
18844 | are designed with proper behavior around the branch cuts in mind, @emph{not} | |
18845 | efficiency or accuracy. You may need to increase the floating precision | |
18846 | and wait a while to get suitable answers from them. | |
18847 | ||
a4231b04 JB |
18848 | For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive |
18849 | or zero, the result is close to the @expr{+i} axis. For @expr{b} small and | |
18850 | negative, the result is close to the @expr{-i} axis. The result always lies | |
d7b8e6c6 EZ |
18851 | in the right half of the complex plane. |
18852 | ||
18853 | For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}. | |
18854 | The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}. | |
18855 | Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the | |
18856 | negative real axis. | |
18857 | ||
18858 | The following table describes these branch cuts in another way. | |
a4231b04 JB |
18859 | If the real and imaginary parts of @expr{z} are as shown, then |
18860 | the real and imaginary parts of @expr{f(z)} will be as shown. | |
d7b8e6c6 EZ |
18861 | Here @code{eps} stands for a small positive value; each |
18862 | occurrence of @code{eps} may stand for a different small value. | |
18863 | ||
18864 | @smallexample | |
18865 | z sqrt(z) ln(z) | |
18866 | ---------------------------------------- | |
18867 | +, 0 +, 0 any, 0 | |
18868 | -, 0 0, + any, pi | |
18869 | -, +eps +eps, + +eps, + | |
18870 | -, -eps +eps, - +eps, - | |
18871 | @end smallexample | |
18872 | ||
18873 | For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}. | |
18874 | One interesting consequence of this is that @samp{(-8)^1:3} does | |
8e04863e | 18875 | not evaluate to @mathit{-2} as you might expect, but to the complex |
a4231b04 | 18876 | number @expr{(1., 1.732)}. Both of these are valid cube roots |
8e04863e | 18877 | of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps |
d7b8e6c6 EZ |
18878 | less-obvious root for the sake of mathematical consistency. |
18879 | ||
18880 | For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}. | |
8e04863e | 18881 | The branch cuts are on the real axis, less than @mathit{-1} and greater than 1. |
d7b8e6c6 EZ |
18882 | |
18883 | For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))}, | |
18884 | or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on | |
8e04863e | 18885 | the real axis, less than @mathit{-1} and greater than 1. |
d7b8e6c6 EZ |
18886 | |
18887 | For @samp{arctan(z)}: This is defined by | |
18888 | @samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the | |
a4231b04 | 18889 | imaginary axis, below @expr{-i} and above @expr{i}. |
d7b8e6c6 EZ |
18890 | |
18891 | For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}. | |
a4231b04 JB |
18892 | The branch cuts are on the imaginary axis, below @expr{-i} and |
18893 | above @expr{i}. | |
d7b8e6c6 EZ |
18894 | |
18895 | For @samp{arccosh(z)}: This is defined by | |
18896 | @samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the | |
18897 | real axis less than 1. | |
18898 | ||
18899 | For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}. | |
8e04863e | 18900 | The branch cuts are on the real axis, less than @mathit{-1} and greater than 1. |
d7b8e6c6 EZ |
18901 | |
18902 | The following tables for @code{arcsin}, @code{arccos}, and | |
07ce2eb3 | 18903 | @code{arctan} assume the current angular mode is Radians. The |
d7b8e6c6 EZ |
18904 | hyperbolic functions operate independently of the angular mode. |
18905 | ||
18906 | @smallexample | |
18907 | z arcsin(z) arccos(z) | |
18908 | ------------------------------------------------------- | |
18909 | (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0 | |
18910 | (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps | |
18911 | (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps | |
18912 | <-1, 0 -pi/2, + pi, - | |
18913 | <-1, +eps -pi/2 + eps, + pi - eps, - | |
18914 | <-1, -eps -pi/2 + eps, - pi - eps, + | |
18915 | >1, 0 pi/2, - 0, + | |
18916 | >1, +eps pi/2 - eps, + +eps, - | |
18917 | >1, -eps pi/2 - eps, - +eps, + | |
18918 | @end smallexample | |
18919 | ||
18920 | @smallexample | |
18921 | z arccosh(z) arctanh(z) | |
18922 | ----------------------------------------------------- | |
18923 | (-1..1), 0 0, (0..pi) any, 0 | |
18924 | (-1..1), +eps +eps, (0..pi) any, +eps | |
18925 | (-1..1), -eps +eps, (-pi..0) any, -eps | |
18926 | <-1, 0 +, pi -, pi/2 | |
18927 | <-1, +eps +, pi - eps -, pi/2 - eps | |
18928 | <-1, -eps +, -pi + eps -, -pi/2 + eps | |
18929 | >1, 0 +, 0 +, -pi/2 | |
18930 | >1, +eps +, +eps +, pi/2 - eps | |
18931 | >1, -eps +, -eps +, -pi/2 + eps | |
18932 | @end smallexample | |
18933 | ||
18934 | @smallexample | |
18935 | z arcsinh(z) arctan(z) | |
18936 | ----------------------------------------------------- | |
18937 | 0, (-1..1) 0, (-pi/2..pi/2) 0, any | |
18938 | 0, <-1 -, -pi/2 -pi/2, - | |
18939 | +eps, <-1 +, -pi/2 + eps pi/2 - eps, - | |
18940 | -eps, <-1 -, -pi/2 + eps -pi/2 + eps, - | |
18941 | 0, >1 +, pi/2 pi/2, + | |
18942 | +eps, >1 +, pi/2 - eps pi/2 - eps, + | |
18943 | -eps, >1 -, pi/2 - eps -pi/2 + eps, + | |
18944 | @end smallexample | |
18945 | ||
18946 | Finally, the following identities help to illustrate the relationship | |
18947 | between the complex trigonometric and hyperbolic functions. They | |
18948 | are valid everywhere, including on the branch cuts. | |
18949 | ||
18950 | @smallexample | |
18951 | sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z) | |
18952 | cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z) | |
18953 | tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z) | |
18954 | sinh(i*z) = i*sin(z) cosh(i*z) = cos(z) | |
18955 | @end smallexample | |
18956 | ||
18957 | The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined | |
18958 | for general complex arguments, but their branch cuts and principal values | |
18959 | are not rigorously specified at present. | |
18960 | ||
18961 | @node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions | |
18962 | @section Random Numbers | |
18963 | ||
18964 | @noindent | |
18965 | @kindex k r | |
18966 | @pindex calc-random | |
18967 | @tindex random | |
18968 | The @kbd{k r} (@code{calc-random}) [@code{random}] command produces | |
18969 | random numbers of various sorts. | |
18970 | ||
a4231b04 JB |
18971 | Given a positive numeric prefix argument @expr{M}, it produces a random |
18972 | integer @expr{N} in the range | |
8e04863e | 18973 | @texline @math{0 \le N < M}. |
a4231b04 JB |
18974 | @infoline @expr{0 <= N < M}. |
18975 | Each of the @expr{M} values appears with equal probability. | |
d7b8e6c6 EZ |
18976 | |
18977 | With no numeric prefix argument, the @kbd{k r} command takes its argument | |
a4231b04 JB |
18978 | from the stack instead. Once again, if this is a positive integer @expr{M} |
18979 | the result is a random integer less than @expr{M}. However, note that | |
18980 | while numeric prefix arguments are limited to six digits or so, an @expr{M} | |
18981 | taken from the stack can be arbitrarily large. If @expr{M} is negative, | |
18982 | the result is a random integer in the range | |
8e04863e | 18983 | @texline @math{M < N \le 0}. |
a4231b04 JB |
18984 | @infoline @expr{M < N <= 0}. |
18985 | ||
18986 | If the value on the stack is a floating-point number @expr{M}, the result | |
18987 | is a random floating-point number @expr{N} in the range | |
8e04863e | 18988 | @texline @math{0 \le N < M} |
a4231b04 JB |
18989 | @infoline @expr{0 <= N < M} |
18990 | or | |
8e04863e | 18991 | @texline @math{M < N \le 0}, |
a4231b04 JB |
18992 | @infoline @expr{M < N <= 0}, |
18993 | according to the sign of @expr{M}. | |
18994 | ||
18995 | If @expr{M} is zero, the result is a Gaussian-distributed random real | |
d7b8e6c6 EZ |
18996 | number; the distribution has a mean of zero and a standard deviation |
18997 | of one. The algorithm used generates random numbers in pairs; thus, | |
18998 | every other call to this function will be especially fast. | |
18999 | ||
a4231b04 | 19000 | If @expr{M} is an error form |
8e04863e | 19001 | @texline @math{m} @code{+/-} @math{\sigma} |
a4231b04 JB |
19002 | @infoline @samp{m +/- s} |
19003 | where @var{m} and | |
8e04863e | 19004 | @texline @math{\sigma} |
a4231b04 JB |
19005 | @infoline @var{s} |
19006 | are both real numbers, the result uses a Gaussian distribution with mean | |
19007 | @var{m} and standard deviation | |
8e04863e | 19008 | @texline @math{\sigma}. |
bd712b70 | 19009 | @infoline @var{s}. |
d7b8e6c6 | 19010 | |
a4231b04 | 19011 | If @expr{M} is an interval form, the lower and upper bounds specify the |
d7b8e6c6 EZ |
19012 | acceptable limits of the random numbers. If both bounds are integers, |
19013 | the result is a random integer in the specified range. If either bound | |
19014 | is floating-point, the result is a random real number in the specified | |
19015 | range. If the interval is open at either end, the result will be sure | |
19016 | not to equal that end value. (This makes a big difference for integer | |
19017 | intervals, but for floating-point intervals it's relatively minor: | |
19018 | with a precision of 6, @samp{random([1.0..2.0))} will return any of one | |
19019 | million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may | |
19020 | additionally return 2.00000, but the probability of this happening is | |
19021 | extremely small.) | |
19022 | ||
a4231b04 | 19023 | If @expr{M} is a vector, the result is one element taken at random from |
d7b8e6c6 EZ |
19024 | the vector. All elements of the vector are given equal probabilities. |
19025 | ||
19026 | @vindex RandSeed | |
19027 | The sequence of numbers produced by @kbd{k r} is completely random by | |
19028 | default, i.e., the sequence is seeded each time you start Calc using | |
19029 | the current time and other information. You can get a reproducible | |
19030 | sequence by storing a particular ``seed value'' in the Calc variable | |
19031 | @code{RandSeed}. Any integer will do for a seed; integers of from 1 | |
19032 | to 12 digits are good. If you later store a different integer into | |
19033 | @code{RandSeed}, Calc will switch to a different pseudo-random | |
19034 | sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself | |
19035 | from the current time. If you store the same integer that you used | |
19036 | before back into @code{RandSeed}, you will get the exact same sequence | |
19037 | of random numbers as before. | |
19038 | ||
19039 | @pindex calc-rrandom | |
19040 | The @code{calc-rrandom} command (not on any key) produces a random real | |
19041 | number between zero and one. It is equivalent to @samp{random(1.0)}. | |
19042 | ||
19043 | @kindex k a | |
19044 | @pindex calc-random-again | |
19045 | The @kbd{k a} (@code{calc-random-again}) command produces another random | |
a4231b04 | 19046 | number, re-using the most recent value of @expr{M}. With a numeric |
d7b8e6c6 | 19047 | prefix argument @var{n}, it produces @var{n} more random numbers using |
a4231b04 | 19048 | that value of @expr{M}. |
d7b8e6c6 EZ |
19049 | |
19050 | @kindex k h | |
19051 | @pindex calc-shuffle | |
19052 | @tindex shuffle | |
19053 | The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several | |
19054 | random values with no duplicates. The value on the top of the stack | |
19055 | specifies the set from which the random values are drawn, and may be any | |
a4231b04 | 19056 | of the @expr{M} formats described above. The numeric prefix argument |
d7b8e6c6 EZ |
19057 | gives the length of the desired list. (If you do not provide a numeric |
19058 | prefix argument, the length of the list is taken from the top of the | |
a4231b04 | 19059 | stack, and @expr{M} from second-to-top.) |
d7b8e6c6 | 19060 | |
a4231b04 | 19061 | If @expr{M} is a floating-point number, zero, or an error form (so |
d7b8e6c6 EZ |
19062 | that the random values are being drawn from the set of real numbers) |
19063 | there is little practical difference between using @kbd{k h} and using | |
19064 | @kbd{k r} several times. But if the set of possible values consists | |
19065 | of just a few integers, or the elements of a vector, then there is | |
19066 | a very real chance that multiple @kbd{k r}'s will produce the same | |
19067 | number more than once. The @kbd{k h} command produces a vector whose | |
19068 | elements are always distinct. (Actually, there is a slight exception: | |
a4231b04 JB |
19069 | If @expr{M} is a vector, no given vector element will be drawn more |
19070 | than once, but if several elements of @expr{M} are equal, they may | |
d7b8e6c6 EZ |
19071 | each make it into the result vector.) |
19072 | ||
19073 | One use of @kbd{k h} is to rearrange a list at random. This happens | |
19074 | if the prefix argument is equal to the number of values in the list: | |
19075 | @kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list | |
19076 | @samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument | |
19077 | @var{n} is negative it is replaced by the size of the set represented | |
a4231b04 | 19078 | by @expr{M}. Naturally, this is allowed only when @expr{M} specifies |
d7b8e6c6 EZ |
19079 | a small discrete set of possibilities. |
19080 | ||
19081 | To do the equivalent of @kbd{k h} but with duplications allowed, | |
a4231b04 JB |
19082 | given @expr{M} on the stack and with @var{n} just entered as a numeric |
19083 | prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use | |
d7b8e6c6 EZ |
19084 | @kbd{V M k r} to ``map'' the normal @kbd{k r} function over the |
19085 | elements of this vector. @xref{Matrix Functions}. | |
19086 | ||
19087 | @menu | |
19088 | * Random Number Generator:: (Complete description of Calc's algorithm) | |
19089 | @end menu | |
19090 | ||
19091 | @node Random Number Generator, , Random Numbers, Random Numbers | |
19092 | @subsection Random Number Generator | |
19093 | ||
19094 | Calc's random number generator uses several methods to ensure that | |
19095 | the numbers it produces are highly random. Knuth's @emph{Art of | |
19096 | Computer Programming}, Volume II, contains a thorough description | |
19097 | of the theory of random number generators and their measurement and | |
19098 | characterization. | |
19099 | ||
19100 | If @code{RandSeed} has no stored value, Calc calls Emacs' built-in | |
19101 | @code{random} function to get a stream of random numbers, which it | |
19102 | then treats in various ways to avoid problems inherent in the simple | |
19103 | random number generators that many systems use to implement @code{random}. | |
19104 | ||
19105 | When Calc's random number generator is first invoked, it ``seeds'' | |
19106 | the low-level random sequence using the time of day, so that the | |
19107 | random number sequence will be different every time you use Calc. | |
19108 | ||
19109 | Since Emacs Lisp doesn't specify the range of values that will be | |
19110 | returned by its @code{random} function, Calc exercises the function | |
19111 | several times to estimate the range. When Calc subsequently uses | |
19112 | the @code{random} function, it takes only 10 bits of the result | |
19113 | near the most-significant end. (It avoids at least the bottom | |
19114 | four bits, preferably more, and also tries to avoid the top two | |
19115 | bits.) This strategy works well with the linear congruential | |
19116 | generators that are typically used to implement @code{random}. | |
19117 | ||
19118 | If @code{RandSeed} contains an integer, Calc uses this integer to | |
19119 | seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A, | |
a4231b04 | 19120 | computing |
8e04863e | 19121 | @texline @math{X_{n-55} - X_{n-24}}. |
a4231b04 JB |
19122 | @infoline @expr{X_n-55 - X_n-24}). |
19123 | This method expands the seed | |
d7b8e6c6 | 19124 | value into a large table which is maintained internally; the variable |
a4231b04 | 19125 | @code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]} |
d7b8e6c6 EZ |
19126 | to indicate that the seed has been absorbed into this table. When |
19127 | @code{RandSeed} contains a vector, @kbd{k r} and related commands | |
19128 | continue to use the same internal table as last time. There is no | |
19129 | way to extract the complete state of the random number generator | |
19130 | so that you can restart it from any point; you can only restart it | |
19131 | from the same initial seed value. A simple way to restart from the | |
19132 | same seed is to type @kbd{s r RandSeed} to get the seed vector, | |
19133 | @kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed} | |
19134 | to reseed the generator with that number. | |
19135 | ||
19136 | Calc uses a ``shuffling'' method as described in algorithm 3.2.2B | |
19137 | of Knuth. It fills a table with 13 random 10-bit numbers. Then, | |
19138 | to generate a new random number, it uses the previous number to | |
19139 | index into the table, picks the value it finds there as the new | |
19140 | random number, then replaces that table entry with a new value | |
19141 | obtained from a call to the base random number generator (either | |
19142 | the additive congruential generator or the @code{random} function | |
19143 | supplied by the system). If there are any flaws in the base | |
19144 | generator, shuffling will tend to even them out. But if the system | |
19145 | provides an excellent @code{random} function, shuffling will not | |
19146 | damage its randomness. | |
19147 | ||
19148 | To create a random integer of a certain number of digits, Calc | |
19149 | builds the integer three decimal digits at a time. For each group | |
19150 | of three digits, Calc calls its 10-bit shuffling random number generator | |
19151 | (which returns a value from 0 to 1023); if the random value is 1000 | |
19152 | or more, Calc throws it out and tries again until it gets a suitable | |
19153 | value. | |
19154 | ||
19155 | To create a random floating-point number with precision @var{p}, Calc | |
19156 | simply creates a random @var{p}-digit integer and multiplies by | |
8e04863e | 19157 | @texline @math{10^{-p}}. |
a4231b04 JB |
19158 | @infoline @expr{10^-p}. |
19159 | The resulting random numbers should be very clean, but note | |
d7b8e6c6 EZ |
19160 | that relatively small numbers will have few significant random digits. |
19161 | In other words, with a precision of 12, you will occasionally get | |
a4231b04 | 19162 | numbers on the order of |
8e04863e | 19163 | @texline @math{10^{-9}} |
a4231b04 JB |
19164 | @infoline @expr{10^-9} |
19165 | or | |
8e04863e | 19166 | @texline @math{10^{-10}}, |
a4231b04 JB |
19167 | @infoline @expr{10^-10}, |
19168 | but those numbers will only have two or three random digits since they | |
19169 | correspond to small integers times | |
8e04863e | 19170 | @texline @math{10^{-12}}. |
a4231b04 | 19171 | @infoline @expr{10^-12}. |
d7b8e6c6 EZ |
19172 | |
19173 | To create a random integer in the interval @samp{[0 .. @var{m})}, Calc | |
19174 | counts the digits in @var{m}, creates a random integer with three | |
19175 | additional digits, then reduces modulo @var{m}. Unless @var{m} is a | |
19176 | power of ten the resulting values will be very slightly biased toward | |
19177 | the lower numbers, but this bias will be less than 0.1%. (For example, | |
19178 | if @var{m} is 42, Calc will reduce a random integer less than 100000 | |
19179 | modulo 42 to get a result less than 42. It is easy to show that the | |
19180 | numbers 40 and 41 will be only 2380/2381 as likely to result from this | |
19181 | modulo operation as numbers 39 and below.) If @var{m} is a power of | |
19182 | ten, however, the numbers should be completely unbiased. | |
19183 | ||
19184 | The Gaussian random numbers generated by @samp{random(0.0)} use the | |
19185 | ``polar'' method described in Knuth section 3.4.1C. This method | |
19186 | generates a pair of Gaussian random numbers at a time, so only every | |
19187 | other call to @samp{random(0.0)} will require significant calculations. | |
19188 | ||
19189 | @node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions | |
19190 | @section Combinatorial Functions | |
19191 | ||
19192 | @noindent | |
19193 | Commands relating to combinatorics and number theory begin with the | |
19194 | @kbd{k} key prefix. | |
19195 | ||
19196 | @kindex k g | |
19197 | @pindex calc-gcd | |
19198 | @tindex gcd | |
19199 | The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the | |
19200 | Greatest Common Divisor of two integers. It also accepts fractions; | |
19201 | the GCD of two fractions is defined by taking the GCD of the | |
19202 | numerators, and the LCM of the denominators. This definition is | |
19203 | consistent with the idea that @samp{a / gcd(a,x)} should yield an | |
19204 | integer for any @samp{a} and @samp{x}. For other types of arguments, | |
a4231b04 | 19205 | the operation is left in symbolic form. |
d7b8e6c6 EZ |
19206 | |
19207 | @kindex k l | |
19208 | @pindex calc-lcm | |
19209 | @tindex lcm | |
19210 | The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the | |
19211 | Least Common Multiple of two integers or fractions. The product of | |
19212 | the LCM and GCD of two numbers is equal to the product of the | |
a4231b04 | 19213 | numbers. |
d7b8e6c6 EZ |
19214 | |
19215 | @kindex k E | |
19216 | @pindex calc-extended-gcd | |
19217 | @tindex egcd | |
19218 | The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes | |
a4231b04 JB |
19219 | the GCD of two integers @expr{x} and @expr{y} and returns a vector |
19220 | @expr{[g, a, b]} where | |
8e04863e | 19221 | @texline @math{g = \gcd(x,y) = a x + b y}. |
a4231b04 | 19222 | @infoline @expr{g = gcd(x,y) = a x + b y}. |
d7b8e6c6 EZ |
19223 | |
19224 | @kindex ! | |
19225 | @pindex calc-factorial | |
19226 | @tindex fact | |
5d67986c RS |
19227 | @ignore |
19228 | @mindex @null | |
19229 | @end ignore | |
d7b8e6c6 EZ |
19230 | @tindex ! |
19231 | The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the | |
19232 | factorial of the number at the top of the stack. If the number is an | |
19233 | integer, the result is an exact integer. If the number is an | |
19234 | integer-valued float, the result is a floating-point approximation. If | |
19235 | the number is a non-integral real number, the generalized factorial is used, | |
19236 | as defined by the Euler Gamma function. Please note that computation of | |
19237 | large factorials can be slow; using floating-point format will help | |
19238 | since fewer digits must be maintained. The same is true of many of | |
a4231b04 | 19239 | the commands in this section. |
d7b8e6c6 EZ |
19240 | |
19241 | @kindex k d | |
19242 | @pindex calc-double-factorial | |
19243 | @tindex dfact | |
5d67986c RS |
19244 | @ignore |
19245 | @mindex @null | |
19246 | @end ignore | |
d7b8e6c6 EZ |
19247 | @tindex !! |
19248 | The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command | |
19249 | computes the ``double factorial'' of an integer. For an even integer, | |
a4231b04 JB |
19250 | this is the product of even integers from 2 to @expr{N}. For an odd |
19251 | integer, this is the product of odd integers from 3 to @expr{N}. If | |
d7b8e6c6 EZ |
19252 | the argument is an integer-valued float, the result is a floating-point |
19253 | approximation. This function is undefined for negative even integers. | |
a4231b04 | 19254 | The notation @expr{N!!} is also recognized for double factorials. |
d7b8e6c6 EZ |
19255 | |
19256 | @kindex k c | |
19257 | @pindex calc-choose | |
19258 | @tindex choose | |
19259 | The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the | |
a4231b04 JB |
19260 | binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number |
19261 | on the top of the stack and @expr{N} is second-to-top. If both arguments | |
d7b8e6c6 EZ |
19262 | are integers, the result is an exact integer. Otherwise, the result is a |
19263 | floating-point approximation. The binomial coefficient is defined for all | |
a4231b04 | 19264 | real numbers by |
8e04863e | 19265 | @texline @math{N! \over M! (N-M)!\,}. |
a4231b04 | 19266 | @infoline @expr{N! / M! (N-M)!}. |
d7b8e6c6 EZ |
19267 | |
19268 | @kindex H k c | |
19269 | @pindex calc-perm | |
19270 | @tindex perm | |
19271 | @ifinfo | |
19272 | The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the | |
a4231b04 | 19273 | number-of-permutations function @expr{N! / (N-M)!}. |
d7b8e6c6 EZ |
19274 | @end ifinfo |
19275 | @tex | |
19276 | The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the | |
19277 | number-of-perm\-utations function $N! \over (N-M)!\,$. | |
19278 | @end tex | |
19279 | ||
19280 | @kindex k b | |
19281 | @kindex H k b | |
19282 | @pindex calc-bernoulli-number | |
19283 | @tindex bern | |
19284 | The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command | |
19285 | computes a given Bernoulli number. The value at the top of the stack | |
a4231b04 | 19286 | is a nonnegative integer @expr{n} that specifies which Bernoulli number |
d7b8e6c6 | 19287 | is desired. The @kbd{H k b} command computes a Bernoulli polynomial, |
a4231b04 JB |
19288 | taking @expr{n} from the second-to-top position and @expr{x} from the |
19289 | top of the stack. If @expr{x} is a variable or formula the result is | |
19290 | a polynomial in @expr{x}; if @expr{x} is a number the result is a number. | |
d7b8e6c6 EZ |
19291 | |
19292 | @kindex k e | |
19293 | @kindex H k e | |
19294 | @pindex calc-euler-number | |
19295 | @tindex euler | |
19296 | The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly | |
19297 | computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial. | |
19298 | Bernoulli and Euler numbers occur in the Taylor expansions of several | |
19299 | functions. | |
19300 | ||
19301 | @kindex k s | |
19302 | @kindex H k s | |
19303 | @pindex calc-stirling-number | |
19304 | @tindex stir1 | |
19305 | @tindex stir2 | |
19306 | The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command | |
a4231b04 | 19307 | computes a Stirling number of the first |
8e04863e | 19308 | @texline kind@tie{}@math{n \brack m}, |
a4231b04 JB |
19309 | @infoline kind, |
19310 | given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s} | |
19311 | [@code{stir2}] command computes a Stirling number of the second | |
8e04863e | 19312 | @texline kind@tie{}@math{n \brace m}. |
a4231b04 JB |
19313 | @infoline kind. |
19314 | These are the number of @expr{m}-cycle permutations of @expr{n} objects, | |
19315 | and the number of ways to partition @expr{n} objects into @expr{m} | |
d7b8e6c6 EZ |
19316 | non-empty sets, respectively. |
19317 | ||
19318 | @kindex k p | |
19319 | @pindex calc-prime-test | |
19320 | @cindex Primes | |
19321 | The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on | |
19322 | the top of the stack is prime. For integers less than eight million, the | |
19323 | answer is always exact and reasonably fast. For larger integers, a | |
19324 | probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P). | |
19325 | The number is first checked against small prime factors (up to 13). Then, | |
19326 | any number of iterations of the algorithm are performed. Each step either | |
19327 | discovers that the number is non-prime, or substantially increases the | |
19328 | certainty that the number is prime. After a few steps, the chance that | |
19329 | a number was mistakenly described as prime will be less than one percent. | |
19330 | (Indeed, this is a worst-case estimate of the probability; in practice | |
19331 | even a single iteration is quite reliable.) After the @kbd{k p} command, | |
19332 | the number will be reported as definitely prime or non-prime if possible, | |
19333 | or otherwise ``probably'' prime with a certain probability of error. | |
19334 | ||
5d67986c RS |
19335 | @ignore |
19336 | @starindex | |
19337 | @end ignore | |
d7b8e6c6 EZ |
19338 | @tindex prime |
19339 | The normal @kbd{k p} command performs one iteration of the primality | |
19340 | test. Pressing @kbd{k p} repeatedly for the same integer will perform | |
19341 | additional iterations. Also, @kbd{k p} with a numeric prefix performs | |
19342 | the specified number of iterations. There is also an algebraic function | |
a4231b04 | 19343 | @samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n} |
d7b8e6c6 EZ |
19344 | is (probably) prime and 0 if not. |
19345 | ||
19346 | @kindex k f | |
19347 | @pindex calc-prime-factors | |
19348 | @tindex prfac | |
19349 | The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command | |
19350 | attempts to decompose an integer into its prime factors. For numbers up | |
19351 | to 25 million, the answer is exact although it may take some time. The | |
19352 | result is a vector of the prime factors in increasing order. For larger | |
19353 | inputs, prime factors above 5000 may not be found, in which case the | |
19354 | last number in the vector will be an unfactored integer greater than 25 | |
19355 | million (with a warning message). For negative integers, the first | |
8e04863e JB |
19356 | element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and |
19357 | @mathit{1}, the result is a list of the same number. | |
d7b8e6c6 EZ |
19358 | |
19359 | @kindex k n | |
19360 | @pindex calc-next-prime | |
5d67986c RS |
19361 | @ignore |
19362 | @mindex nextpr@idots | |
19363 | @end ignore | |
d7b8e6c6 EZ |
19364 | @tindex nextprime |
19365 | The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds | |
19366 | the next prime above a given number. Essentially, it searches by calling | |
19367 | @code{calc-prime-test} on successive integers until it finds one that | |
19368 | passes the test. This is quite fast for integers less than eight million, | |
19369 | but once the probabilistic test comes into play the search may be rather | |
19370 | slow. Ordinarily this command stops for any prime that passes one iteration | |
19371 | of the primality test. With a numeric prefix argument, a number must pass | |
19372 | the specified number of iterations before the search stops. (This only | |
19373 | matters when searching above eight million.) You can always use additional | |
19374 | @kbd{k p} commands to increase your certainty that the number is indeed | |
19375 | prime. | |
19376 | ||
19377 | @kindex I k n | |
19378 | @pindex calc-prev-prime | |
5d67986c RS |
19379 | @ignore |
19380 | @mindex prevpr@idots | |
19381 | @end ignore | |
d7b8e6c6 EZ |
19382 | @tindex prevprime |
19383 | The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command | |
19384 | analogously finds the next prime less than a given number. | |
19385 | ||
19386 | @kindex k t | |
19387 | @pindex calc-totient | |
19388 | @tindex totient | |
19389 | The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the | |
a4231b04 | 19390 | Euler ``totient'' |
8e04863e | 19391 | @texline function@tie{}@math{\phi(n)}, |
a4231b04 JB |
19392 | @infoline function, |
19393 | the number of integers less than @expr{n} which | |
19394 | are relatively prime to @expr{n}. | |
d7b8e6c6 EZ |
19395 | |
19396 | @kindex k m | |
19397 | @pindex calc-moebius | |
19398 | @tindex moebius | |
19399 | The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the | |
8e04863e | 19400 | @texline M@"obius @math{\mu} |
a4231b04 JB |
19401 | @infoline Moebius ``mu'' |
19402 | function. If the input number is a product of @expr{k} | |
19403 | distinct factors, this is @expr{(-1)^k}. If the input number has any | |
d7b8e6c6 EZ |
19404 | duplicate factors (i.e., can be divided by the same prime more than once), |
19405 | the result is zero. | |
19406 | ||
19407 | @node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions | |
19408 | @section Probability Distribution Functions | |
19409 | ||
19410 | @noindent | |
19411 | The functions in this section compute various probability distributions. | |
19412 | For continuous distributions, this is the integral of the probability | |
a4231b04 | 19413 | density function from @expr{x} to infinity. (These are the ``upper |
d7b8e6c6 | 19414 | tail'' distribution functions; there are also corresponding ``lower |
a4231b04 | 19415 | tail'' functions which integrate from minus infinity to @expr{x}.) |
d7b8e6c6 | 19416 | For discrete distributions, the upper tail function gives the sum |
a4231b04 JB |
19417 | from @expr{x} to infinity; the lower tail function gives the sum |
19418 | from minus infinity up to, but not including,@w{ }@expr{x}. | |
d7b8e6c6 | 19419 | |
a4231b04 | 19420 | To integrate from @expr{x} to @expr{y}, just use the distribution |
d7b8e6c6 EZ |
19421 | function twice and subtract. For example, the probability that a |
19422 | Gaussian random variable with mean 2 and standard deviation 1 will | |
19423 | lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)} | |
19424 | (``the probability that it is greater than 2.5, but not greater than 2.8''), | |
19425 | or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}. | |
19426 | ||
19427 | @kindex k B | |
19428 | @kindex I k B | |
19429 | @pindex calc-utpb | |
19430 | @tindex utpb | |
19431 | @tindex ltpb | |
19432 | The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the | |
19433 | binomial distribution. Push the parameters @var{n}, @var{p}, and | |
19434 | then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the | |
19435 | probability that an event will occur @var{x} or more times out | |
19436 | of @var{n} trials, if its probability of occurring in any given | |
19437 | trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is | |
19438 | the probability that the event will occur fewer than @var{x} times. | |
19439 | ||
19440 | The other probability distribution functions similarly take the | |
19441 | form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}] | |
19442 | and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters | |
19443 | @var{x}. The arguments to the algebraic functions are the value of | |
19444 | the random variable first, then whatever other parameters define the | |
19445 | distribution. Note these are among the few Calc functions where the | |
19446 | order of the arguments in algebraic form differs from the order of | |
19447 | arguments as found on the stack. (The random variable comes last on | |
19448 | the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5 | |
19449 | k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to | |
a4231b04 | 19450 | recover the original arguments but substitute a new value for @expr{x}.) |
d7b8e6c6 EZ |
19451 | |
19452 | @kindex k C | |
19453 | @pindex calc-utpc | |
19454 | @tindex utpc | |
5d67986c RS |
19455 | @ignore |
19456 | @mindex @idots | |
19457 | @end ignore | |
d7b8e6c6 | 19458 | @kindex I k C |
5d67986c RS |
19459 | @ignore |
19460 | @mindex @null | |
19461 | @end ignore | |
d7b8e6c6 EZ |
19462 | @tindex ltpc |
19463 | The @samp{utpc(x,v)} function uses the chi-square distribution with | |
8e04863e | 19464 | @texline @math{\nu} |
a4231b04 JB |
19465 | @infoline @expr{v} |
19466 | degrees of freedom. It is the probability that a model is | |
19467 | correct if its chi-square statistic is @expr{x}. | |
d7b8e6c6 EZ |
19468 | |
19469 | @kindex k F | |
19470 | @pindex calc-utpf | |
19471 | @tindex utpf | |
5d67986c RS |
19472 | @ignore |
19473 | @mindex @idots | |
19474 | @end ignore | |
d7b8e6c6 | 19475 | @kindex I k F |
5d67986c RS |
19476 | @ignore |
19477 | @mindex @null | |
19478 | @end ignore | |
d7b8e6c6 EZ |
19479 | @tindex ltpf |
19480 | The @samp{utpf(F,v1,v2)} function uses the F distribution, used in | |
a4231b04 | 19481 | various statistical tests. The parameters |
8e04863e | 19482 | @texline @math{\nu_1} |
a4231b04 JB |
19483 | @infoline @expr{v1} |
19484 | and | |
8e04863e | 19485 | @texline @math{\nu_2} |
a4231b04 | 19486 | @infoline @expr{v2} |
d7b8e6c6 | 19487 | are the degrees of freedom in the numerator and denominator, |
a4231b04 | 19488 | respectively, used in computing the statistic @expr{F}. |
d7b8e6c6 EZ |
19489 | |
19490 | @kindex k N | |
19491 | @pindex calc-utpn | |
19492 | @tindex utpn | |
5d67986c RS |
19493 | @ignore |
19494 | @mindex @idots | |
19495 | @end ignore | |
d7b8e6c6 | 19496 | @kindex I k N |
5d67986c RS |
19497 | @ignore |
19498 | @mindex @null | |
19499 | @end ignore | |
d7b8e6c6 EZ |
19500 | @tindex ltpn |
19501 | The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution | |
a4231b04 | 19502 | with mean @expr{m} and standard deviation |
8e04863e | 19503 | @texline @math{\sigma}. |
a4231b04 JB |
19504 | @infoline @expr{s}. |
19505 | It is the probability that such a normal-distributed random variable | |
19506 | would exceed @expr{x}. | |
d7b8e6c6 EZ |
19507 | |
19508 | @kindex k P | |
19509 | @pindex calc-utpp | |
19510 | @tindex utpp | |
5d67986c RS |
19511 | @ignore |
19512 | @mindex @idots | |
19513 | @end ignore | |
d7b8e6c6 | 19514 | @kindex I k P |
5d67986c RS |
19515 | @ignore |
19516 | @mindex @null | |
19517 | @end ignore | |
d7b8e6c6 EZ |
19518 | @tindex ltpp |
19519 | The @samp{utpp(n,x)} function uses a Poisson distribution with | |
a4231b04 | 19520 | mean @expr{x}. It is the probability that @expr{n} or more such |
d7b8e6c6 EZ |
19521 | Poisson random events will occur. |
19522 | ||
19523 | @kindex k T | |
19524 | @pindex calc-ltpt | |
19525 | @tindex utpt | |
5d67986c RS |
19526 | @ignore |
19527 | @mindex @idots | |
19528 | @end ignore | |
d7b8e6c6 | 19529 | @kindex I k T |
5d67986c RS |
19530 | @ignore |
19531 | @mindex @null | |
19532 | @end ignore | |
d7b8e6c6 EZ |
19533 | @tindex ltpt |
19534 | The @samp{utpt(t,v)} function uses the Student's ``t'' distribution | |
a4231b04 | 19535 | with |
8e04863e | 19536 | @texline @math{\nu} |
a4231b04 JB |
19537 | @infoline @expr{v} |
19538 | degrees of freedom. It is the probability that a | |
19539 | t-distributed random variable will be greater than @expr{t}. | |
19540 | (Note: This computes the distribution function | |
8e04863e | 19541 | @texline @math{A(t|\nu)} |
a4231b04 JB |
19542 | @infoline @expr{A(t|v)} |
19543 | where | |
8e04863e | 19544 | @texline @math{A(0|\nu) = 1} |
a4231b04 JB |
19545 | @infoline @expr{A(0|v) = 1} |
19546 | and | |
8e04863e | 19547 | @texline @math{A(\infty|\nu) \to 0}. |
a4231b04 JB |
19548 | @infoline @expr{A(inf|v) -> 0}. |
19549 | The @code{UTPT} operation on the HP-48 uses a different definition which | |
19550 | returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.) | |
d7b8e6c6 EZ |
19551 | |
19552 | While Calc does not provide inverses of the probability distribution | |
19553 | functions, the @kbd{a R} command can be used to solve for the inverse. | |
19554 | Since the distribution functions are monotonic, @kbd{a R} is guaranteed | |
19555 | to be able to find a solution given any initial guess. | |
19556 | @xref{Numerical Solutions}. | |
19557 | ||
19558 | @node Matrix Functions, Algebra, Scientific Functions, Top | |
19559 | @chapter Vector/Matrix Functions | |
19560 | ||
19561 | @noindent | |
19562 | Many of the commands described here begin with the @kbd{v} prefix. | |
19563 | (For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.) | |
19564 | The commands usually apply to both plain vectors and matrices; some | |
19565 | apply only to matrices or only to square matrices. If the argument | |
19566 | has the wrong dimensions the operation is left in symbolic form. | |
19567 | ||
19568 | Vectors are entered and displayed using @samp{[a,b,c]} notation. | |
19569 | Matrices are vectors of which all elements are vectors of equal length. | |
19570 | (Though none of the standard Calc commands use this concept, a | |
19571 | three-dimensional matrix or rank-3 tensor could be defined as a | |
19572 | vector of matrices, and so on.) | |
19573 | ||
19574 | @menu | |
19575 | * Packing and Unpacking:: | |
19576 | * Building Vectors:: | |
19577 | * Extracting Elements:: | |
19578 | * Manipulating Vectors:: | |
19579 | * Vector and Matrix Arithmetic:: | |
19580 | * Set Operations:: | |
19581 | * Statistical Operations:: | |
19582 | * Reducing and Mapping:: | |
19583 | * Vector and Matrix Formats:: | |
19584 | @end menu | |
19585 | ||
19586 | @node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions | |
19587 | @section Packing and Unpacking | |
19588 | ||
19589 | @noindent | |
19590 | Calc's ``pack'' and ``unpack'' commands collect stack entries to build | |
19591 | composite objects such as vectors and complex numbers. They are | |
19592 | described in this chapter because they are most often used to build | |
19593 | vectors. | |
19594 | ||
19595 | @kindex v p | |
19596 | @pindex calc-pack | |
19597 | The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several | |
19598 | elements from the stack into a matrix, complex number, HMS form, error | |
19599 | form, etc. It uses a numeric prefix argument to specify the kind of | |
19600 | object to be built; this argument is referred to as the ``packing mode.'' | |
19601 | If the packing mode is a nonnegative integer, a vector of that | |
19602 | length is created. For example, @kbd{C-u 5 v p} will pop the top | |
19603 | five stack elements and push back a single vector of those five | |
19604 | elements. (@kbd{C-u 0 v p} simply creates an empty vector.) | |
19605 | ||
19606 | The same effect can be had by pressing @kbd{[} to push an incomplete | |
19607 | vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak | |
19608 | the incomplete object up past a certain number of elements, and | |
19609 | then pressing @kbd{]} to complete the vector. | |
19610 | ||
19611 | Negative packing modes create other kinds of composite objects: | |
19612 | ||
19613 | @table @cite | |
19614 | @item -1 | |
19615 | Two values are collected to build a complex number. For example, | |
19616 | @kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number | |
a4231b04 | 19617 | @expr{(5, 7)}. The result is always a rectangular complex |
d7b8e6c6 EZ |
19618 | number. The two input values must both be real numbers, |
19619 | i.e., integers, fractions, or floats. If they are not, Calc | |
19620 | will instead build a formula like @samp{a + (0, 1) b}. (The | |
19621 | other packing modes also create a symbolic answer if the | |
19622 | components are not suitable.) | |
19623 | ||
19624 | @item -2 | |
19625 | Two values are collected to build a polar complex number. | |
19626 | The first is the magnitude; the second is the phase expressed | |
19627 | in either degrees or radians according to the current angular | |
19628 | mode. | |
19629 | ||
19630 | @item -3 | |
19631 | Three values are collected into an HMS form. The first | |
19632 | two values (hours and minutes) must be integers or | |
19633 | integer-valued floats. The third value may be any real | |
19634 | number. | |
19635 | ||
19636 | @item -4 | |
19637 | Two values are collected into an error form. The inputs | |
19638 | may be real numbers or formulas. | |
19639 | ||
19640 | @item -5 | |
19641 | Two values are collected into a modulo form. The inputs | |
19642 | must be real numbers. | |
19643 | ||
19644 | @item -6 | |
19645 | Two values are collected into the interval @samp{[a .. b]}. | |
19646 | The inputs may be real numbers, HMS or date forms, or formulas. | |
19647 | ||
19648 | @item -7 | |
19649 | Two values are collected into the interval @samp{[a .. b)}. | |
19650 | ||
19651 | @item -8 | |
19652 | Two values are collected into the interval @samp{(a .. b]}. | |
19653 | ||
19654 | @item -9 | |
19655 | Two values are collected into the interval @samp{(a .. b)}. | |
19656 | ||
19657 | @item -10 | |
19658 | Two integer values are collected into a fraction. | |
19659 | ||
19660 | @item -11 | |
19661 | Two values are collected into a floating-point number. | |
19662 | The first is the mantissa; the second, which must be an | |
19663 | integer, is the exponent. The result is the mantissa | |
19664 | times ten to the power of the exponent. | |
19665 | ||
19666 | @item -12 | |
8e04863e JB |
19667 | This is treated the same as @mathit{-11} by the @kbd{v p} command. |
19668 | When unpacking, @mathit{-12} specifies that a floating-point mantissa | |
d7b8e6c6 EZ |
19669 | is desired. |
19670 | ||
19671 | @item -13 | |
19672 | A real number is converted into a date form. | |
19673 | ||
19674 | @item -14 | |
19675 | Three numbers (year, month, day) are packed into a pure date form. | |
19676 | ||
19677 | @item -15 | |
19678 | Six numbers are packed into a date/time form. | |
19679 | @end table | |
19680 | ||
19681 | With any of the two-input negative packing modes, either or both | |
19682 | of the inputs may be vectors. If both are vectors of the same | |
19683 | length, the result is another vector made by packing corresponding | |
19684 | elements of the input vectors. If one input is a vector and the | |
19685 | other is a plain number, the number is packed along with each vector | |
19686 | element to produce a new vector. For example, @kbd{C-u -4 v p} | |
19687 | could be used to convert a vector of numbers and a vector of errors | |
19688 | into a single vector of error forms; @kbd{C-u -5 v p} could convert | |
19689 | a vector of numbers and a single number @var{M} into a vector of | |
19690 | numbers modulo @var{M}. | |
19691 | ||
19692 | If you don't give a prefix argument to @kbd{v p}, it takes | |
19693 | the packing mode from the top of the stack. The elements to | |
19694 | be packed then begin at stack level 2. Thus | |
19695 | @kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to | |
19696 | enter the error form @samp{1 +/- 2}. | |
19697 | ||
19698 | If the packing mode taken from the stack is a vector, the result is a | |
19699 | matrix with the dimensions specified by the elements of the vector, | |
19700 | which must each be integers. For example, if the packing mode is | |
19701 | @samp{[2, 3]}, then six numbers will be taken from the stack and | |
19702 | returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}. | |
19703 | ||
19704 | If any elements of the vector are negative, other kinds of | |
19705 | packing are done at that level as described above. For | |
19706 | example, @samp{[2, 3, -4]} takes 12 objects and creates a | |
8e04863e | 19707 | @texline @math{2\times3} |
a4231b04 JB |
19708 | @infoline 2x3 |
19709 | matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}. | |
d7b8e6c6 EZ |
19710 | Also, @samp{[-4, -10]} will convert four integers into an |
19711 | error form consisting of two fractions: @samp{a:b +/- c:d}. | |
19712 | ||
5d67986c RS |
19713 | @ignore |
19714 | @starindex | |
19715 | @end ignore | |
d7b8e6c6 EZ |
19716 | @tindex pack |
19717 | There is an equivalent algebraic function, | |
19718 | @samp{pack(@var{mode}, @var{items})} where @var{mode} is a | |
19719 | packing mode (an integer or a vector of integers) and @var{items} | |
19720 | is a vector of objects to be packed (re-packed, really) according | |
19721 | to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])} | |
19722 | yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is | |
ce7c7522 | 19723 | left in symbolic form if the packing mode is invalid, or if the |
d7b8e6c6 EZ |
19724 | number of data items does not match the number of items required |
19725 | by the mode. | |
19726 | ||
19727 | @kindex v u | |
19728 | @pindex calc-unpack | |
19729 | The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex | |
19730 | number, HMS form, or other composite object on the top of the stack and | |
19731 | ``unpacks'' it, pushing each of its elements onto the stack as separate | |
19732 | objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value | |
19733 | at the top of the stack is a formula, @kbd{v u} unpacks it by pushing | |
19734 | each of the arguments of the top-level operator onto the stack. | |
19735 | ||
19736 | You can optionally give a numeric prefix argument to @kbd{v u} | |
19737 | to specify an explicit (un)packing mode. If the packing mode is | |
19738 | negative and the input is actually a vector or matrix, the result | |
19739 | will be two or more similar vectors or matrices of the elements. | |
19740 | For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]}, | |
19741 | the result of @kbd{C-u -4 v u} will be the two vectors | |
19742 | @samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}. | |
19743 | ||
19744 | Note that the prefix argument can have an effect even when the input is | |
8e04863e JB |
19745 | not a vector. For example, if the input is the number @mathit{-5}, then |
19746 | @kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5} | |
d7b8e6c6 | 19747 | when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5 |
07ce2eb3 | 19748 | and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5} |
8e04863e | 19749 | and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational |
d7b8e6c6 EZ |
19750 | number). Plain @kbd{v u} with this input would complain that the input |
19751 | is not a composite object. | |
19752 | ||
8e04863e | 19753 | Unpacking mode @mathit{-11} converts a float into an integer mantissa and |
d7b8e6c6 EZ |
19754 | an integer exponent, where the mantissa is not divisible by 10 |
19755 | (except that 0.0 is represented by a mantissa and exponent of 0). | |
8e04863e | 19756 | Unpacking mode @mathit{-12} converts a float into a floating-point mantissa |
d7b8e6c6 EZ |
19757 | and integer exponent, where the mantissa (for non-zero numbers) |
19758 | is guaranteed to lie in the range [1 .. 10). In both cases, | |
19759 | the mantissa is shifted left or right (and the exponent adjusted | |
19760 | to compensate) in order to satisfy these constraints. | |
19761 | ||
19762 | Positive unpacking modes are treated differently than for @kbd{v p}. | |
19763 | A mode of 1 is much like plain @kbd{v u} with no prefix argument, | |
19764 | except that in addition to the components of the input object, | |
19765 | a suitable packing mode to re-pack the object is also pushed. | |
19766 | Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the | |
19767 | original object. | |
19768 | ||
19769 | A mode of 2 unpacks two levels of the object; the resulting | |
19770 | re-packing mode will be a vector of length 2. This might be used | |
19771 | to unpack a matrix, say, or a vector of error forms. Higher | |
19772 | unpacking modes unpack the input even more deeply. | |
19773 | ||
5d67986c RS |
19774 | @ignore |
19775 | @starindex | |
19776 | @end ignore | |
d7b8e6c6 EZ |
19777 | @tindex unpack |
19778 | There are two algebraic functions analogous to @kbd{v u}. | |
19779 | The @samp{unpack(@var{mode}, @var{item})} function unpacks the | |
19780 | @var{item} using the given @var{mode}, returning the result as | |
19781 | a vector of components. Here the @var{mode} must be an | |
19782 | integer, not a vector. For example, @samp{unpack(-4, a +/- b)} | |
19783 | returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}. | |
19784 | ||
5d67986c RS |
19785 | @ignore |
19786 | @starindex | |
19787 | @end ignore | |
d7b8e6c6 EZ |
19788 | @tindex unpackt |
19789 | The @code{unpackt} function is like @code{unpack} but instead | |
19790 | of returning a simple vector of items, it returns a vector of | |
19791 | two things: The mode, and the vector of items. For example, | |
19792 | @samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]}, | |
19793 | and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}. | |
19794 | The identity for re-building the original object is | |
19795 | @samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The | |
19796 | @code{apply} function builds a function call given the function | |
19797 | name and a vector of arguments.) | |
19798 | ||
19799 | @cindex Numerator of a fraction, extracting | |
19800 | Subscript notation is a useful way to extract a particular part | |
19801 | of an object. For example, to get the numerator of a rational | |
19802 | number, you can use @samp{unpack(-10, @var{x})_1}. | |
19803 | ||
19804 | @node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions | |
19805 | @section Building Vectors | |
19806 | ||
19807 | @noindent | |
19808 | Vectors and matrices can be added, | |
a4231b04 | 19809 | subtracted, multiplied, and divided; @pxref{Basic Arithmetic}. |
d7b8e6c6 EZ |
19810 | |
19811 | @kindex | | |
19812 | @pindex calc-concat | |
5d67986c RS |
19813 | @ignore |
19814 | @mindex @null | |
19815 | @end ignore | |
d7b8e6c6 | 19816 | @tindex | |
029b2a44 | 19817 | The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors |
d7b8e6c6 EZ |
19818 | into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack |
19819 | will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments | |
19820 | are matrices, the rows of the first matrix are concatenated with the | |
19821 | rows of the second. (In other words, two matrices are just two vectors | |
19822 | of row-vectors as far as @kbd{|} is concerned.) | |
19823 | ||
19824 | If either argument to @kbd{|} is a scalar (a non-vector), it is treated | |
19825 | like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |} | |
19826 | produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a | |
19827 | matrix and the other is a plain vector, the vector is treated as a | |
19828 | one-row matrix. | |
19829 | ||
19830 | @kindex H | | |
19831 | @tindex append | |
19832 | The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates | |
19833 | two vectors without any special cases. Both inputs must be vectors. | |
19834 | Whether or not they are matrices is not taken into account. If either | |
19835 | argument is a scalar, the @code{append} function is left in symbolic form. | |
19836 | See also @code{cons} and @code{rcons} below. | |
19837 | ||
19838 | @kindex I | | |
19839 | @kindex H I | | |
19840 | The @kbd{I |} and @kbd{H I |} commands are similar, but they use their | |
19841 | two stack arguments in the opposite order. Thus @kbd{I |} is equivalent | |
5d67986c | 19842 | to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster. |
d7b8e6c6 EZ |
19843 | |
19844 | @kindex v d | |
19845 | @pindex calc-diag | |
19846 | @tindex diag | |
19847 | The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal | |
19848 | square matrix. The optional numeric prefix gives the number of rows | |
19849 | and columns in the matrix. If the value at the top of the stack is a | |
19850 | vector, the elements of the vector are used as the diagonal elements; the | |
19851 | prefix, if specified, must match the size of the vector. If the value on | |
19852 | the stack is a scalar, it is used for each element on the diagonal, and | |
19853 | the prefix argument is required. | |
19854 | ||
a4231b04 | 19855 | To build a constant square matrix, e.g., a |
8e04863e | 19856 | @texline @math{3\times3} |
a4231b04 JB |
19857 | @infoline 3x3 |
19858 | matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero | |
19859 | matrix first and then add a constant value to that matrix. (Another | |
19860 | alternative would be to use @kbd{v b} and @kbd{v a}; see below.) | |
d7b8e6c6 EZ |
19861 | |
19862 | @kindex v i | |
19863 | @pindex calc-ident | |
19864 | @tindex idn | |
19865 | The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity | |
19866 | matrix of the specified size. It is a convenient form of @kbd{v d} | |
19867 | where the diagonal element is always one. If no prefix argument is given, | |
19868 | this command prompts for one. | |
19869 | ||
19870 | In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)}, | |
a4231b04 JB |
19871 | except that @expr{a} is required to be a scalar (non-vector) quantity. |
19872 | If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an | |
d7b8e6c6 EZ |
19873 | identity matrix of unknown size. Calc can operate algebraically on |
19874 | such generic identity matrices, and if one is combined with a matrix | |
19875 | whose size is known, it is converted automatically to an identity | |
19876 | matrix of a suitable matching size. The @kbd{v i} command with an | |
19877 | argument of zero creates a generic identity matrix, @samp{idn(1)}. | |
07ce2eb3 | 19878 | Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic |
d7b8e6c6 EZ |
19879 | identity matrices are immediately expanded to the current default |
19880 | dimensions. | |
19881 | ||
19882 | @kindex v x | |
19883 | @pindex calc-index | |
19884 | @tindex index | |
19885 | The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector | |
19886 | of consecutive integers from 1 to @var{n}, where @var{n} is the numeric | |
19887 | prefix argument. If you do not provide a prefix argument, you will be | |
19888 | prompted to enter a suitable number. If @var{n} is negative, the result | |
8e04863e | 19889 | is a vector of negative integers from @var{n} to @mathit{-1}. |
d7b8e6c6 EZ |
19890 | |
19891 | With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes | |
19892 | three values from the stack: @var{n}, @var{start}, and @var{incr} (with | |
19893 | @var{incr} at top-of-stack). Counting starts at @var{start} and increases | |
19894 | by @var{incr} for successive vector elements. If @var{start} or @var{n} | |
19895 | is in floating-point format, the resulting vector elements will also be | |
19896 | floats. Note that @var{start} and @var{incr} may in fact be any kind | |
19897 | of numbers or formulas. | |
19898 | ||
19899 | When @var{start} and @var{incr} are specified, a negative @var{n} has a | |
19900 | different interpretation: It causes a geometric instead of arithmetic | |
19901 | sequence to be generated. For example, @samp{index(-3, a, b)} produces | |
19902 | @samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form, | |
19903 | @samp{index(@var{n}, @var{start})}, the default value for @var{incr} | |
19904 | is one for positive @var{n} or two for negative @var{n}. | |
19905 | ||
19906 | @kindex v b | |
19907 | @pindex calc-build-vector | |
19908 | @tindex cvec | |
19909 | The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a | |
19910 | vector of @var{n} copies of the value on the top of the stack, where @var{n} | |
19911 | is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)} | |
19912 | can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}. | |
19913 | (Interactively, just use @kbd{v b} twice: once to build a row, then again | |
19914 | to build a matrix of copies of that row.) | |
19915 | ||
19916 | @kindex v h | |
19917 | @kindex I v h | |
19918 | @pindex calc-head | |
19919 | @pindex calc-tail | |
19920 | @tindex head | |
19921 | @tindex tail | |
19922 | The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first | |
19923 | element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}] | |
19924 | function returns the vector with its first element removed. In both | |
19925 | cases, the argument must be a non-empty vector. | |
19926 | ||
19927 | @kindex v k | |
19928 | @pindex calc-cons | |
19929 | @tindex cons | |
19930 | The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h} | |
19931 | and a vector @var{t} from the stack, and produces the vector whose head is | |
19932 | @var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except | |
19933 | if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors | |
19934 | whereas @code{cons} will insert @var{h} at the front of the vector @var{t}. | |
19935 | ||
19936 | @kindex H v h | |
19937 | @tindex rhead | |
5d67986c RS |
19938 | @ignore |
19939 | @mindex @idots | |
19940 | @end ignore | |
d7b8e6c6 | 19941 | @kindex H I v h |
5d67986c RS |
19942 | @ignore |
19943 | @mindex @null | |
19944 | @end ignore | |
d7b8e6c6 | 19945 | @kindex H v k |
5d67986c RS |
19946 | @ignore |
19947 | @mindex @null | |
19948 | @end ignore | |
d7b8e6c6 | 19949 | @tindex rtail |
5d67986c RS |
19950 | @ignore |
19951 | @mindex @null | |
19952 | @end ignore | |
d7b8e6c6 EZ |
19953 | @tindex rcons |
19954 | Each of these three functions also accepts the Hyperbolic flag [@code{rhead}, | |
19955 | @code{rtail}, @code{rcons}] in which case @var{t} instead represents | |
19956 | the @emph{last} single element of the vector, with @var{h} | |
19957 | representing the remainder of the vector. Thus the vector | |
19958 | @samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}. | |
19959 | Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]}, | |
19960 | @samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}. | |
19961 | ||
19962 | @node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions | |
19963 | @section Extracting Vector Elements | |
19964 | ||
19965 | @noindent | |
19966 | @kindex v r | |
19967 | @pindex calc-mrow | |
19968 | @tindex mrow | |
19969 | The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of | |
19970 | the matrix on the top of the stack, or one element of the plain vector on | |
19971 | the top of the stack. The row or element is specified by the numeric | |
19972 | prefix argument; the default is to prompt for the row or element number. | |
19973 | The matrix or vector is replaced by the specified row or element in the | |
19974 | form of a vector or scalar, respectively. | |
19975 | ||
19976 | @cindex Permutations, applying | |
19977 | With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of | |
19978 | the element or row from the top of the stack, and the vector or matrix | |
19979 | from the second-to-top position. If the index is itself a vector of | |
19980 | integers, the result is a vector of the corresponding elements of the | |
19981 | input vector, or a matrix of the corresponding rows of the input matrix. | |
19982 | This command can be used to obtain any permutation of a vector. | |
19983 | ||
19984 | With @kbd{C-u}, if the index is an interval form with integer components, | |
19985 | it is interpreted as a range of indices and the corresponding subvector or | |
19986 | submatrix is returned. | |
19987 | ||
19988 | @cindex Subscript notation | |
19989 | @kindex a _ | |
19990 | @pindex calc-subscript | |
19991 | @tindex subscr | |
19992 | @tindex _ | |
19993 | Subscript notation in algebraic formulas (@samp{a_b}) stands for the | |
19994 | Calc function @code{subscr}, which is synonymous with @code{mrow}. | |
a4231b04 JB |
19995 | Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if |
19996 | @expr{k} is one, two, or three, respectively. A double subscript | |
d7b8e6c6 | 19997 | (@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will |
a4231b04 | 19998 | access the element at row @expr{i}, column @expr{j} of a matrix. |
d7b8e6c6 EZ |
19999 | The @kbd{a _} (@code{calc-subscript}) command creates a subscript |
20000 | formula @samp{a_b} out of two stack entries. (It is on the @kbd{a} | |
20001 | ``algebra'' prefix because subscripted variables are often used | |
20002 | purely as an algebraic notation.) | |
20003 | ||
20004 | @tindex mrrow | |
20005 | Given a negative prefix argument, @kbd{v r} instead deletes one row or | |
20006 | element from the matrix or vector on the top of the stack. Thus | |
20007 | @kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r} | |
20008 | replaces the matrix with the same matrix with its second row removed. | |
20009 | In algebraic form this function is called @code{mrrow}. | |
20010 | ||
20011 | @tindex getdiag | |
20012 | Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements | |
20013 | of a square matrix in the form of a vector. In algebraic form this | |
20014 | function is called @code{getdiag}. | |
20015 | ||
20016 | @kindex v c | |
20017 | @pindex calc-mcol | |
20018 | @tindex mcol | |
20019 | @tindex mrcol | |
20020 | The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is | |
20021 | the analogous operation on columns of a matrix. Given a plain vector | |
20022 | it extracts (or removes) one element, just like @kbd{v r}. If the | |
20023 | index in @kbd{C-u v c} is an interval or vector and the argument is a | |
20024 | matrix, the result is a submatrix with only the specified columns | |
a4231b04 | 20025 | retained (and possibly permuted in the case of a vector index). |
d7b8e6c6 EZ |
20026 | |
20027 | To extract a matrix element at a given row and column, use @kbd{v r} to | |
20028 | extract the row as a vector, then @kbd{v c} to extract the column element | |
20029 | from that vector. In algebraic formulas, it is often more convenient to | |
a4231b04 JB |
20030 | use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j} |
20031 | of matrix @expr{m}. | |
d7b8e6c6 EZ |
20032 | |
20033 | @kindex v s | |
20034 | @pindex calc-subvector | |
20035 | @tindex subvec | |
20036 | The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts | |
20037 | a subvector of a vector. The arguments are the vector, the starting | |
20038 | index, and the ending index, with the ending index in the top-of-stack | |
20039 | position. The starting index indicates the first element of the vector | |
20040 | to take. The ending index indicates the first element @emph{past} the | |
20041 | range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces | |
20042 | the subvector @samp{[b, c]}. You could get the same result using | |
20043 | @samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}. | |
20044 | ||
20045 | If either the start or the end index is zero or negative, it is | |
20046 | interpreted as relative to the end of the vector. Thus | |
20047 | @samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In | |
20048 | the algebraic form, the end index can be omitted in which case it | |
20049 | is taken as zero, i.e., elements from the starting element to the | |
20050 | end of the vector are used. The infinity symbol, @code{inf}, also | |
20051 | has this effect when used as the ending index. | |
20052 | ||
20053 | @kindex I v s | |
20054 | @tindex rsubvec | |
20055 | With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector | |
20056 | from a vector. The arguments are interpreted the same as for the | |
20057 | normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)} | |
20058 | produces @samp{[a, d, e]}. It is always true that @code{subvec} and | |
20059 | @code{rsubvec} return complementary parts of the input vector. | |
20060 | ||
20061 | @xref{Selecting Subformulas}, for an alternative way to operate on | |
20062 | vectors one element at a time. | |
20063 | ||
20064 | @node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions | |
20065 | @section Manipulating Vectors | |
20066 | ||
20067 | @noindent | |
20068 | @kindex v l | |
20069 | @pindex calc-vlength | |
20070 | @tindex vlen | |
20071 | The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the | |
20072 | length of a vector. The length of a non-vector is considered to be zero. | |
20073 | Note that matrices are just vectors of vectors for the purposes of this | |
a4231b04 | 20074 | command. |
d7b8e6c6 EZ |
20075 | |
20076 | @kindex H v l | |
20077 | @tindex mdims | |
20078 | With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector | |
20079 | of the dimensions of a vector, matrix, or higher-order object. For | |
20080 | example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since | |
a4231b04 | 20081 | its argument is a |
8e04863e | 20082 | @texline @math{2\times3} |
a4231b04 JB |
20083 | @infoline 2x3 |
20084 | matrix. | |
d7b8e6c6 EZ |
20085 | |
20086 | @kindex v f | |
20087 | @pindex calc-vector-find | |
20088 | @tindex find | |
20089 | The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches | |
20090 | along a vector for the first element equal to a given target. The target | |
20091 | is on the top of the stack; the vector is in the second-to-top position. | |
20092 | If a match is found, the result is the index of the matching element. | |
20093 | Otherwise, the result is zero. The numeric prefix argument, if given, | |
20094 | allows you to select any starting index for the search. | |
20095 | ||
20096 | @kindex v a | |
20097 | @pindex calc-arrange-vector | |
20098 | @tindex arrange | |
20099 | @cindex Arranging a matrix | |
20100 | @cindex Reshaping a matrix | |
20101 | @cindex Flattening a matrix | |
20102 | The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command | |
20103 | rearranges a vector to have a certain number of columns and rows. The | |
20104 | numeric prefix argument specifies the number of columns; if you do not | |
20105 | provide an argument, you will be prompted for the number of columns. | |
20106 | The vector or matrix on the top of the stack is @dfn{flattened} into a | |
20107 | plain vector. If the number of columns is nonzero, this vector is | |
20108 | then formed into a matrix by taking successive groups of @var{n} elements. | |
20109 | If the number of columns does not evenly divide the number of elements | |
20110 | in the vector, the last row will be short and the result will not be | |
20111 | suitable for use as a matrix. For example, with the matrix | |
20112 | @samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces | |
a4231b04 | 20113 | @samp{[[1, 2, 3, 4]]} (a |
8e04863e | 20114 | @texline @math{1\times4} |
a4231b04 JB |
20115 | @infoline 1x4 |
20116 | matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a | |
8e04863e | 20117 | @texline @math{4\times1} |
a4231b04 JB |
20118 | @infoline 4x1 |
20119 | matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original | |
8e04863e | 20120 | @texline @math{2\times2} |
a4231b04 JB |
20121 | @infoline 2x2 |
20122 | matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a | |
20123 | matrix), and @kbd{v a 0} produces the flattened list | |
20124 | @samp{[1, 2, @w{3, 4}]}. | |
d7b8e6c6 EZ |
20125 | |
20126 | @cindex Sorting data | |
20127 | @kindex V S | |
20128 | @kindex I V S | |
20129 | @pindex calc-sort | |
20130 | @tindex sort | |
20131 | @tindex rsort | |
20132 | The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of | |
20133 | a vector into increasing order. Real numbers, real infinities, and | |
20134 | constant interval forms come first in this ordering; next come other | |
20135 | kinds of numbers, then variables (in alphabetical order), then finally | |
20136 | come formulas and other kinds of objects; these are sorted according | |
20137 | to a kind of lexicographic ordering with the useful property that | |
20138 | one vector is less or greater than another if the first corresponding | |
20139 | unequal elements are less or greater, respectively. Since quoted strings | |
20140 | are stored by Calc internally as vectors of ASCII character codes | |
20141 | (@pxref{Strings}), this means vectors of strings are also sorted into | |
20142 | alphabetical order by this command. | |
20143 | ||
20144 | The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order. | |
20145 | ||
20146 | @cindex Permutation, inverse of | |
20147 | @cindex Inverse of permutation | |
20148 | @cindex Index tables | |
20149 | @cindex Rank tables | |
20150 | @kindex V G | |
20151 | @kindex I V G | |
20152 | @pindex calc-grade | |
20153 | @tindex grade | |
20154 | @tindex rgrade | |
20155 | The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command | |
20156 | produces an index table or permutation vector which, if applied to the | |
20157 | input vector (as the index of @kbd{C-u v r}, say), would sort the vector. | |
20158 | A permutation vector is just a vector of integers from 1 to @var{n}, where | |
20159 | each integer occurs exactly once. One application of this is to sort a | |
20160 | matrix of data rows using one column as the sort key; extract that column, | |
20161 | grade it with @kbd{V G}, then use the result to reorder the original matrix | |
20162 | with @kbd{C-u v r}. Another interesting property of the @code{V G} command | |
20163 | is that, if the input is itself a permutation vector, the result will | |
20164 | be the inverse of the permutation. The inverse of an index table is | |
20165 | a rank table, whose @var{k}th element says where the @var{k}th original | |
20166 | vector element will rest when the vector is sorted. To get a rank | |
20167 | table, just use @kbd{V G V G}. | |
20168 | ||
20169 | With the Inverse flag, @kbd{I V G} produces an index table that would | |
20170 | sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G} | |
20171 | use a ``stable'' sorting algorithm, i.e., any two elements which are equal | |
20172 | will not be moved out of their original order. Generally there is no way | |
20173 | to tell with @kbd{V S}, since two elements which are equal look the same, | |
20174 | but with @kbd{V G} this can be an important issue. In the matrix-of-rows | |
20175 | example, suppose you have names and telephone numbers as two columns and | |
20176 | you wish to sort by phone number primarily, and by name when the numbers | |
20177 | are equal. You can sort the data matrix by names first, and then again | |
20178 | by phone numbers. Because the sort is stable, any two rows with equal | |
20179 | phone numbers will remain sorted by name even after the second sort. | |
20180 | ||
20181 | @cindex Histograms | |
20182 | @kindex V H | |
20183 | @pindex calc-histogram | |
5d67986c RS |
20184 | @ignore |
20185 | @mindex histo@idots | |
20186 | @end ignore | |
d7b8e6c6 EZ |
20187 | @tindex histogram |
20188 | The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a | |
20189 | histogram of a vector of numbers. Vector elements are assumed to be | |
20190 | integers or real numbers in the range [0..@var{n}) for some ``number of | |
20191 | bins'' @var{n}, which is the numeric prefix argument given to the | |
20192 | command. The result is a vector of @var{n} counts of how many times | |
20193 | each value appeared in the original vector. Non-integers in the input | |
20194 | are rounded down to integers. Any vector elements outside the specified | |
20195 | range are ignored. (You can tell if elements have been ignored by noting | |
20196 | that the counts in the result vector don't add up to the length of the | |
20197 | input vector.) | |
20198 | ||
20199 | @kindex H V H | |
20200 | With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack. | |
20201 | The second-to-top vector is the list of numbers as before. The top | |
20202 | vector is an equal-sized list of ``weights'' to attach to the elements | |
20203 | of the data vector. For example, if the first data element is 4.2 and | |
20204 | the first weight is 10, then 10 will be added to bin 4 of the result | |
20205 | vector. Without the hyperbolic flag, every element has a weight of one. | |
20206 | ||
20207 | @kindex v t | |
20208 | @pindex calc-transpose | |
20209 | @tindex trn | |
20210 | The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes | |
20211 | the transpose of the matrix at the top of the stack. If the argument | |
20212 | is a plain vector, it is treated as a row vector and transposed into | |
20213 | a one-column matrix. | |
20214 | ||
20215 | @kindex v v | |
20216 | @pindex calc-reverse-vector | |
20217 | @tindex rev | |
029b2a44 | 20218 | The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses |
d7b8e6c6 EZ |
20219 | a vector end-for-end. Given a matrix, it reverses the order of the rows. |
20220 | (To reverse the columns instead, just use @kbd{v t v v v t}. The same | |
20221 | principle can be used to apply other vector commands to the columns of | |
20222 | a matrix.) | |
20223 | ||
20224 | @kindex v m | |
20225 | @pindex calc-mask-vector | |
20226 | @tindex vmask | |
20227 | The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses | |
20228 | one vector as a mask to extract elements of another vector. The mask | |
20229 | is in the second-to-top position; the target vector is on the top of | |
20230 | the stack. These vectors must have the same length. The result is | |
20231 | the same as the target vector, but with all elements which correspond | |
20232 | to zeros in the mask vector deleted. Thus, for example, | |
20233 | @samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}. | |
20234 | @xref{Logical Operations}. | |
20235 | ||
20236 | @kindex v e | |
20237 | @pindex calc-expand-vector | |
20238 | @tindex vexp | |
20239 | The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command | |
20240 | expands a vector according to another mask vector. The result is a | |
20241 | vector the same length as the mask, but with nonzero elements replaced | |
20242 | by successive elements from the target vector. The length of the target | |
20243 | vector is normally the number of nonzero elements in the mask. If the | |
20244 | target vector is longer, its last few elements are lost. If the target | |
20245 | vector is shorter, the last few nonzero mask elements are left | |
20246 | unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])} | |
20247 | produces @samp{[a, 0, b, 0, 7]}. | |
20248 | ||
20249 | @kindex H v e | |
20250 | With the Hyperbolic flag, @kbd{H v e} takes a filler value from the | |
20251 | top of the stack; the mask and target vectors come from the third and | |
20252 | second elements of the stack. This filler is used where the mask is | |
20253 | zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces | |
20254 | @samp{[a, z, c, z, 7]}. If the filler value is itself a vector, | |
20255 | then successive values are taken from it, so that the effect is to | |
20256 | interleave two vectors according to the mask: | |
20257 | @samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces | |
20258 | @samp{[a, x, b, 7, y, 0]}. | |
20259 | ||
20260 | Another variation on the masking idea is to combine @samp{[a, b, c, d, e]} | |
20261 | with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}. | |
20262 | You can accomplish this with @kbd{V M a &}, mapping the logical ``and'' | |
20263 | operation across the two vectors. @xref{Logical Operations}. Note that | |
20264 | the @code{? :} operation also discussed there allows other types of | |
20265 | masking using vectors. | |
20266 | ||
20267 | @node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions | |
20268 | @section Vector and Matrix Arithmetic | |
20269 | ||
20270 | @noindent | |
20271 | Basic arithmetic operations like addition and multiplication are defined | |
20272 | for vectors and matrices as well as for numbers. Division of matrices, in | |
20273 | the sense of multiplying by the inverse, is supported. (Division by a | |
20274 | matrix actually uses LU-decomposition for greater accuracy and speed.) | |
20275 | @xref{Basic Arithmetic}. | |
20276 | ||
20277 | The following functions are applied element-wise if their arguments are | |
20278 | vectors or matrices: @code{change-sign}, @code{conj}, @code{arg}, | |
20279 | @code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean}, | |
a4231b04 | 20280 | @code{float}, @code{frac}. @xref{Function Index}. |
d7b8e6c6 EZ |
20281 | |
20282 | @kindex V J | |
20283 | @pindex calc-conj-transpose | |
20284 | @tindex ctrn | |
20285 | The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes | |
20286 | the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}. | |
20287 | ||
5d67986c RS |
20288 | @ignore |
20289 | @mindex A | |
20290 | @end ignore | |
d7b8e6c6 EZ |
20291 | @kindex A (vectors) |
20292 | @pindex calc-abs (vectors) | |
5d67986c RS |
20293 | @ignore |
20294 | @mindex abs | |
20295 | @end ignore | |
d7b8e6c6 EZ |
20296 | @tindex abs (vectors) |
20297 | The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the | |
20298 | Frobenius norm of a vector or matrix argument. This is the square | |
20299 | root of the sum of the squares of the absolute values of the | |
20300 | elements of the vector or matrix. If the vector is interpreted as | |
20301 | a point in two- or three-dimensional space, this is the distance | |
a4231b04 | 20302 | from that point to the origin. |
d7b8e6c6 EZ |
20303 | |
20304 | @kindex v n | |
20305 | @pindex calc-rnorm | |
20306 | @tindex rnorm | |
20307 | The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes | |
20308 | the row norm, or infinity-norm, of a vector or matrix. For a plain | |
20309 | vector, this is the maximum of the absolute values of the elements. | |
20310 | For a matrix, this is the maximum of the row-absolute-value-sums, | |
20311 | i.e., of the sums of the absolute values of the elements along the | |
20312 | various rows. | |
20313 | ||
20314 | @kindex V N | |
20315 | @pindex calc-cnorm | |
20316 | @tindex cnorm | |
20317 | The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes | |
20318 | the column norm, or one-norm, of a vector or matrix. For a plain | |
20319 | vector, this is the sum of the absolute values of the elements. | |
20320 | For a matrix, this is the maximum of the column-absolute-value-sums. | |
a4231b04 | 20321 | General @expr{k}-norms for @expr{k} other than one or infinity are |
d7b8e6c6 EZ |
20322 | not provided. |
20323 | ||
20324 | @kindex V C | |
20325 | @pindex calc-cross | |
20326 | @tindex cross | |
20327 | The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the | |
20328 | right-handed cross product of two vectors, each of which must have | |
20329 | exactly three elements. | |
20330 | ||
5d67986c RS |
20331 | @ignore |
20332 | @mindex & | |
20333 | @end ignore | |
d7b8e6c6 EZ |
20334 | @kindex & (matrices) |
20335 | @pindex calc-inv (matrices) | |
5d67986c RS |
20336 | @ignore |
20337 | @mindex inv | |
20338 | @end ignore | |
d7b8e6c6 EZ |
20339 | @tindex inv (matrices) |
20340 | The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the | |
20341 | inverse of a square matrix. If the matrix is singular, the inverse | |
20342 | operation is left in symbolic form. Matrix inverses are recorded so | |
20343 | that once an inverse (or determinant) of a particular matrix has been | |
20344 | computed, the inverse and determinant of the matrix can be recomputed | |
20345 | quickly in the future. | |
20346 | ||
a4231b04 JB |
20347 | If the argument to @kbd{&} is a plain number @expr{x}, this |
20348 | command simply computes @expr{1/x}. This is okay, because the | |
d7b8e6c6 EZ |
20349 | @samp{/} operator also does a matrix inversion when dividing one |
20350 | by a matrix. | |
20351 | ||
20352 | @kindex V D | |
20353 | @pindex calc-mdet | |
20354 | @tindex det | |
20355 | The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the | |
20356 | determinant of a square matrix. | |
20357 | ||
20358 | @kindex V L | |
20359 | @pindex calc-mlud | |
20360 | @tindex lud | |
20361 | The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the | |
20362 | LU decomposition of a matrix. The result is a list of three matrices | |
20363 | which, when multiplied together left-to-right, form the original matrix. | |
20364 | The first is a permutation matrix that arises from pivoting in the | |
20365 | algorithm, the second is lower-triangular with ones on the diagonal, | |
20366 | and the third is upper-triangular. | |
20367 | ||
20368 | @kindex V T | |
20369 | @pindex calc-mtrace | |
20370 | @tindex tr | |
20371 | The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the | |
20372 | trace of a square matrix. This is defined as the sum of the diagonal | |
20373 | elements of the matrix. | |
20374 | ||
20375 | @node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions | |
20376 | @section Set Operations using Vectors | |
20377 | ||
20378 | @noindent | |
20379 | @cindex Sets, as vectors | |
20380 | Calc includes several commands which interpret vectors as @dfn{sets} of | |
20381 | objects. A set is a collection of objects; any given object can appear | |
20382 | only once in the set. Calc stores sets as vectors of objects in | |
20383 | sorted order. Objects in a Calc set can be any of the usual things, | |
20384 | such as numbers, variables, or formulas. Two set elements are considered | |
20385 | equal if they are identical, except that numerically equal numbers like | |
20386 | the integer 4 and the float 4.0 are considered equal even though they | |
20387 | are not ``identical.'' Variables are treated like plain symbols without | |
20388 | attached values by the set operations; subtracting the set @samp{[b]} | |
20389 | from @samp{[a, b]} always yields the set @samp{[a]} even though if | |
28665d46 | 20390 | the variables @samp{a} and @samp{b} both equaled 17, you might |
d7b8e6c6 EZ |
20391 | expect the answer @samp{[]}. |
20392 | ||
20393 | If a set contains interval forms, then it is assumed to be a set of | |
20394 | real numbers. In this case, all set operations require the elements | |
20395 | of the set to be only things that are allowed in intervals: Real | |
20396 | numbers, plus and minus infinity, HMS forms, and date forms. If | |
20397 | there are variables or other non-real objects present in a real set, | |
20398 | all set operations on it will be left in unevaluated form. | |
20399 | ||
20400 | If the input to a set operation is a plain number or interval form | |
20401 | @var{a}, it is treated like the one-element vector @samp{[@var{a}]}. | |
20402 | The result is always a vector, except that if the set consists of a | |
20403 | single interval, the interval itself is returned instead. | |
20404 | ||
20405 | @xref{Logical Operations}, for the @code{in} function which tests if | |
a4231b04 JB |
20406 | a certain value is a member of a given set. To test if the set @expr{A} |
20407 | is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}. | |
d7b8e6c6 EZ |
20408 | |
20409 | @kindex V + | |
20410 | @pindex calc-remove-duplicates | |
20411 | @tindex rdup | |
20412 | The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command | |
20413 | converts an arbitrary vector into set notation. It works by sorting | |
20414 | the vector as if by @kbd{V S}, then removing duplicates. (For example, | |
20415 | @kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then | |
20416 | reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as | |
20417 | necessary. You rarely need to use @kbd{V +} explicitly, since all the | |
20418 | other set-based commands apply @kbd{V +} to their inputs before using | |
20419 | them. | |
20420 | ||
20421 | @kindex V V | |
20422 | @pindex calc-set-union | |
20423 | @tindex vunion | |
20424 | The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes | |
20425 | the union of two sets. An object is in the union of two sets if and | |
20426 | only if it is in either (or both) of the input sets. (You could | |
20427 | accomplish the same thing by concatenating the sets with @kbd{|}, | |
20428 | then using @kbd{V +}.) | |
20429 | ||
20430 | @kindex V ^ | |
20431 | @pindex calc-set-intersect | |
20432 | @tindex vint | |
20433 | The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes | |
20434 | the intersection of two sets. An object is in the intersection if | |
20435 | and only if it is in both of the input sets. Thus if the input | |
20436 | sets are disjoint, i.e., if they share no common elements, the result | |
20437 | will be the empty vector @samp{[]}. Note that the characters @kbd{V} | |
20438 | and @kbd{^} were chosen to be close to the conventional mathematical | |
a4231b04 | 20439 | notation for set |
8e04863e | 20440 | @texline union@tie{}(@math{A \cup B}) |
a4231b04 JB |
20441 | @infoline union |
20442 | and | |
8e04863e | 20443 | @texline intersection@tie{}(@math{A \cap B}). |
a4231b04 | 20444 | @infoline intersection. |
d7b8e6c6 EZ |
20445 | |
20446 | @kindex V - | |
20447 | @pindex calc-set-difference | |
20448 | @tindex vdiff | |
20449 | The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes | |
20450 | the difference between two sets. An object is in the difference | |
a4231b04 | 20451 | @expr{A - B} if and only if it is in @expr{A} but not in @expr{B}. |
d7b8e6c6 EZ |
20452 | Thus subtracting @samp{[y,z]} from a set will remove the elements |
20453 | @samp{y} and @samp{z} if they are present. You can also think of this | |
a4231b04 JB |
20454 | as a general @dfn{set complement} operator; if @expr{A} is the set of |
20455 | all possible values, then @expr{A - B} is the ``complement'' of @expr{B}. | |
d7b8e6c6 EZ |
20456 | Obviously this is only practical if the set of all possible values in |
20457 | your problem is small enough to list in a Calc vector (or simple | |
20458 | enough to express in a few intervals). | |
20459 | ||
20460 | @kindex V X | |
20461 | @pindex calc-set-xor | |
20462 | @tindex vxor | |
20463 | The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes | |
20464 | the ``exclusive-or,'' or ``symmetric difference'' of two sets. | |
20465 | An object is in the symmetric difference of two sets if and only | |
20466 | if it is in one, but @emph{not} both, of the sets. Objects that | |
20467 | occur in both sets ``cancel out.'' | |
20468 | ||
20469 | @kindex V ~ | |
20470 | @pindex calc-set-complement | |
20471 | @tindex vcompl | |
20472 | The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command | |
20473 | computes the complement of a set with respect to the real numbers. | |
20474 | Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}. | |
20475 | For example, @samp{vcompl([2, (3 .. 4]])} evaluates to | |
20476 | @samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}. | |
20477 | ||
20478 | @kindex V F | |
20479 | @pindex calc-set-floor | |
20480 | @tindex vfloor | |
20481 | The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command | |
20482 | reinterprets a set as a set of integers. Any non-integer values, | |
20483 | and intervals that do not enclose any integers, are removed. Open | |
20484 | intervals are converted to equivalent closed intervals. Successive | |
20485 | integers are converted into intervals of integers. For example, the | |
20486 | complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted | |
20487 | the complement with respect to the set of integers you could type | |
20488 | @kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}. | |
20489 | ||
20490 | @kindex V E | |
20491 | @pindex calc-set-enumerate | |
20492 | @tindex venum | |
20493 | The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command | |
20494 | converts a set of integers into an explicit vector. Intervals in | |
20495 | the set are expanded out to lists of all integers encompassed by | |
20496 | the intervals. This only works for finite sets (i.e., sets which | |
20497 | do not involve @samp{-inf} or @samp{inf}). | |
20498 | ||
20499 | @kindex V : | |
20500 | @pindex calc-set-span | |
20501 | @tindex vspan | |
20502 | The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any | |
20503 | set of reals into an interval form that encompasses all its elements. | |
20504 | The lower limit will be the smallest element in the set; the upper | |
20505 | limit will be the largest element. For an empty set, @samp{vspan([])} | |
20506 | returns the empty interval @w{@samp{[0 .. 0)}}. | |
20507 | ||
20508 | @kindex V # | |
20509 | @pindex calc-set-cardinality | |
20510 | @tindex vcard | |
20511 | The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts | |
20512 | the number of integers in a set. The result is the length of the vector | |
20513 | that would be produced by @kbd{V E}, although the computation is much | |
20514 | more efficient than actually producing that vector. | |
20515 | ||
20516 | @cindex Sets, as binary numbers | |
20517 | Another representation for sets that may be more appropriate in some | |
20518 | cases is binary numbers. If you are dealing with sets of integers | |
20519 | in the range 0 to 49, you can use a 50-bit binary number where a | |
20520 | particular bit is 1 if the corresponding element is in the set. | |
20521 | @xref{Binary Functions}, for a list of commands that operate on | |
20522 | binary numbers. Note that many of the above set operations have | |
20523 | direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}), | |
20524 | @kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}), | |
20525 | @kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}), | |
20526 | respectively. You can use whatever representation for sets is most | |
20527 | convenient to you. | |
20528 | ||
20529 | @kindex b p | |
20530 | @kindex b u | |
20531 | @pindex calc-pack-bits | |
20532 | @pindex calc-unpack-bits | |
20533 | @tindex vpack | |
20534 | @tindex vunpack | |
20535 | The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command | |
20536 | converts an integer that represents a set in binary into a set | |
20537 | in vector/interval notation. For example, @samp{vunpack(67)} | |
20538 | returns @samp{[[0 .. 1], 6]}. If the input is negative, the set | |
20539 | it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}. | |
20540 | Use @kbd{V E} afterwards to expand intervals to individual | |
20541 | values if you wish. Note that this command uses the @kbd{b} | |
20542 | (binary) prefix key. | |
20543 | ||
20544 | The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command | |
20545 | converts the other way, from a vector or interval representing | |
20546 | a set of nonnegative integers into a binary integer describing | |
20547 | the same set. The set may include positive infinity, but must | |
20548 | not include any negative numbers. The input is interpreted as a | |
20549 | set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware | |
20550 | that a simple input like @samp{[100]} can result in a huge integer | |
a4231b04 | 20551 | representation |
8e04863e | 20552 | @texline (@math{2^{100}}, a 31-digit integer, in this case). |
a4231b04 | 20553 | @infoline (@expr{2^100}, a 31-digit integer, in this case). |
d7b8e6c6 EZ |
20554 | |
20555 | @node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions | |
20556 | @section Statistical Operations on Vectors | |
20557 | ||
20558 | @noindent | |
20559 | @cindex Statistical functions | |
20560 | The commands in this section take vectors as arguments and compute | |
20561 | various statistical measures on the data stored in the vectors. The | |
20562 | references used in the definitions of these functions are Bevington's | |
20563 | @emph{Data Reduction and Error Analysis for the Physical Sciences}, | |
20564 | and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and | |
20565 | Vetterling. | |
20566 | ||
20567 | The statistical commands use the @kbd{u} prefix key followed by | |
20568 | a shifted letter or other character. | |
20569 | ||
20570 | @xref{Manipulating Vectors}, for a description of @kbd{V H} | |
20571 | (@code{calc-histogram}). | |
20572 | ||
20573 | @xref{Curve Fitting}, for the @kbd{a F} command for doing | |
20574 | least-squares fits to statistical data. | |
20575 | ||
20576 | @xref{Probability Distribution Functions}, for several common | |
20577 | probability distribution functions. | |
20578 | ||
20579 | @menu | |
20580 | * Single-Variable Statistics:: | |
20581 | * Paired-Sample Statistics:: | |
20582 | @end menu | |
20583 | ||
20584 | @node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations | |
20585 | @subsection Single-Variable Statistics | |
20586 | ||
20587 | @noindent | |
20588 | These functions do various statistical computations on single | |
20589 | vectors. Given a numeric prefix argument, they actually pop | |
20590 | @var{n} objects from the stack and combine them into a data | |
20591 | vector. Each object may be either a number or a vector; if a | |
20592 | vector, any sub-vectors inside it are ``flattened'' as if by | |
20593 | @kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object | |
20594 | is popped, which (in order to be useful) is usually a vector. | |
20595 | ||
20596 | If an argument is a variable name, and the value stored in that | |
20597 | variable is a vector, then the stored vector is used. This method | |
20598 | has the advantage that if your data vector is large, you can avoid | |
20599 | the slow process of manipulating it directly on the stack. | |
20600 | ||
20601 | These functions are left in symbolic form if any of their arguments | |
20602 | are not numbers or vectors, e.g., if an argument is a formula, or | |
20603 | a non-vector variable. However, formulas embedded within vector | |
20604 | arguments are accepted; the result is a symbolic representation | |
20605 | of the computation, based on the assumption that the formula does | |
20606 | not itself represent a vector. All varieties of numbers such as | |
20607 | error forms and interval forms are acceptable. | |
20608 | ||
20609 | Some of the functions in this section also accept a single error form | |
20610 | or interval as an argument. They then describe a property of the | |
20611 | normal or uniform (respectively) statistical distribution described | |
20612 | by the argument. The arguments are interpreted in the same way as | |
20613 | the @var{M} argument of the random number function @kbd{k r}. In | |
20614 | particular, an interval with integer limits is considered an integer | |
20615 | distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}. | |
20616 | An interval with at least one floating-point limit is a continuous | |
20617 | distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as | |
20618 | @samp{[2.0 .. 5.0]}! | |
20619 | ||
20620 | @kindex u # | |
20621 | @pindex calc-vector-count | |
20622 | @tindex vcount | |
20623 | The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command | |
20624 | computes the number of data values represented by the inputs. | |
20625 | For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7. | |
20626 | If the argument is a single vector with no sub-vectors, this | |
20627 | simply computes the length of the vector. | |
20628 | ||
20629 | @kindex u + | |
20630 | @kindex u * | |
20631 | @pindex calc-vector-sum | |
20632 | @pindex calc-vector-prod | |
20633 | @tindex vsum | |
20634 | @tindex vprod | |
20635 | @cindex Summations (statistical) | |
20636 | The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command | |
20637 | computes the sum of the data values. The @kbd{u *} | |
20638 | (@code{calc-vector-prod}) [@code{vprod}] command computes the | |
20639 | product of the data values. If the input is a single flat vector, | |
20640 | these are the same as @kbd{V R +} and @kbd{V R *} | |
a4231b04 | 20641 | (@pxref{Reducing and Mapping}). |
d7b8e6c6 EZ |
20642 | |
20643 | @kindex u X | |
20644 | @kindex u N | |
20645 | @pindex calc-vector-max | |
20646 | @pindex calc-vector-min | |
20647 | @tindex vmax | |
20648 | @tindex vmin | |
20649 | The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command | |
20650 | computes the maximum of the data values, and the @kbd{u N} | |
20651 | (@code{calc-vector-min}) [@code{vmin}] command computes the minimum. | |
20652 | If the argument is an interval, this finds the minimum or maximum | |
20653 | value in the interval. (Note that @samp{vmax([2..6)) = 5} as | |
20654 | described above.) If the argument is an error form, this returns | |
20655 | plus or minus infinity. | |
20656 | ||
20657 | @kindex u M | |
20658 | @pindex calc-vector-mean | |
20659 | @tindex vmean | |
20660 | @cindex Mean of data values | |
20661 | The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command | |
20662 | computes the average (arithmetic mean) of the data values. | |
a4231b04 | 20663 | If the inputs are error forms |
8e04863e | 20664 | @texline @math{x \pm \sigma}, |
a4231b04 JB |
20665 | @infoline @samp{x +/- s}, |
20666 | this is the weighted mean of the @expr{x} values with weights | |
8e04863e | 20667 | @texline @math{1 /\sigma^2}. |
a4231b04 | 20668 | @infoline @expr{1 / s^2}. |
d7b8e6c6 EZ |
20669 | @tex |
20670 | \turnoffactive | |
20671 | $$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over | |
20672 | \displaystyle \sum { 1 \over \sigma_i^2 } } $$ | |
20673 | @end tex | |
20674 | If the inputs are not error forms, this is simply the sum of the | |
a4231b04 | 20675 | values divided by the count of the values. |
d7b8e6c6 EZ |
20676 | |
20677 | Note that a plain number can be considered an error form with | |
a4231b04 | 20678 | error |
8e04863e | 20679 | @texline @math{\sigma = 0}. |
a4231b04 JB |
20680 | @infoline @expr{s = 0}. |
20681 | If the input to @kbd{u M} is a mixture of | |
d7b8e6c6 EZ |
20682 | plain numbers and error forms, the result is the mean of the |
20683 | plain numbers, ignoring all values with non-zero errors. (By the | |
20684 | above definitions it's clear that a plain number effectively | |
20685 | has an infinite weight, next to which an error form with a finite | |
20686 | weight is completely negligible.) | |
20687 | ||
20688 | This function also works for distributions (error forms or | |
bd712b70 | 20689 | intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply |
a4231b04 | 20690 | @expr{a}. The mean of an interval is the mean of the minimum |
d7b8e6c6 EZ |
20691 | and maximum values of the interval. |
20692 | ||
20693 | @kindex I u M | |
20694 | @pindex calc-vector-mean-error | |
20695 | @tindex vmeane | |
20696 | The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}] | |
20697 | command computes the mean of the data points expressed as an | |
20698 | error form. This includes the estimated error associated with | |
20699 | the mean. If the inputs are error forms, the error is the square | |
20700 | root of the reciprocal of the sum of the reciprocals of the squares | |
20701 | of the input errors. (I.e., the variance is the reciprocal of the | |
20702 | sum of the reciprocals of the variances.) | |
20703 | @tex | |
20704 | \turnoffactive | |
20705 | $$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$ | |
20706 | @end tex | |
20707 | If the inputs are plain | |
20708 | numbers, the error is equal to the standard deviation of the values | |
20709 | divided by the square root of the number of values. (This works | |
20710 | out to be equivalent to calculating the standard deviation and | |
20711 | then assuming each value's error is equal to this standard | |
a4231b04 | 20712 | deviation.) |
d7b8e6c6 EZ |
20713 | @tex |
20714 | \turnoffactive | |
20715 | $$ \sigma_\mu^2 = {\sigma^2 \over N} $$ | |
20716 | @end tex | |
20717 | ||
20718 | @kindex H u M | |
20719 | @pindex calc-vector-median | |
20720 | @tindex vmedian | |
20721 | @cindex Median of data values | |
20722 | The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}] | |
20723 | command computes the median of the data values. The values are | |
20724 | first sorted into numerical order; the median is the middle | |
20725 | value after sorting. (If the number of data values is even, | |
20726 | the median is taken to be the average of the two middle values.) | |
20727 | The median function is different from the other functions in | |
20728 | this section in that the arguments must all be real numbers; | |
20729 | variables are not accepted even when nested inside vectors. | |
20730 | (Otherwise it is not possible to sort the data values.) If | |
20731 | any of the input values are error forms, their error parts are | |
20732 | ignored. | |
20733 | ||
20734 | The median function also accepts distributions. For both normal | |
20735 | (error form) and uniform (interval) distributions, the median is | |
20736 | the same as the mean. | |
20737 | ||
20738 | @kindex H I u M | |
20739 | @pindex calc-vector-harmonic-mean | |
20740 | @tindex vhmean | |
20741 | @cindex Harmonic mean | |
20742 | The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}] | |
20743 | command computes the harmonic mean of the data values. This is | |
20744 | defined as the reciprocal of the arithmetic mean of the reciprocals | |
20745 | of the values. | |
20746 | @tex | |
20747 | \turnoffactive | |
20748 | $$ { N \over \displaystyle \sum {1 \over x_i} } $$ | |
20749 | @end tex | |
20750 | ||
20751 | @kindex u G | |
20752 | @pindex calc-vector-geometric-mean | |
20753 | @tindex vgmean | |
20754 | @cindex Geometric mean | |
20755 | The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}] | |
20756 | command computes the geometric mean of the data values. This | |
5d67986c | 20757 | is the @var{n}th root of the product of the values. This is also |
d7b8e6c6 EZ |
20758 | equal to the @code{exp} of the arithmetic mean of the logarithms |
20759 | of the data values. | |
20760 | @tex | |
20761 | \turnoffactive | |
20762 | $$ \exp \left ( \sum { \ln x_i } \right ) = | |
20763 | \left ( \prod { x_i } \right)^{1 / N} $$ | |
20764 | @end tex | |
20765 | ||
20766 | @kindex H u G | |
20767 | @tindex agmean | |
20768 | The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric | |
20769 | mean'' of two numbers taken from the stack. This is computed by | |
20770 | replacing the two numbers with their arithmetic mean and geometric | |
20771 | mean, then repeating until the two values converge. | |
20772 | @tex | |
20773 | \turnoffactive | |
20774 | $$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$ | |
20775 | @end tex | |
20776 | ||
20777 | @cindex Root-mean-square | |
20778 | Another commonly used mean, the RMS (root-mean-square), can be computed | |
20779 | for a vector of numbers simply by using the @kbd{A} command. | |
20780 | ||
20781 | @kindex u S | |
20782 | @pindex calc-vector-sdev | |
20783 | @tindex vsdev | |
20784 | @cindex Standard deviation | |
20785 | @cindex Sample statistics | |
20786 | The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command | |
a4231b04 | 20787 | computes the standard |
8e04863e | 20788 | @texline deviation@tie{}@math{\sigma} |
a4231b04 JB |
20789 | @infoline deviation |
20790 | of the data values. If the values are error forms, the errors are used | |
20791 | as weights just as for @kbd{u M}. This is the @emph{sample} standard | |
20792 | deviation, whose value is the square root of the sum of the squares of | |
20793 | the differences between the values and the mean of the @expr{N} values, | |
20794 | divided by @expr{N-1}. | |
d7b8e6c6 EZ |
20795 | @tex |
20796 | \turnoffactive | |
20797 | $$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$ | |
20798 | @end tex | |
20799 | ||
20800 | This function also applies to distributions. The standard deviation | |
20801 | of a single error form is simply the error part. The standard deviation | |
20802 | of a continuous interval happens to equal the difference between the | |
a4231b04 | 20803 | limits, divided by |
8e04863e | 20804 | @texline @math{\sqrt{12}}. |
a4231b04 JB |
20805 | @infoline @expr{sqrt(12)}. |
20806 | The standard deviation of an integer interval is the same as the | |
20807 | standard deviation of a vector of those integers. | |
d7b8e6c6 EZ |
20808 | |
20809 | @kindex I u S | |
20810 | @pindex calc-vector-pop-sdev | |
20811 | @tindex vpsdev | |
20812 | @cindex Population statistics | |
20813 | The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}] | |
20814 | command computes the @emph{population} standard deviation. | |
20815 | It is defined by the same formula as above but dividing | |
a4231b04 | 20816 | by @expr{N} instead of by @expr{N-1}. The population standard |
d7b8e6c6 EZ |
20817 | deviation is used when the input represents the entire set of |
20818 | data values in the distribution; the sample standard deviation | |
20819 | is used when the input represents a sample of the set of all | |
20820 | data values, so that the mean computed from the input is itself | |
20821 | only an estimate of the true mean. | |
20822 | @tex | |
20823 | \turnoffactive | |
20824 | $$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$ | |
20825 | @end tex | |
20826 | ||
20827 | For error forms and continuous intervals, @code{vpsdev} works | |
20828 | exactly like @code{vsdev}. For integer intervals, it computes the | |
20829 | population standard deviation of the equivalent vector of integers. | |
20830 | ||
20831 | @kindex H u S | |
20832 | @kindex H I u S | |
20833 | @pindex calc-vector-variance | |
20834 | @pindex calc-vector-pop-variance | |
20835 | @tindex vvar | |
20836 | @tindex vpvar | |
20837 | @cindex Variance of data values | |
20838 | The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and | |
20839 | @kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}] | |
20840 | commands compute the variance of the data values. The variance | |
a4231b04 | 20841 | is the |
8e04863e | 20842 | @texline square@tie{}@math{\sigma^2} |
a4231b04 JB |
20843 | @infoline square |
20844 | of the standard deviation, i.e., the sum of the | |
d7b8e6c6 EZ |
20845 | squares of the deviations of the data values from the mean. |
20846 | (This definition also applies when the argument is a distribution.) | |
20847 | ||
5d67986c RS |
20848 | @ignore |
20849 | @starindex | |
20850 | @end ignore | |
d7b8e6c6 EZ |
20851 | @tindex vflat |
20852 | The @code{vflat} algebraic function returns a vector of its | |
20853 | arguments, interpreted in the same way as the other functions | |
20854 | in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)} | |
20855 | returns @samp{[1, 2, 3, 4, 5]}. | |
20856 | ||
20857 | @node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations | |
20858 | @subsection Paired-Sample Statistics | |
20859 | ||
20860 | @noindent | |
20861 | The functions in this section take two arguments, which must be | |
20862 | vectors of equal size. The vectors are each flattened in the same | |
20863 | way as by the single-variable statistical functions. Given a numeric | |
20864 | prefix argument of 1, these functions instead take one object from | |
a4231b04 | 20865 | the stack, which must be an |
8e04863e | 20866 | @texline @math{N\times2} |
a4231b04 JB |
20867 | @infoline Nx2 |
20868 | matrix of data values. Once again, variable names can be used in place | |
20869 | of actual vectors and matrices. | |
d7b8e6c6 EZ |
20870 | |
20871 | @kindex u C | |
20872 | @pindex calc-vector-covariance | |
20873 | @tindex vcov | |
20874 | @cindex Covariance | |
20875 | The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command | |
20876 | computes the sample covariance of two vectors. The covariance | |
20877 | of vectors @var{x} and @var{y} is the sum of the products of the | |
20878 | differences between the elements of @var{x} and the mean of @var{x} | |
20879 | times the differences between the corresponding elements of @var{y} | |
a4231b04 | 20880 | and the mean of @var{y}, all divided by @expr{N-1}. Note that |
d7b8e6c6 EZ |
20881 | the variance of a vector is just the covariance of the vector |
20882 | with itself. Once again, if the inputs are error forms the | |
20883 | errors are used as weight factors. If both @var{x} and @var{y} | |
20884 | are composed of error forms, the error for a given data point | |
20885 | is taken as the square root of the sum of the squares of the two | |
20886 | input errors. | |
20887 | @tex | |
20888 | \turnoffactive | |
20889 | $$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$ | |
20890 | $$ \sigma_{x\!y}^2 = | |
20891 | {\displaystyle {1 \over N-1} | |
20892 | \sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2} | |
20893 | \over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}} | |
20894 | $$ | |
20895 | @end tex | |
20896 | ||
20897 | @kindex I u C | |
20898 | @pindex calc-vector-pop-covariance | |
20899 | @tindex vpcov | |
20900 | The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}] | |
20901 | command computes the population covariance, which is the same as the | |
a4231b04 JB |
20902 | sample covariance computed by @kbd{u C} except dividing by @expr{N} |
20903 | instead of @expr{N-1}. | |
d7b8e6c6 EZ |
20904 | |
20905 | @kindex H u C | |
20906 | @pindex calc-vector-correlation | |
20907 | @tindex vcorr | |
20908 | @cindex Correlation coefficient | |
20909 | @cindex Linear correlation | |
20910 | The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}] | |
20911 | command computes the linear correlation coefficient of two vectors. | |
20912 | This is defined by the covariance of the vectors divided by the | |
20913 | product of their standard deviations. (There is no difference | |
20914 | between sample or population statistics here.) | |
20915 | @tex | |
20916 | \turnoffactive | |
20917 | $$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$ | |
20918 | @end tex | |
20919 | ||
20920 | @node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions | |
20921 | @section Reducing and Mapping Vectors | |
20922 | ||
20923 | @noindent | |
20924 | The commands in this section allow for more general operations on the | |
20925 | elements of vectors. | |
20926 | ||
20927 | @kindex V A | |
20928 | @pindex calc-apply | |
20929 | @tindex apply | |
20930 | The simplest of these operations is @kbd{V A} (@code{calc-apply}) | |
20931 | [@code{apply}], which applies a given operator to the elements of a vector. | |
20932 | For example, applying the hypothetical function @code{f} to the vector | |
20933 | @w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}. | |
20934 | Applying the @code{+} function to the vector @samp{[a, b]} gives | |
20935 | @samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an | |
20936 | error, since the @code{+} function expects exactly two arguments. | |
20937 | ||
20938 | While @kbd{V A} is useful in some cases, you will usually find that either | |
20939 | @kbd{V R} or @kbd{V M}, described below, is closer to what you want. | |
20940 | ||
20941 | @menu | |
20942 | * Specifying Operators:: | |
20943 | * Mapping:: | |
20944 | * Reducing:: | |
20945 | * Nesting and Fixed Points:: | |
20946 | * Generalized Products:: | |
20947 | @end menu | |
20948 | ||
20949 | @node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping | |
20950 | @subsection Specifying Operators | |
20951 | ||
20952 | @noindent | |
20953 | Commands in this section (like @kbd{V A}) prompt you to press the key | |
20954 | corresponding to the desired operator. Press @kbd{?} for a partial | |
20955 | list of the available operators. Generally, an operator is any key or | |
20956 | sequence of keys that would normally take one or more arguments from | |
20957 | the stack and replace them with a result. For example, @kbd{V A H C} | |
20958 | uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh} | |
20959 | expects one argument, @kbd{V A H C} requires a vector with a single | |
20960 | element as its argument.) | |
20961 | ||
20962 | You can press @kbd{x} at the operator prompt to select any algebraic | |
20963 | function by name to use as the operator. This includes functions you | |
20964 | have defined yourself using the @kbd{Z F} command. (@xref{Algebraic | |
20965 | Definitions}.) If you give a name for which no function has been | |
20966 | defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}. | |
20967 | Calc will prompt for the number of arguments the function takes if it | |
20968 | can't figure it out on its own (say, because you named a function that | |
20969 | is currently undefined). It is also possible to type a digit key before | |
20970 | the function name to specify the number of arguments, e.g., | |
5d67986c | 20971 | @kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it |
d7b8e6c6 EZ |
20972 | looks like it ought to have only two. This technique may be necessary |
20973 | if the function allows a variable number of arguments. For example, | |
20974 | the @kbd{v e} [@code{vexp}] function accepts two or three arguments; | |
20975 | if you want to map with the three-argument version, you will have to | |
20976 | type @kbd{V M 3 v e}. | |
20977 | ||
20978 | It is also possible to apply any formula to a vector by treating that | |
20979 | formula as a function. When prompted for the operator to use, press | |
20980 | @kbd{'} (the apostrophe) and type your formula as an algebraic entry. | |
20981 | You will then be prompted for the argument list, which defaults to a | |
20982 | list of all variables that appear in the formula, sorted into alphabetic | |
20983 | order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}. | |
20984 | The default argument list would be @samp{(x y)}, which means that if | |
20985 | this function is applied to the arguments @samp{[3, 10]} the result will | |
20986 | be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this | |
20987 | way often, you might consider defining it as a function with @kbd{Z F}.) | |
20988 | ||
20989 | Another way to specify the arguments to the formula you enter is with | |
20990 | @kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$} | |
20991 | has the same effect as the previous example. The argument list is | |
20992 | automatically taken to be @samp{($$ $)}. (The order of the arguments | |
20993 | may seem backwards, but it is analogous to the way normal algebraic | |
20994 | entry interacts with the stack.) | |
20995 | ||
20996 | If you press @kbd{$} at the operator prompt, the effect is similar to | |
20997 | the apostrophe except that the relevant formula is taken from top-of-stack | |
20998 | instead. The actual vector arguments of the @kbd{V A $} or related command | |
20999 | then start at the second-to-top stack position. You will still be | |
21000 | prompted for an argument list. | |
21001 | ||
21002 | @cindex Nameless functions | |
21003 | @cindex Generic functions | |
21004 | A function can be written without a name using the notation @samp{<#1 - #2>}, | |
21005 | which means ``a function of two arguments that computes the first | |
21006 | argument minus the second argument.'' The symbols @samp{#1} and @samp{#2} | |
21007 | are placeholders for the arguments. You can use any names for these | |
21008 | placeholders if you wish, by including an argument list followed by a | |
5d67986c | 21009 | colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}}, |
d7b8e6c6 | 21010 | Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function |
5d67986c | 21011 | to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}}, |
d7b8e6c6 EZ |
21012 | Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both |
21013 | cases, Calc also writes the nameless function to the Trail so that you | |
21014 | can get it back later if you wish. | |
21015 | ||
21016 | If there is only one argument, you can write @samp{#} in place of @samp{#1}. | |
21017 | (Note that @samp{< >} notation is also used for date forms. Calc tells | |
21018 | that @samp{<@var{stuff}>} is a nameless function by the presence of | |
21019 | @samp{#} signs inside @var{stuff}, or by the fact that @var{stuff} | |
21020 | begins with a list of variables followed by a colon.) | |
21021 | ||
21022 | You can type a nameless function directly to @kbd{V A '}, or put one on | |
21023 | the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an | |
21024 | argument list in this case, since the nameless function specifies the | |
21025 | argument list as well as the function itself. In @kbd{V A '}, you can | |
21026 | omit the @samp{< >} marks if you use @samp{#} notation for the arguments, | |
5d67986c RS |
21027 | so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}}, |
21028 | which in turn is the same as @kbd{V A ' $$+$ @key{RET}}. | |
d7b8e6c6 EZ |
21029 | |
21030 | @cindex Lambda expressions | |
5d67986c RS |
21031 | @ignore |
21032 | @starindex | |
21033 | @end ignore | |
d7b8e6c6 EZ |
21034 | @tindex lambda |
21035 | The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}. | |
21036 | (The word @code{lambda} derives from Lisp notation and the theory of | |
21037 | functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA, | |
21038 | ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called | |
21039 | @code{lambda}; the whole point is that the @code{lambda} expression is | |
21040 | used in its symbolic form, not evaluated for an answer until it is applied | |
21041 | to specific arguments by a command like @kbd{V A} or @kbd{V M}. | |
21042 | ||
21043 | (Actually, @code{lambda} does have one special property: Its arguments | |
21044 | are never evaluated; for example, putting @samp{<(2/3) #>} on the stack | |
21045 | will not simplify the @samp{2/3} until the nameless function is actually | |
21046 | called.) | |
21047 | ||
21048 | @tindex add | |
21049 | @tindex sub | |
5d67986c RS |
21050 | @ignore |
21051 | @mindex @idots | |
21052 | @end ignore | |
d7b8e6c6 | 21053 | @tindex mul |
5d67986c RS |
21054 | @ignore |
21055 | @mindex @null | |
21056 | @end ignore | |
d7b8e6c6 | 21057 | @tindex div |
5d67986c RS |
21058 | @ignore |
21059 | @mindex @null | |
21060 | @end ignore | |
d7b8e6c6 | 21061 | @tindex pow |
5d67986c RS |
21062 | @ignore |
21063 | @mindex @null | |
21064 | @end ignore | |
d7b8e6c6 | 21065 | @tindex neg |
5d67986c RS |
21066 | @ignore |
21067 | @mindex @null | |
21068 | @end ignore | |
d7b8e6c6 | 21069 | @tindex mod |
5d67986c RS |
21070 | @ignore |
21071 | @mindex @null | |
21072 | @end ignore | |
d7b8e6c6 EZ |
21073 | @tindex vconcat |
21074 | As usual, commands like @kbd{V A} have algebraic function name equivalents. | |
21075 | For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to | |
21076 | @samp{apply(gcd, v)}. The first argument specifies the operator name, | |
21077 | and is either a variable whose name is the same as the function name, | |
21078 | or a nameless function like @samp{<#^3+1>}. Operators that are normally | |
21079 | written as algebraic symbols have the names @code{add}, @code{sub}, | |
21080 | @code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and | |
a4231b04 | 21081 | @code{vconcat}. |
d7b8e6c6 | 21082 | |
5d67986c RS |
21083 | @ignore |
21084 | @starindex | |
21085 | @end ignore | |
d7b8e6c6 EZ |
21086 | @tindex call |
21087 | The @code{call} function builds a function call out of several arguments: | |
21088 | @samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which | |
21089 | in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call}, | |
21090 | like the other functions described here, may be either a variable naming a | |
21091 | function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same | |
21092 | as @samp{x + 2y}). | |
21093 | ||
21094 | (Experts will notice that it's not quite proper to use a variable to name | |
21095 | a function, since the name @code{gcd} corresponds to the Lisp variable | |
21096 | @code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc | |
21097 | automatically makes this translation, so you don't have to worry | |
21098 | about it.) | |
21099 | ||
21100 | @node Mapping, Reducing, Specifying Operators, Reducing and Mapping | |
21101 | @subsection Mapping | |
21102 | ||
21103 | @noindent | |
21104 | @kindex V M | |
21105 | @pindex calc-map | |
21106 | @tindex map | |
21107 | The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given | |
21108 | operator elementwise to one or more vectors. For example, mapping | |
21109 | @code{A} [@code{abs}] produces a vector of the absolute values of the | |
21110 | elements in the input vector. Mapping @code{+} pops two vectors from | |
21111 | the stack, which must be of equal length, and produces a vector of the | |
21112 | pairwise sums of the elements. If either argument is a non-vector, it | |
21113 | is duplicated for each element of the other vector. For example, | |
21114 | @kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector. | |
21115 | With the 2 listed first, it would have computed a vector of powers of | |
21116 | two. Mapping a user-defined function pops as many arguments from the | |
21117 | stack as the function requires. If you give an undefined name, you will | |
a4231b04 | 21118 | be prompted for the number of arguments to use. |
d7b8e6c6 EZ |
21119 | |
21120 | If any argument to @kbd{V M} is a matrix, the operator is normally mapped | |
21121 | across all elements of the matrix. For example, given the matrix | |
a4231b04 JB |
21122 | @expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to |
21123 | produce another | |
8e04863e | 21124 | @texline @math{3\times2} |
a4231b04 JB |
21125 | @infoline 3x2 |
21126 | matrix, @expr{[[1, 2, 3], [4, 5, 6]]}. | |
d7b8e6c6 EZ |
21127 | |
21128 | @tindex mapr | |
21129 | The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the | |
21130 | operator prompt) maps by rows instead. For example, @kbd{V M _ A} views | |
21131 | the above matrix as a vector of two 3-element row vectors. It produces | |
21132 | a new vector which contains the absolute values of those row vectors, | |
a4231b04 | 21133 | namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is |
d7b8e6c6 EZ |
21134 | defined as the square root of the sum of the squares of the elements.) |
21135 | Some operators accept vectors and return new vectors; for example, | |
21136 | @kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row | |
a4231b04 | 21137 | of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}. |
d7b8e6c6 EZ |
21138 | |
21139 | Sometimes a vector of vectors (representing, say, strings, sets, or lists) | |
21140 | happens to look like a matrix. If so, remember to use @kbd{V M _} if you | |
21141 | want to map a function across the whole strings or sets rather than across | |
21142 | their individual elements. | |
21143 | ||
21144 | @tindex mapc | |
21145 | The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it | |
21146 | transposes the input matrix, maps by rows, and then, if the result is a | |
21147 | matrix, transposes again. For example, @kbd{V M : A} takes the absolute | |
21148 | values of the three columns of the matrix, treating each as a 2-vector, | |
21149 | and @kbd{V M : v v} reverses the columns to get the matrix | |
a4231b04 | 21150 | @expr{[[-4, 5, -6], [1, -2, 3]]}. |
d7b8e6c6 EZ |
21151 | |
21152 | (The symbols @kbd{_} and @kbd{:} were chosen because they had row-like | |
21153 | and column-like appearances, and were not already taken by useful | |
21154 | operators. Also, they appear shifted on most keyboards so they are easy | |
21155 | to type after @kbd{V M}.) | |
21156 | ||
21157 | The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are | |
21158 | not matrices (so if none of the arguments are matrices, they have no | |
21159 | effect at all). If some of the arguments are matrices and others are | |
21160 | plain numbers, the plain numbers are held constant for all rows of the | |
21161 | matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring | |
21162 | a vector takes a dot product of the vector with itself). | |
21163 | ||
21164 | If some of the arguments are vectors with the same lengths as the | |
21165 | rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix | |
21166 | arguments, those vectors are also held constant for every row or | |
21167 | column. | |
21168 | ||
21169 | Sometimes it is useful to specify another mapping command as the operator | |
21170 | to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +} | |
21171 | to each row of the input matrix, which in turn adds the two values on that | |
21172 | row. If you give another vector-operator command as the operator for | |
21173 | @kbd{V M}, it automatically uses map-by-rows mode if you don't specify | |
21174 | otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If | |
21175 | you really want to map-by-elements another mapping command, you can use | |
21176 | a triple-nested mapping command: @kbd{V M V M V A +} means to map | |
21177 | @kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is | |
21178 | mapped over the elements of each row.) | |
21179 | ||
21180 | @tindex mapa | |
21181 | @tindex mapd | |
21182 | Previous versions of Calc had ``map across'' and ``map down'' modes | |
21183 | that are now considered obsolete; the old ``map across'' is now simply | |
21184 | @kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic | |
21185 | functions @code{mapa} and @code{mapd} are still supported, though. | |
21186 | Note also that, while the old mapping modes were persistent (once you | |
21187 | set the mode, it would apply to later mapping commands until you reset | |
21188 | it), the new @kbd{:} and @kbd{_} modifiers apply only to the current | |
21189 | mapping command. The default @kbd{V M} always means map-by-elements. | |
21190 | ||
21191 | @xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like | |
21192 | @kbd{V M} but for equations and inequalities instead of vectors. | |
21193 | @xref{Storing Variables}, for the @kbd{s m} command which modifies a | |
21194 | variable's stored value using a @kbd{V M}-like operator. | |
21195 | ||
21196 | @node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping | |
21197 | @subsection Reducing | |
21198 | ||
21199 | @noindent | |
21200 | @kindex V R | |
21201 | @pindex calc-reduce | |
21202 | @tindex reduce | |
21203 | The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given | |
21204 | binary operator across all the elements of a vector. A binary operator is | |
21205 | a function such as @code{+} or @code{max} which takes two arguments. For | |
21206 | example, reducing @code{+} over a vector computes the sum of the elements | |
21207 | of the vector. Reducing @code{-} computes the first element minus each of | |
21208 | the remaining elements. Reducing @code{max} computes the maximum element | |
21209 | and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]} | |
21210 | produces @samp{f(f(f(a, b), c), d)}. | |
21211 | ||
21212 | @kindex I V R | |
21213 | @tindex rreduce | |
21214 | The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except | |
21215 | that works from right to left through the vector. For example, plain | |
21216 | @kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d} | |
21217 | but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))}, | |
21218 | or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently | |
21219 | in power series expansions. | |
21220 | ||
21221 | @kindex V U | |
21222 | @tindex accum | |
21223 | The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an | |
21224 | accumulation operation. Here Calc does the corresponding reduction | |
21225 | operation, but instead of producing only the final result, it produces | |
21226 | a vector of all the intermediate results. Accumulating @code{+} over | |
21227 | the vector @samp{[a, b, c, d]} produces the vector | |
21228 | @samp{[a, a + b, a + b + c, a + b + c + d]}. | |
21229 | ||
21230 | @kindex I V U | |
21231 | @tindex raccum | |
21232 | The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation. | |
21233 | For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the | |
21234 | vector @samp{[a - b + c - d, b - c + d, c - d, d]}. | |
21235 | ||
21236 | @tindex reducea | |
21237 | @tindex rreducea | |
21238 | @tindex reduced | |
21239 | @tindex rreduced | |
21240 | As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For | |
a4231b04 JB |
21241 | example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will |
21242 | compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or | |
d7b8e6c6 EZ |
21243 | @kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}] |
21244 | command reduces ``across'' the matrix; it reduces each row of the matrix | |
21245 | as a vector, then collects the results. Thus @kbd{V R _ +} of this | |
a4231b04 JB |
21246 | matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :} |
21247 | [@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d, | |
d7b8e6c6 EZ |
21248 | b + e, c + f]}. |
21249 | ||
21250 | @tindex reducer | |
21251 | @tindex rreducer | |
21252 | There is a third ``by rows'' mode for reduction that is occasionally | |
21253 | useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over | |
21254 | the rows of the matrix themselves. Thus @kbd{V R = +} on the above | |
21255 | matrix would get the same result as @kbd{V R : +}, since adding two | |
21256 | row vectors is equivalent to adding their elements. But @kbd{V R = *} | |
21257 | would multiply the two rows (to get a single number, their dot product), | |
21258 | while @kbd{V R : *} would produce a vector of the products of the columns. | |
21259 | ||
21260 | These three matrix reduction modes work with @kbd{V R} and @kbd{I V R}, | |
21261 | but they are not currently supported with @kbd{V U} or @kbd{I V U}. | |
21262 | ||
21263 | @tindex reducec | |
21264 | @tindex rreducec | |
21265 | The obsolete reduce-by-columns function, @code{reducec}, is still | |
21266 | supported but there is no way to get it through the @kbd{V R} command. | |
21267 | ||
58547c3e JB |
21268 | The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing |
21269 | @kbd{C-x * r} to grab a rectangle of data into Calc, and then typing | |
d7b8e6c6 EZ |
21270 | @kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or |
21271 | rows of the matrix. @xref{Grabbing From Buffers}. | |
21272 | ||
21273 | @node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping | |
21274 | @subsection Nesting and Fixed Points | |
21275 | ||
21276 | @noindent | |
21277 | @kindex H V R | |
21278 | @tindex nest | |
21279 | The @kbd{H V R} [@code{nest}] command applies a function to a given | |
21280 | argument repeatedly. It takes two values, @samp{a} and @samp{n}, from | |
21281 | the stack, where @samp{n} must be an integer. It then applies the | |
21282 | function nested @samp{n} times; if the function is @samp{f} and @samp{n} | |
21283 | is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be | |
21284 | negative if Calc knows an inverse for the function @samp{f}; for | |
21285 | example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}. | |
21286 | ||
21287 | @kindex H V U | |
21288 | @tindex anest | |
21289 | The @kbd{H V U} [@code{anest}] command is an accumulating version of | |
21290 | @code{nest}: It returns a vector of @samp{n+1} values, e.g., | |
21291 | @samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and | |
21292 | @samp{F} is the inverse of @samp{f}, then the result is of the | |
21293 | form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}. | |
21294 | ||
21295 | @kindex H I V R | |
21296 | @tindex fixp | |
21297 | @cindex Fixed points | |
21298 | The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except | |
21299 | that it takes only an @samp{a} value from the stack; the function is | |
21300 | applied until it reaches a ``fixed point,'' i.e., until the result | |
21301 | no longer changes. | |
21302 | ||
21303 | @kindex H I V U | |
21304 | @tindex afixp | |
21305 | The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}. | |
21306 | The first element of the return vector will be the initial value @samp{a}; | |
21307 | the last element will be the final result that would have been returned | |
21308 | by @code{fixp}. | |
21309 | ||
21310 | For example, 0.739085 is a fixed point of the cosine function (in radians): | |
21311 | @samp{cos(0.739085) = 0.739085}. You can find this value by putting, say, | |
21312 | 1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating | |
21313 | version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553, | |
21314 | 0.65329, ...]}. With a precision of six, this command will take 36 steps | |
21315 | to converge to 0.739085.) | |
21316 | ||
21317 | Newton's method for finding roots is a classic example of iteration | |
21318 | to a fixed point. To find the square root of five starting with an | |
21319 | initial guess, Newton's method would look for a fixed point of the | |
21320 | function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack | |
5d67986c | 21321 | and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result |
d7b8e6c6 EZ |
21322 | 2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root}) |
21323 | command to find a root of the equation @samp{x^2 = 5}. | |
21324 | ||
21325 | These examples used numbers for @samp{a} values. Calc keeps applying | |
21326 | the function until two successive results are equal to within the | |
21327 | current precision. For complex numbers, both the real parts and the | |
21328 | imaginary parts must be equal to within the current precision. If | |
21329 | @samp{a} is a formula (say, a variable name), then the function is | |
21330 | applied until two successive results are exactly the same formula. | |
21331 | It is up to you to ensure that the function will eventually converge; | |
21332 | if it doesn't, you may have to press @kbd{C-g} to stop the Calculator. | |
21333 | ||
21334 | The algebraic @code{fixp} function takes two optional arguments, @samp{n} | |
21335 | and @samp{tol}. The first is the maximum number of steps to be allowed, | |
21336 | and must be either an integer or the symbol @samp{inf} (infinity, the | |
21337 | default). The second is a convergence tolerance. If a tolerance is | |
21338 | specified, all results during the calculation must be numbers, not | |
21339 | formulas, and the iteration stops when the magnitude of the difference | |
21340 | between two successive results is less than or equal to the tolerance. | |
21341 | (This implies that a tolerance of zero iterates until the results are | |
21342 | exactly equal.) | |
21343 | ||
21344 | Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)} | |
21345 | computes the square root of @samp{A} given the initial guess @samp{B}, | |
21346 | stopping when the result is correct within the specified tolerance, or | |
21347 | when 20 steps have been taken, whichever is sooner. | |
21348 | ||
21349 | @node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping | |
21350 | @subsection Generalized Products | |
21351 | ||
21352 | @kindex V O | |
21353 | @pindex calc-outer-product | |
21354 | @tindex outer | |
21355 | The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies | |
21356 | a given binary operator to all possible pairs of elements from two | |
21357 | vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]} | |
21358 | and @samp{[x, y, z]} on the stack produces a multiplication table: | |
21359 | @samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of | |
21360 | the result matrix is obtained by applying the operator to element @var{r} | |
21361 | of the lefthand vector and element @var{c} of the righthand vector. | |
21362 | ||
21363 | @kindex V I | |
21364 | @pindex calc-inner-product | |
21365 | @tindex inner | |
21366 | The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes | |
21367 | the generalized inner product of two vectors or matrices, given a | |
21368 | ``multiplicative'' operator and an ``additive'' operator. These can each | |
21369 | actually be any binary operators; if they are @samp{*} and @samp{+}, | |
21370 | respectively, the result is a standard matrix multiplication. Element | |
21371 | @var{r},@var{c} of the result matrix is obtained by mapping the | |
21372 | multiplicative operator across row @var{r} of the lefthand matrix and | |
21373 | column @var{c} of the righthand matrix, and then reducing with the additive | |
21374 | operator. Just as for the standard @kbd{*} command, this can also do a | |
21375 | vector-matrix or matrix-vector inner product, or a vector-vector | |
21376 | generalized dot product. | |
21377 | ||
21378 | Since @kbd{V I} requires two operators, it prompts twice. In each case, | |
21379 | you can use any of the usual methods for entering the operator. If you | |
21380 | use @kbd{$} twice to take both operator formulas from the stack, the | |
21381 | first (multiplicative) operator is taken from the top of the stack | |
21382 | and the second (additive) operator is taken from second-to-top. | |
21383 | ||
21384 | @node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions | |
21385 | @section Vector and Matrix Display Formats | |
21386 | ||
21387 | @noindent | |
21388 | Commands for controlling vector and matrix display use the @kbd{v} prefix | |
21389 | instead of the usual @kbd{d} prefix. But they are display modes; in | |
21390 | particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys | |
21391 | in the same way (@pxref{Display Modes}). Matrix display is also | |
21392 | influenced by the @kbd{d O} (@code{calc-flat-language}) mode; | |
21393 | @pxref{Normal Language Modes}. | |
21394 | ||
21395 | @kindex V < | |
21396 | @pindex calc-matrix-left-justify | |
21397 | @kindex V = | |
21398 | @pindex calc-matrix-center-justify | |
21399 | @kindex V > | |
21400 | @pindex calc-matrix-right-justify | |
21401 | The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >} | |
21402 | (@code{calc-matrix-right-justify}), and @w{@kbd{v =}} | |
21403 | (@code{calc-matrix-center-justify}) control whether matrix elements | |
a4231b04 | 21404 | are justified to the left, right, or center of their columns. |
d7b8e6c6 EZ |
21405 | |
21406 | @kindex V [ | |
21407 | @pindex calc-vector-brackets | |
21408 | @kindex V @{ | |
21409 | @pindex calc-vector-braces | |
21410 | @kindex V ( | |
21411 | @pindex calc-vector-parens | |
21412 | The @kbd{v [} (@code{calc-vector-brackets}) command turns the square | |
21413 | brackets that surround vectors and matrices displayed in the stack on | |
21414 | and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (} | |
21415 | (@code{calc-vector-parens}) commands use curly braces or parentheses, | |
21416 | respectively, instead of square brackets. For example, @kbd{v @{} might | |
21417 | be used in preparation for yanking a matrix into a buffer running | |
21418 | Mathematica. (In fact, the Mathematica language mode uses this mode; | |
21419 | @pxref{Mathematica Language Mode}.) Note that, regardless of the | |
21420 | display mode, either brackets or braces may be used to enter vectors, | |
a4231b04 | 21421 | and parentheses may never be used for this purpose. |
d7b8e6c6 EZ |
21422 | |
21423 | @kindex V ] | |
21424 | @pindex calc-matrix-brackets | |
21425 | The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the | |
21426 | ``big'' style display of matrices. It prompts for a string of code | |
21427 | letters; currently implemented letters are @code{R}, which enables | |
21428 | brackets on each row of the matrix; @code{O}, which enables outer | |
21429 | brackets in opposite corners of the matrix; and @code{C}, which | |
21430 | enables commas or semicolons at the ends of all rows but the last. | |
21431 | The default format is @samp{RO}. (Before Calc 2.00, the format | |
21432 | was fixed at @samp{ROC}.) Here are some example matrices: | |
21433 | ||
d7b8e6c6 | 21434 | @example |
5d67986c | 21435 | @group |
d7b8e6c6 EZ |
21436 | [ [ 123, 0, 0 ] [ [ 123, 0, 0 ], |
21437 | [ 0, 123, 0 ] [ 0, 123, 0 ], | |
21438 | [ 0, 0, 123 ] ] [ 0, 0, 123 ] ] | |
21439 | ||
21440 | RO ROC | |
21441 | ||
d7b8e6c6 | 21442 | @end group |
5d67986c | 21443 | @end example |
d7b8e6c6 | 21444 | @noindent |
d7b8e6c6 | 21445 | @example |
5d67986c | 21446 | @group |
d7b8e6c6 EZ |
21447 | [ 123, 0, 0 [ 123, 0, 0 ; |
21448 | 0, 123, 0 0, 123, 0 ; | |
21449 | 0, 0, 123 ] 0, 0, 123 ] | |
21450 | ||
21451 | O OC | |
21452 | ||
d7b8e6c6 | 21453 | @end group |
5d67986c | 21454 | @end example |
d7b8e6c6 | 21455 | @noindent |
d7b8e6c6 | 21456 | @example |
5d67986c | 21457 | @group |
d7b8e6c6 EZ |
21458 | [ 123, 0, 0 ] 123, 0, 0 |
21459 | [ 0, 123, 0 ] 0, 123, 0 | |
21460 | [ 0, 0, 123 ] 0, 0, 123 | |
21461 | ||
21462 | R @r{blank} | |
d7b8e6c6 | 21463 | @end group |
5d67986c | 21464 | @end example |
d7b8e6c6 EZ |
21465 | |
21466 | @noindent | |
21467 | Note that of the formats shown here, @samp{RO}, @samp{ROC}, and | |
21468 | @samp{OC} are all recognized as matrices during reading, while | |
21469 | the others are useful for display only. | |
21470 | ||
21471 | @kindex V , | |
21472 | @pindex calc-vector-commas | |
21473 | The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and | |
a4231b04 | 21474 | off in vector and matrix display. |
d7b8e6c6 EZ |
21475 | |
21476 | In vectors of length one, and in all vectors when commas have been | |
21477 | turned off, Calc adds extra parentheses around formulas that might | |
21478 | otherwise be ambiguous. For example, @samp{[a b]} could be a vector | |
21479 | of the one formula @samp{a b}, or it could be a vector of two | |
21480 | variables with commas turned off. Calc will display the former | |
21481 | case as @samp{[(a b)]}. You can disable these extra parentheses | |
21482 | (to make the output less cluttered at the expense of allowing some | |
21483 | ambiguity) by adding the letter @code{P} to the control string you | |
21484 | give to @kbd{v ]} (as described above). | |
21485 | ||
21486 | @kindex V . | |
21487 | @pindex calc-full-vectors | |
21488 | The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated | |
21489 | display of long vectors on and off. In this mode, vectors of six | |
21490 | or more elements, or matrices of six or more rows or columns, will | |
21491 | be displayed in an abbreviated form that displays only the first | |
21492 | three elements and the last element: @samp{[a, b, c, ..., z]}. | |
21493 | When very large vectors are involved this will substantially | |
21494 | improve Calc's display speed. | |
21495 | ||
21496 | @kindex t . | |
21497 | @pindex calc-full-trail-vectors | |
21498 | The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a | |
21499 | similar mode for recording vectors in the Trail. If you turn on | |
21500 | this mode, vectors of six or more elements and matrices of six or | |
21501 | more rows or columns will be abbreviated when they are put in the | |
21502 | Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be | |
21503 | unable to recover those vectors. If you are working with very | |
21504 | large vectors, this mode will improve the speed of all operations | |
21505 | that involve the trail. | |
21506 | ||
21507 | @kindex V / | |
21508 | @pindex calc-break-vectors | |
21509 | The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line | |
21510 | vector display on and off. Normally, matrices are displayed with one | |
21511 | row per line but all other types of vectors are displayed in a single | |
21512 | line. This mode causes all vectors, whether matrices or not, to be | |
21513 | displayed with a single element per line. Sub-vectors within the | |
21514 | vectors will still use the normal linear form. | |
21515 | ||
21516 | @node Algebra, Units, Matrix Functions, Top | |
21517 | @chapter Algebra | |
21518 | ||
21519 | @noindent | |
21520 | This section covers the Calc features that help you work with | |
21521 | algebraic formulas. First, the general sub-formula selection | |
21522 | mechanism is described; this works in conjunction with any Calc | |
21523 | commands. Then, commands for specific algebraic operations are | |
21524 | described. Finally, the flexible @dfn{rewrite rule} mechanism | |
21525 | is discussed. | |
21526 | ||
21527 | The algebraic commands use the @kbd{a} key prefix; selection | |
21528 | commands use the @kbd{j} (for ``just a letter that wasn't used | |
21529 | for anything else'') prefix. | |
21530 | ||
21531 | @xref{Editing Stack Entries}, to see how to manipulate formulas | |
a4231b04 | 21532 | using regular Emacs editing commands. |
d7b8e6c6 EZ |
21533 | |
21534 | When doing algebraic work, you may find several of the Calculator's | |
07ce2eb3 JB |
21535 | modes to be helpful, including Algebraic Simplification mode (@kbd{m A}) |
21536 | or No-Simplification mode (@kbd{m O}), | |
21537 | Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and | |
21538 | Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions | |
21539 | of these modes. You may also wish to select Big display mode (@kbd{d B}). | |
a4231b04 | 21540 | @xref{Normal Language Modes}. |
d7b8e6c6 EZ |
21541 | |
21542 | @menu | |
21543 | * Selecting Subformulas:: | |
21544 | * Algebraic Manipulation:: | |
21545 | * Simplifying Formulas:: | |
21546 | * Polynomials:: | |
21547 | * Calculus:: | |
21548 | * Solving Equations:: | |
21549 | * Numerical Solutions:: | |
21550 | * Curve Fitting:: | |
21551 | * Summations:: | |
21552 | * Logical Operations:: | |
21553 | * Rewrite Rules:: | |
21554 | @end menu | |
21555 | ||
21556 | @node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra | |
21557 | @section Selecting Sub-Formulas | |
21558 | ||
21559 | @noindent | |
21560 | @cindex Selections | |
21561 | @cindex Sub-formulas | |
21562 | @cindex Parts of formulas | |
21563 | When working with an algebraic formula it is often necessary to | |
21564 | manipulate a portion of the formula rather than the formula as a | |
21565 | whole. Calc allows you to ``select'' a portion of any formula on | |
21566 | the stack. Commands which would normally operate on that stack | |
21567 | entry will now operate only on the sub-formula, leaving the | |
21568 | surrounding part of the stack entry alone. | |
21569 | ||
21570 | One common non-algebraic use for selection involves vectors. To work | |
21571 | on one element of a vector in-place, simply select that element as a | |
21572 | ``sub-formula'' of the vector. | |
21573 | ||
21574 | @menu | |
21575 | * Making Selections:: | |
21576 | * Changing Selections:: | |
21577 | * Displaying Selections:: | |
21578 | * Operating on Selections:: | |
21579 | * Rearranging with Selections:: | |
21580 | @end menu | |
21581 | ||
21582 | @node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas | |
21583 | @subsection Making Selections | |
21584 | ||
21585 | @noindent | |
21586 | @kindex j s | |
21587 | @pindex calc-select-here | |
21588 | To select a sub-formula, move the Emacs cursor to any character in that | |
21589 | sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will | |
21590 | highlight the smallest portion of the formula that contains that | |
21591 | character. By default the sub-formula is highlighted by blanking out | |
21592 | all of the rest of the formula with dots. Selection works in any | |
07ce2eb3 | 21593 | display mode but is perhaps easiest in Big mode (@kbd{d B}). |
d7b8e6c6 EZ |
21594 | Suppose you enter the following formula: |
21595 | ||
d7b8e6c6 | 21596 | @smallexample |
5d67986c | 21597 | @group |
d7b8e6c6 EZ |
21598 | 3 ___ |
21599 | (a + b) + V c | |
21600 | 1: --------------- | |
21601 | 2 x + 1 | |
d7b8e6c6 | 21602 | @end group |
5d67986c | 21603 | @end smallexample |
d7b8e6c6 EZ |
21604 | |
21605 | @noindent | |
21606 | (by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the | |
21607 | cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes | |
21608 | to | |
21609 | ||
d7b8e6c6 | 21610 | @smallexample |
5d67986c | 21611 | @group |
d7b8e6c6 EZ |
21612 | . ... |
21613 | .. . b. . . . | |
21614 | 1* ............... | |
21615 | . . . . | |
d7b8e6c6 | 21616 | @end group |
5d67986c | 21617 | @end smallexample |
d7b8e6c6 EZ |
21618 | |
21619 | @noindent | |
21620 | Every character not part of the sub-formula @samp{b} has been changed | |
21621 | to a dot. The @samp{*} next to the line number is to remind you that | |
21622 | the formula has a portion of it selected. (In this case, it's very | |
07ce2eb3 | 21623 | obvious, but it might not always be. If Embedded mode is enabled, |
d7b8e6c6 EZ |
21624 | the word @samp{Sel} also appears in the mode line because the stack |
21625 | may not be visible. @pxref{Embedded Mode}.) | |
21626 | ||
21627 | If you had instead placed the cursor on the parenthesis immediately to | |
21628 | the right of the @samp{b}, the selection would have been: | |
21629 | ||
d7b8e6c6 | 21630 | @smallexample |
5d67986c | 21631 | @group |
d7b8e6c6 EZ |
21632 | . ... |
21633 | (a + b) . . . | |
21634 | 1* ............... | |
21635 | . . . . | |
d7b8e6c6 | 21636 | @end group |
5d67986c | 21637 | @end smallexample |
d7b8e6c6 EZ |
21638 | |
21639 | @noindent | |
21640 | The portion selected is always large enough to be considered a complete | |
21641 | formula all by itself, so selecting the parenthesis selects the whole | |
269b7745 | 21642 | formula that it encloses. Putting the cursor on the @samp{+} sign |
d7b8e6c6 EZ |
21643 | would have had the same effect. |
21644 | ||
21645 | (Strictly speaking, the Emacs cursor is really the manifestation of | |
21646 | the Emacs ``point,'' which is a position @emph{between} two characters | |
21647 | in the buffer. So purists would say that Calc selects the smallest | |
21648 | sub-formula which contains the character to the right of ``point.'') | |
21649 | ||
21650 | If you supply a numeric prefix argument @var{n}, the selection is | |
21651 | expanded to the @var{n}th enclosing sub-formula. Thus, positioning | |
21652 | the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select | |
21653 | @samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3}, | |
21654 | and so on. | |
21655 | ||
21656 | If the cursor is not on any part of the formula, or if you give a | |
21657 | numeric prefix that is too large, the entire formula is selected. | |
21658 | ||
21659 | If the cursor is on the @samp{.} line that marks the top of the stack | |
21660 | (i.e., its normal ``rest position''), this command selects the entire | |
21661 | formula at stack level 1. Most selection commands similarly operate | |
21662 | on the formula at the top of the stack if you haven't positioned the | |
21663 | cursor on any stack entry. | |
21664 | ||
21665 | @kindex j a | |
21666 | @pindex calc-select-additional | |
21667 | The @kbd{j a} (@code{calc-select-additional}) command enlarges the | |
21668 | current selection to encompass the cursor. To select the smallest | |
21669 | sub-formula defined by two different points, move to the first and | |
21670 | press @kbd{j s}, then move to the other and press @kbd{j a}. This | |
21671 | is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to | |
21672 | select the two ends of a region of text during normal Emacs editing. | |
21673 | ||
21674 | @kindex j o | |
21675 | @pindex calc-select-once | |
21676 | The @kbd{j o} (@code{calc-select-once}) command selects a formula in | |
21677 | exactly the same way as @kbd{j s}, except that the selection will | |
21678 | last only as long as the next command that uses it. For example, | |
21679 | @kbd{j o 1 +} is a handy way to add one to the sub-formula indicated | |
21680 | by the cursor. | |
21681 | ||
21682 | (A somewhat more precise definition: The @kbd{j o} command sets a flag | |
21683 | such that the next command involving selected stack entries will clear | |
21684 | the selections on those stack entries afterwards. All other selection | |
21685 | commands except @kbd{j a} and @kbd{j O} clear this flag.) | |
21686 | ||
21687 | @kindex j S | |
21688 | @kindex j O | |
21689 | @pindex calc-select-here-maybe | |
21690 | @pindex calc-select-once-maybe | |
21691 | The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O} | |
21692 | (@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s} | |
21693 | and @kbd{j o}, respectively, except that if the formula already | |
21694 | has a selection they have no effect. This is analogous to the | |
21695 | behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection}; | |
21696 | @pxref{Selections with Rewrite Rules}) and is mainly intended to be | |
21697 | used in keyboard macros that implement your own selection-oriented | |
a4231b04 | 21698 | commands. |
d7b8e6c6 EZ |
21699 | |
21700 | Selection of sub-formulas normally treats associative terms like | |
21701 | @samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula. | |
21702 | If you place the cursor anywhere inside @samp{a + b - c + d} except | |
21703 | on one of the variable names and use @kbd{j s}, you will select the | |
21704 | entire four-term sum. | |
21705 | ||
21706 | @kindex j b | |
21707 | @pindex calc-break-selections | |
21708 | The @kbd{j b} (@code{calc-break-selections}) command controls a mode | |
21709 | in which the ``deep structure'' of these associative formulas shows | |
21710 | through. Calc actually stores the above formulas as @samp{((a + b) - c) + d} | |
21711 | and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc | |
21712 | treats multiplication as right-associative.) Once you have enabled | |
21713 | @kbd{j b} mode, selecting with the cursor on the @samp{-} sign would | |
21714 | only select the @samp{a + b - c} portion, which makes sense when the | |
21715 | deep structure of the sum is considered. There is no way to select | |
21716 | the @samp{b - c + d} portion; although this might initially look | |
21717 | like just as legitimate a sub-formula as @samp{a + b - c}, the deep | |
21718 | structure shows that it isn't. The @kbd{d U} command can be used | |
21719 | to view the deep structure of any formula (@pxref{Normal Language Modes}). | |
21720 | ||
21721 | When @kbd{j b} mode has not been enabled, the deep structure is | |
21722 | generally hidden by the selection commands---what you see is what | |
21723 | you get. | |
21724 | ||
21725 | @kindex j u | |
21726 | @pindex calc-unselect | |
21727 | The @kbd{j u} (@code{calc-unselect}) command unselects the formula | |
21728 | that the cursor is on. If there was no selection in the formula, | |
21729 | this command has no effect. With a numeric prefix argument, it | |
21730 | unselects the @var{n}th stack element rather than using the cursor | |
21731 | position. | |
21732 | ||
21733 | @kindex j c | |
21734 | @pindex calc-clear-selections | |
21735 | The @kbd{j c} (@code{calc-clear-selections}) command unselects all | |
21736 | stack elements. | |
21737 | ||
21738 | @node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas | |
21739 | @subsection Changing Selections | |
21740 | ||
21741 | @noindent | |
21742 | @kindex j m | |
21743 | @pindex calc-select-more | |
21744 | Once you have selected a sub-formula, you can expand it using the | |
21745 | @w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is | |
21746 | selected, pressing @w{@kbd{j m}} repeatedly works as follows: | |
21747 | ||
d7b8e6c6 | 21748 | @smallexample |
5d67986c | 21749 | @group |
d7b8e6c6 EZ |
21750 | 3 ... 3 ___ 3 ___ |
21751 | (a + b) . . . (a + b) + V c (a + b) + V c | |
21752 | 1* ............... 1* ............... 1* --------------- | |
21753 | . . . . . . . . 2 x + 1 | |
d7b8e6c6 | 21754 | @end group |
5d67986c | 21755 | @end smallexample |
d7b8e6c6 EZ |
21756 | |
21757 | @noindent | |
21758 | In the last example, the entire formula is selected. This is roughly | |
21759 | the same as having no selection at all, but because there are subtle | |
21760 | differences the @samp{*} character is still there on the line number. | |
21761 | ||
21762 | With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n} | |
21763 | times (or until the entire formula is selected). Note that @kbd{j s} | |
21764 | with argument @var{n} is equivalent to plain @kbd{j s} followed by | |
21765 | @kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there | |
21766 | is no current selection, it is equivalent to @w{@kbd{j s}}. | |
21767 | ||
21768 | Even though @kbd{j m} does not explicitly use the location of the | |
21769 | cursor within the formula, it nevertheless uses the cursor to determine | |
21770 | which stack element to operate on. As usual, @kbd{j m} when the cursor | |
21771 | is not on any stack element operates on the top stack element. | |
21772 | ||
21773 | @kindex j l | |
21774 | @pindex calc-select-less | |
21775 | The @kbd{j l} (@code{calc-select-less}) command reduces the current | |
21776 | selection around the cursor position. That is, it selects the | |
21777 | immediate sub-formula of the current selection which contains the | |
21778 | cursor, the opposite of @kbd{j m}. If the cursor is not inside the | |
21779 | current selection, the command de-selects the formula. | |
21780 | ||
21781 | @kindex j 1-9 | |
21782 | @pindex calc-select-part | |
21783 | The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands | |
21784 | select the @var{n}th sub-formula of the current selection. They are | |
21785 | like @kbd{j l} (@code{calc-select-less}) except they use counting | |
21786 | rather than the cursor position to decide which sub-formula to select. | |
21787 | For example, if the current selection is @kbd{a + b + c} or | |
21788 | @kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a}, | |
21789 | @kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of | |
21790 | these cases, @kbd{j 4} through @kbd{j 9} would be errors. | |
21791 | ||
21792 | If there is no current selection, @kbd{j 1} through @kbd{j 9} select | |
21793 | the @var{n}th top-level sub-formula. (In other words, they act as if | |
21794 | the entire stack entry were selected first.) To select the @var{n}th | |
21795 | sub-formula where @var{n} is greater than nine, you must instead invoke | |
a4231b04 | 21796 | @w{@kbd{j 1}} with @var{n} as a numeric prefix argument. |
d7b8e6c6 EZ |
21797 | |
21798 | @kindex j n | |
21799 | @kindex j p | |
21800 | @pindex calc-select-next | |
21801 | @pindex calc-select-previous | |
21802 | The @kbd{j n} (@code{calc-select-next}) and @kbd{j p} | |
21803 | (@code{calc-select-previous}) commands change the current selection | |
21804 | to the next or previous sub-formula at the same level. For example, | |
21805 | if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n} | |
21806 | selects @samp{c}. Further @kbd{j n} commands would be in error because, | |
21807 | even though there is something to the right of @samp{c} (namely, @samp{x}), | |
21808 | it is not at the same level; in this case, it is not a term of the | |
21809 | same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select | |
21810 | the whole product @samp{a*b*c} as a term of the sum) followed by | |
21811 | @w{@kbd{j n}} would successfully select the @samp{x}. | |
21812 | ||
21813 | Similarly, @kbd{j p} moves the selection from the @samp{b} in this | |
21814 | sample formula to the @samp{a}. Both commands accept numeric prefix | |
21815 | arguments to move several steps at a time. | |
21816 | ||
21817 | It is interesting to compare Calc's selection commands with the | |
21818 | Emacs Info system's commands for navigating through hierarchically | |
21819 | organized documentation. Calc's @kbd{j n} command is completely | |
21820 | analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to | |
21821 | @kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}. | |
21822 | (Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.) | |
21823 | The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and | |
21824 | @kbd{j l}; in each case, you can jump directly to a sub-component | |
21825 | of the hierarchy simply by pointing to it with the cursor. | |
21826 | ||
21827 | @node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas | |
21828 | @subsection Displaying Selections | |
21829 | ||
21830 | @noindent | |
21831 | @kindex j d | |
21832 | @pindex calc-show-selections | |
21833 | The @kbd{j d} (@code{calc-show-selections}) command controls how | |
21834 | selected sub-formulas are displayed. One of the alternatives is | |
21835 | illustrated in the above examples; if we press @kbd{j d} we switch | |
21836 | to the other style in which the selected portion itself is obscured | |
21837 | by @samp{#} signs: | |
21838 | ||
d7b8e6c6 | 21839 | @smallexample |
5d67986c | 21840 | @group |
d7b8e6c6 EZ |
21841 | 3 ... # ___ |
21842 | (a + b) . . . ## # ## + V c | |
21843 | 1* ............... 1* --------------- | |
21844 | . . . . 2 x + 1 | |
d7b8e6c6 | 21845 | @end group |
5d67986c | 21846 | @end smallexample |
d7b8e6c6 EZ |
21847 | |
21848 | @node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas | |
21849 | @subsection Operating on Selections | |
21850 | ||
21851 | @noindent | |
21852 | Once a selection is made, all Calc commands that manipulate items | |
21853 | on the stack will operate on the selected portions of the items | |
21854 | instead. (Note that several stack elements may have selections | |
21855 | at once, though there can be only one selection at a time in any | |
21856 | given stack element.) | |
21857 | ||
21858 | @kindex j e | |
21859 | @pindex calc-enable-selections | |
21860 | The @kbd{j e} (@code{calc-enable-selections}) command disables the | |
21861 | effect that selections have on Calc commands. The current selections | |
21862 | still exist, but Calc commands operate on whole stack elements anyway. | |
21863 | This mode can be identified by the fact that the @samp{*} markers on | |
21864 | the line numbers are gone, even though selections are visible. To | |
21865 | reactivate the selections, press @kbd{j e} again. | |
21866 | ||
21867 | To extract a sub-formula as a new formula, simply select the | |
21868 | sub-formula and press @key{RET}. This normally duplicates the top | |
21869 | stack element; here it duplicates only the selected portion of that | |
21870 | element. | |
21871 | ||
21872 | To replace a sub-formula with something different, you can enter the | |
21873 | new value onto the stack and press @key{TAB}. This normally exchanges | |
21874 | the top two stack elements; here it swaps the value you entered into | |
21875 | the selected portion of the formula, returning the old selected | |
21876 | portion to the top of the stack. | |
21877 | ||
d7b8e6c6 | 21878 | @smallexample |
5d67986c | 21879 | @group |
d7b8e6c6 EZ |
21880 | 3 ... ... ___ |
21881 | (a + b) . . . 17 x y . . . 17 x y + V c | |
21882 | 2* ............... 2* ............. 2: ------------- | |
21883 | . . . . . . . . 2 x + 1 | |
21884 | ||
21885 | 3 3 | |
21886 | 1: 17 x y 1: (a + b) 1: (a + b) | |
d7b8e6c6 | 21887 | @end group |
5d67986c | 21888 | @end smallexample |
d7b8e6c6 EZ |
21889 | |
21890 | In this example we select a sub-formula of our original example, | |
21891 | enter a new formula, @key{TAB} it into place, then deselect to see | |
21892 | the complete, edited formula. | |
21893 | ||
21894 | If you want to swap whole formulas around even though they contain | |
21895 | selections, just use @kbd{j e} before and after. | |
21896 | ||
21897 | @kindex j ' | |
21898 | @pindex calc-enter-selection | |
21899 | The @kbd{j '} (@code{calc-enter-selection}) command is another way | |
21900 | to replace a selected sub-formula. This command does an algebraic | |
21901 | entry just like the regular @kbd{'} key. When you press @key{RET}, | |
21902 | the formula you type replaces the original selection. You can use | |
21903 | the @samp{$} symbol in the formula to refer to the original | |
21904 | selection. If there is no selection in the formula under the cursor, | |
21905 | the cursor is used to make a temporary selection for the purposes of | |
21906 | the command. Thus, to change a term of a formula, all you have to | |
21907 | do is move the Emacs cursor to that term and press @kbd{j '}. | |
21908 | ||
21909 | @kindex j ` | |
21910 | @pindex calc-edit-selection | |
21911 | The @kbd{j `} (@code{calc-edit-selection}) command is a similar | |
21912 | analogue of the @kbd{`} (@code{calc-edit}) command. It edits the | |
21913 | selected sub-formula in a separate buffer. If there is no | |
21914 | selection, it edits the sub-formula indicated by the cursor. | |
21915 | ||
21916 | To delete a sub-formula, press @key{DEL}. This generally replaces | |
21917 | the sub-formula with the constant zero, but in a few suitable contexts | |
21918 | it uses the constant one instead. The @key{DEL} key automatically | |
21919 | deselects and re-simplifies the entire formula afterwards. Thus: | |
21920 | ||
d7b8e6c6 | 21921 | @smallexample |
5d67986c | 21922 | @group |
d7b8e6c6 EZ |
21923 | ### |
21924 | 17 x y + # # 17 x y 17 # y 17 y | |
21925 | 1* ------------- 1: ------- 1* ------- 1: ------- | |
21926 | 2 x + 1 2 x + 1 2 x + 1 2 x + 1 | |
d7b8e6c6 | 21927 | @end group |
5d67986c | 21928 | @end smallexample |
d7b8e6c6 EZ |
21929 | |
21930 | In this example, we first delete the @samp{sqrt(c)} term; Calc | |
21931 | accomplishes this by replacing @samp{sqrt(c)} with zero and | |
21932 | resimplifying. We then delete the @kbd{x} in the numerator; | |
21933 | since this is part of a product, Calc replaces it with @samp{1} | |
21934 | and resimplifies. | |
21935 | ||
21936 | If you select an element of a vector and press @key{DEL}, that | |
21937 | element is deleted from the vector. If you delete one side of | |
21938 | an equation or inequality, only the opposite side remains. | |
21939 | ||
5d67986c | 21940 | @kindex j @key{DEL} |
d7b8e6c6 EZ |
21941 | @pindex calc-del-selection |
21942 | The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like | |
21943 | @key{DEL} but with the auto-selecting behavior of @kbd{j '} and | |
21944 | @kbd{j `}. It deletes the selected portion of the formula | |
21945 | indicated by the cursor, or, in the absence of a selection, it | |
21946 | deletes the sub-formula indicated by the cursor position. | |
21947 | ||
5d67986c | 21948 | @kindex j @key{RET} |
d7b8e6c6 EZ |
21949 | @pindex calc-grab-selection |
21950 | (There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection}) | |
21951 | command.) | |
21952 | ||
21953 | Normal arithmetic operations also apply to sub-formulas. Here we | |
21954 | select the denominator, press @kbd{5 -} to subtract five from the | |
21955 | denominator, press @kbd{n} to negate the denominator, then | |
21956 | press @kbd{Q} to take the square root. | |
21957 | ||
d7b8e6c6 | 21958 | @smallexample |
5d67986c | 21959 | @group |
d7b8e6c6 EZ |
21960 | .. . .. . .. . .. . |
21961 | 1* ....... 1* ....... 1* ....... 1* .......... | |
21962 | 2 x + 1 2 x - 4 4 - 2 x _________ | |
21963 | V 4 - 2 x | |
d7b8e6c6 | 21964 | @end group |
5d67986c | 21965 | @end smallexample |
d7b8e6c6 EZ |
21966 | |
21967 | Certain types of operations on selections are not allowed. For | |
21968 | example, for an arithmetic function like @kbd{-} no more than one of | |
21969 | the arguments may be a selected sub-formula. (As the above example | |
21970 | shows, the result of the subtraction is spliced back into the argument | |
21971 | which had the selection; if there were more than one selection involved, | |
21972 | this would not be well-defined.) If you try to subtract two selections, | |
21973 | the command will abort with an error message. | |
21974 | ||
21975 | Operations on sub-formulas sometimes leave the formula as a whole | |
21976 | in an ``un-natural'' state. Consider negating the @samp{2 x} term | |
21977 | of our sample formula by selecting it and pressing @kbd{n} | |
a4231b04 | 21978 | (@code{calc-change-sign}). |
d7b8e6c6 | 21979 | |
d7b8e6c6 | 21980 | @smallexample |
5d67986c | 21981 | @group |
d7b8e6c6 EZ |
21982 | .. . .. . |
21983 | 1* .......... 1* ........... | |
21984 | ......... .......... | |
21985 | . . . 2 x . . . -2 x | |
d7b8e6c6 | 21986 | @end group |
5d67986c | 21987 | @end smallexample |
d7b8e6c6 EZ |
21988 | |
21989 | Unselecting the sub-formula reveals that the minus sign, which would | |
21990 | normally have cancelled out with the subtraction automatically, has | |
21991 | not been able to do so because the subtraction was not part of the | |
21992 | selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing | |
21993 | any other mathematical operation on the whole formula will cause it | |
21994 | to be simplified. | |
21995 | ||
d7b8e6c6 | 21996 | @smallexample |
5d67986c | 21997 | @group |
d7b8e6c6 EZ |
21998 | 17 y 17 y |
21999 | 1: ----------- 1: ---------- | |
22000 | __________ _________ | |
22001 | V 4 - -2 x V 4 + 2 x | |
d7b8e6c6 | 22002 | @end group |
5d67986c | 22003 | @end smallexample |
d7b8e6c6 EZ |
22004 | |
22005 | @node Rearranging with Selections, , Operating on Selections, Selecting Subformulas | |
22006 | @subsection Rearranging Formulas using Selections | |
22007 | ||
22008 | @noindent | |
22009 | @kindex j R | |
22010 | @pindex calc-commute-right | |
22011 | The @kbd{j R} (@code{calc-commute-right}) command moves the selected | |
22012 | sub-formula to the right in its surrounding formula. Generally the | |
22013 | selection is one term of a sum or product; the sum or product is | |
22014 | rearranged according to the commutative laws of algebra. | |
22015 | ||
5d67986c | 22016 | As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used |
d7b8e6c6 EZ |
22017 | if there is no selection in the current formula. All commands described |
22018 | in this section share this property. In this example, we place the | |
22019 | cursor on the @samp{a} and type @kbd{j R}, then repeat. | |
22020 | ||
22021 | @smallexample | |
22022 | 1: a + b - c 1: b + a - c 1: b - c + a | |
22023 | @end smallexample | |
22024 | ||
22025 | @noindent | |
22026 | Note that in the final step above, the @samp{a} is switched with | |
22027 | the @samp{c} but the signs are adjusted accordingly. When moving | |
22028 | terms of sums and products, @kbd{j R} will never change the | |
22029 | mathematical meaning of the formula. | |
22030 | ||
22031 | The selected term may also be an element of a vector or an argument | |
22032 | of a function. The term is exchanged with the one to its right. | |
22033 | In this case, the ``meaning'' of the vector or function may of | |
22034 | course be drastically changed. | |
22035 | ||
22036 | @smallexample | |
22037 | 1: [a, b, c] 1: [b, a, c] 1: [b, c, a] | |
22038 | ||
22039 | 1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a) | |
22040 | @end smallexample | |
22041 | ||
22042 | @kindex j L | |
22043 | @pindex calc-commute-left | |
22044 | The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R} | |
22045 | except that it swaps the selected term with the one to its left. | |
22046 | ||
22047 | With numeric prefix arguments, these commands move the selected | |
22048 | term several steps at a time. It is an error to try to move a | |
22049 | term left or right past the end of its enclosing formula. | |
22050 | With numeric prefix arguments of zero, these commands move the | |
22051 | selected term as far as possible in the given direction. | |
22052 | ||
22053 | @kindex j D | |
22054 | @pindex calc-sel-distribute | |
22055 | The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected | |
22056 | sum or product into the surrounding formula using the distributive | |
22057 | law. For example, in @samp{a * (b - c)} with the @samp{b - c} | |
22058 | selected, the result is @samp{a b - a c}. This also distributes | |
22059 | products or quotients into surrounding powers, and can also do | |
22060 | transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)}, | |
22061 | where @samp{a + b} is the selected term, and @samp{ln(a ^ b)} | |
22062 | to @samp{ln(a) b}, where @samp{a ^ b} is the selected term. | |
22063 | ||
22064 | For multiple-term sums or products, @kbd{j D} takes off one term | |
22065 | at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b} | |
22066 | with the @samp{c - d} selected so that you can type @kbd{j D} | |
22067 | repeatedly to expand completely. The @kbd{j D} command allows a | |
22068 | numeric prefix argument which specifies the maximum number of | |
22069 | times to expand at once; the default is one time only. | |
22070 | ||
22071 | @vindex DistribRules | |
22072 | The @kbd{j D} command is implemented using rewrite rules. | |
22073 | @xref{Selections with Rewrite Rules}. The rules are stored in | |
22074 | the Calc variable @code{DistribRules}. A convenient way to view | |
22075 | these rules is to use @kbd{s e} (@code{calc-edit-variable}) which | |
33108698 | 22076 | displays and edits the stored value of a variable. Press @kbd{C-c C-c} |
d7b8e6c6 EZ |
22077 | to return from editing mode; be careful not to make any actual changes |
22078 | or else you will affect the behavior of future @kbd{j D} commands! | |
22079 | ||
22080 | To extend @kbd{j D} to handle new cases, just edit @code{DistribRules} | |
22081 | as described above. You can then use the @kbd{s p} command to save | |
22082 | this variable's value permanently for future Calc sessions. | |
22083 | @xref{Operations on Variables}. | |
22084 | ||
22085 | @kindex j M | |
22086 | @pindex calc-sel-merge | |
22087 | @vindex MergeRules | |
22088 | The @kbd{j M} (@code{calc-sel-merge}) command is the complement | |
22089 | of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or | |
22090 | @samp{a c} selected, the result is @samp{a * (b - c)}. Once | |
22091 | again, @kbd{j M} can also merge calls to functions like @code{exp} | |
22092 | and @code{ln}; examine the variable @code{MergeRules} to see all | |
22093 | the relevant rules. | |
22094 | ||
22095 | @kindex j C | |
22096 | @pindex calc-sel-commute | |
22097 | @vindex CommuteRules | |
22098 | The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments | |
22099 | of the selected sum, product, or equation. It always behaves as | |
22100 | if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is | |
22101 | treated as the nested sums @samp{(a + b) + c} by this command. | |
22102 | If you put the cursor on the first @samp{+}, the result is | |
22103 | @samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the | |
22104 | result is @samp{c + (a + b)} (which the default simplifications | |
22105 | will rearrange to @samp{(c + a) + b}). The relevant rules are stored | |
22106 | in the variable @code{CommuteRules}. | |
22107 | ||
22108 | You may need to turn default simplifications off (with the @kbd{m O} | |
22109 | command) in order to get the full benefit of @kbd{j C}. For example, | |
22110 | commuting @samp{a - b} produces @samp{-b + a}, but the default | |
22111 | simplifications will ``simplify'' this right back to @samp{a - b} if | |
22112 | you don't turn them off. The same is true of some of the other | |
22113 | manipulations described in this section. | |
22114 | ||
22115 | @kindex j N | |
22116 | @pindex calc-sel-negate | |
22117 | @vindex NegateRules | |
22118 | The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected | |
22119 | term with the negative of that term, then adjusts the surrounding | |
22120 | formula in order to preserve the meaning. For example, given | |
22121 | @samp{exp(a - b)} where @samp{a - b} is selected, the result is | |
22122 | @samp{1 / exp(b - a)}. By contrast, selecting a term and using the | |
22123 | regular @kbd{n} (@code{calc-change-sign}) command negates the | |
22124 | term without adjusting the surroundings, thus changing the meaning | |
22125 | of the formula as a whole. The rules variable is @code{NegateRules}. | |
22126 | ||
22127 | @kindex j & | |
22128 | @pindex calc-sel-invert | |
22129 | @vindex InvertRules | |
22130 | The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N} | |
22131 | except it takes the reciprocal of the selected term. For example, | |
22132 | given @samp{a - ln(b)} with @samp{b} selected, the result is | |
22133 | @samp{a + ln(1/b)}. The rules variable is @code{InvertRules}. | |
22134 | ||
22135 | @kindex j E | |
22136 | @pindex calc-sel-jump-equals | |
22137 | @vindex JumpRules | |
22138 | The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the | |
22139 | selected term from one side of an equation to the other. Given | |
22140 | @samp{a + b = c + d} with @samp{c} selected, the result is | |
22141 | @samp{a + b - c = d}. This command also works if the selected | |
22142 | term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The | |
22143 | relevant rules variable is @code{JumpRules}. | |
22144 | ||
22145 | @kindex j I | |
22146 | @kindex H j I | |
22147 | @pindex calc-sel-isolate | |
22148 | The @kbd{j I} (@code{calc-sel-isolate}) command isolates the | |
22149 | selected term on its side of an equation. It uses the @kbd{a S} | |
22150 | (@code{calc-solve-for}) command to solve the equation, and the | |
22151 | Hyperbolic flag affects it in the same way. @xref{Solving Equations}. | |
22152 | When it applies, @kbd{j I} is often easier to use than @kbd{j E}. | |
22153 | It understands more rules of algebra, and works for inequalities | |
22154 | as well as equations. | |
22155 | ||
22156 | @kindex j * | |
22157 | @kindex j / | |
22158 | @pindex calc-sel-mult-both-sides | |
22159 | @pindex calc-sel-div-both-sides | |
22160 | The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a | |
22161 | formula using algebraic entry, then multiplies both sides of the | |
22162 | selected quotient or equation by that formula. It simplifies each | |
22163 | side with @kbd{a s} (@code{calc-simplify}) before re-forming the | |
22164 | quotient or equation. You can suppress this simplification by | |
22165 | providing any numeric prefix argument. There is also a @kbd{j /} | |
22166 | (@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but | |
22167 | dividing instead of multiplying by the factor you enter. | |
22168 | ||
22169 | As a special feature, if the numerator of the quotient is 1, then | |
22170 | the denominator is expanded at the top level using the distributive | |
22171 | law (i.e., using the @kbd{C-u -1 a x} command). Suppose the | |
22172 | formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish | |
22173 | to eliminate the square root in the denominator by multiplying both | |
22174 | sides by @samp{sqrt(a) - 1}. Calc's default simplifications would | |
22175 | change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)} | |
22176 | right back to the original form by cancellation; Calc expands the | |
22177 | denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent | |
22178 | this. (You would now want to use an @kbd{a x} command to expand | |
22179 | the rest of the way, whereupon the denominator would cancel out to | |
22180 | the desired form, @samp{a - 1}.) When the numerator is not 1, this | |
22181 | initial expansion is not necessary because Calc's default | |
22182 | simplifications will not notice the potential cancellation. | |
22183 | ||
22184 | If the selection is an inequality, @kbd{j *} and @kbd{j /} will | |
22185 | accept any factor, but will warn unless they can prove the factor | |
22186 | is either positive or negative. (In the latter case the direction | |
22187 | of the inequality will be switched appropriately.) @xref{Declarations}, | |
22188 | for ways to inform Calc that a given variable is positive or | |
22189 | negative. If Calc can't tell for sure what the sign of the factor | |
22190 | will be, it will assume it is positive and display a warning | |
22191 | message. | |
22192 | ||
22193 | For selections that are not quotients, equations, or inequalities, | |
22194 | these commands pull out a multiplicative factor: They divide (or | |
22195 | multiply) by the entered formula, simplify, then multiply (or divide) | |
22196 | back by the formula. | |
22197 | ||
22198 | @kindex j + | |
22199 | @kindex j - | |
22200 | @pindex calc-sel-add-both-sides | |
22201 | @pindex calc-sel-sub-both-sides | |
22202 | The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -} | |
22203 | (@code{calc-sel-sub-both-sides}) commands analogously add to or | |
22204 | subtract from both sides of an equation or inequality. For other | |
22205 | types of selections, they extract an additive factor. A numeric | |
22206 | prefix argument suppresses simplification of the intermediate | |
22207 | results. | |
22208 | ||
22209 | @kindex j U | |
22210 | @pindex calc-sel-unpack | |
22211 | The @kbd{j U} (@code{calc-sel-unpack}) command replaces the | |
22212 | selected function call with its argument. For example, given | |
22213 | @samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result | |
22214 | is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you | |
22215 | wanted to change the @code{sin} to @code{cos}, just press @kbd{C} | |
22216 | now to take the cosine of the selected part.) | |
22217 | ||
22218 | @kindex j v | |
22219 | @pindex calc-sel-evaluate | |
22220 | The @kbd{j v} (@code{calc-sel-evaluate}) command performs the | |
22221 | normal default simplifications on the selected sub-formula. | |
22222 | These are the simplifications that are normally done automatically | |
22223 | on all results, but which may have been partially inhibited by | |
22224 | previous selection-related operations, or turned off altogether | |
22225 | by the @kbd{m O} command. This command is just an auto-selecting | |
22226 | version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}). | |
22227 | ||
22228 | With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies | |
22229 | the @kbd{a s} (@code{calc-simplify}) command to the selected | |
22230 | sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v} | |
22231 | applies the @kbd{a e} (@code{calc-simplify-extended}) command. | |
22232 | @xref{Simplifying Formulas}. With a negative prefix argument | |
22233 | it simplifies at the top level only, just as with @kbd{a v}. | |
22234 | Here the ``top'' level refers to the top level of the selected | |
22235 | sub-formula. | |
22236 | ||
22237 | @kindex j " | |
22238 | @pindex calc-sel-expand-formula | |
22239 | The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "} | |
22240 | (@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}. | |
22241 | ||
22242 | You can use the @kbd{j r} (@code{calc-rewrite-selection}) command | |
22243 | to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}. | |
22244 | ||
22245 | @node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra | |
22246 | @section Algebraic Manipulation | |
22247 | ||
22248 | @noindent | |
22249 | The commands in this section perform general-purpose algebraic | |
22250 | manipulations. They work on the whole formula at the top of the | |
22251 | stack (unless, of course, you have made a selection in that | |
22252 | formula). | |
22253 | ||
22254 | Many algebra commands prompt for a variable name or formula. If you | |
22255 | answer the prompt with a blank line, the variable or formula is taken | |
22256 | from top-of-stack, and the normal argument for the command is taken | |
22257 | from the second-to-top stack level. | |
22258 | ||
22259 | @kindex a v | |
22260 | @pindex calc-alg-evaluate | |
22261 | The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal | |
22262 | default simplifications on a formula; for example, @samp{a - -b} is | |
22263 | changed to @samp{a + b}. These simplifications are normally done | |
22264 | automatically on all Calc results, so this command is useful only if | |
22265 | you have turned default simplifications off with an @kbd{m O} | |
22266 | command. @xref{Simplification Modes}. | |
22267 | ||
22268 | It is often more convenient to type @kbd{=}, which is like @kbd{a v} | |
22269 | but which also substitutes stored values for variables in the formula. | |
22270 | Use @kbd{a v} if you want the variables to ignore their stored values. | |
22271 | ||
22272 | If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies | |
07ce2eb3 | 22273 | as if in Algebraic Simplification mode. This is equivalent to typing |
d7b8e6c6 | 22274 | @kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix |
07ce2eb3 | 22275 | of 3 or more, it uses Extended Simplification mode (@kbd{a e}). |
d7b8e6c6 | 22276 | |
8e04863e | 22277 | If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3}, |
d7b8e6c6 EZ |
22278 | it simplifies in the corresponding mode but only works on the top-level |
22279 | function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will | |
22280 | simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas | |
22281 | @samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector | |
22282 | @samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])} | |
07ce2eb3 | 22283 | in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to |
d7b8e6c6 EZ |
22284 | 10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}. |
22285 | (@xref{Reducing and Mapping}.) | |
22286 | ||
22287 | @tindex evalv | |
22288 | @tindex evalvn | |
22289 | The @kbd{=} command corresponds to the @code{evalv} function, and | |
22290 | the related @kbd{N} command, which is like @kbd{=} but temporarily | |
07ce2eb3 | 22291 | disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds |
d7b8e6c6 EZ |
22292 | to the @code{evalvn} function. (These commands interpret their prefix |
22293 | arguments differently than @kbd{a v}; @kbd{=} treats the prefix as | |
22294 | the number of stack elements to evaluate at once, and @kbd{N} treats | |
22295 | it as a temporary different working precision.) | |
22296 | ||
22297 | The @code{evalvn} function can take an alternate working precision | |
22298 | as an optional second argument. This argument can be either an | |
22299 | integer, to set the precision absolutely, or a vector containing | |
22300 | a single integer, to adjust the precision relative to the current | |
22301 | precision. Note that @code{evalvn} with a larger than current | |
22302 | precision will do the calculation at this higher precision, but the | |
22303 | result will as usual be rounded back down to the current precision | |
22304 | afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision | |
22305 | of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)} | |
22306 | will return @samp{9.26535897932e-5} (computing a 25-digit result which | |
22307 | is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])} | |
22308 | will return @samp{9.2654e-5}. | |
22309 | ||
22310 | @kindex a " | |
22311 | @pindex calc-expand-formula | |
22312 | The @kbd{a "} (@code{calc-expand-formula}) command expands functions | |
22313 | into their defining formulas wherever possible. For example, | |
22314 | @samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions, | |
22315 | like @code{sin} and @code{gcd}, are not defined by simple formulas | |
22316 | and so are unaffected by this command. One important class of | |
22317 | functions which @emph{can} be expanded is the user-defined functions | |
22318 | created by the @kbd{Z F} command. @xref{Algebraic Definitions}. | |
22319 | Other functions which @kbd{a "} can expand include the probability | |
22320 | distribution functions, most of the financial functions, and the | |
22321 | hyperbolic and inverse hyperbolic functions. A numeric prefix argument | |
22322 | affects @kbd{a "} in the same way as it does @kbd{a v}: A positive | |
22323 | argument expands all functions in the formula and then simplifies in | |
22324 | various ways; a negative argument expands and simplifies only the | |
22325 | top-level function call. | |
22326 | ||
22327 | @kindex a M | |
22328 | @pindex calc-map-equation | |
22329 | @tindex mapeq | |
22330 | The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies | |
22331 | a given function or operator to one or more equations. It is analogous | |
22332 | to @kbd{V M}, which operates on vectors instead of equations. | |
22333 | @pxref{Reducing and Mapping}. For example, @kbd{a M S} changes | |
22334 | @samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with | |
a4231b04 | 22335 | @samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}. |
d7b8e6c6 EZ |
22336 | With two equations on the stack, @kbd{a M +} would add the lefthand |
22337 | sides together and the righthand sides together to get the two | |
22338 | respective sides of a new equation. | |
22339 | ||
22340 | Mapping also works on inequalities. Mapping two similar inequalities | |
22341 | produces another inequality of the same type. Mapping an inequality | |
22342 | with an equation produces an inequality of the same type. Mapping a | |
22343 | @samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}. | |
22344 | If inequalities with opposite direction (e.g., @samp{<} and @samp{>}) | |
22345 | are mapped, the direction of the second inequality is reversed to | |
22346 | match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2} | |
22347 | reverses the latter to get @samp{2 < a}, which then allows the | |
22348 | combination @samp{a + 2 < b + a}, which the @kbd{a s} command can | |
22349 | then simplify to get @samp{2 < b}. | |
22350 | ||
22351 | Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate | |
22352 | or invert an inequality will reverse the direction of the inequality. | |
22353 | Other adjustments to inequalities are @emph{not} done automatically; | |
22354 | @kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even | |
22355 | though this is not true for all values of the variables. | |
22356 | ||
22357 | @kindex H a M | |
22358 | @tindex mapeqp | |
22359 | With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain | |
22360 | mapping operation without reversing the direction of any inequalities. | |
22361 | Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}. | |
22362 | (This change is mathematically incorrect, but perhaps you were | |
22363 | fixing an inequality which was already incorrect.) | |
22364 | ||
22365 | @kindex I a M | |
22366 | @tindex mapeqr | |
22367 | With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses | |
22368 | the direction of the inequality. You might use @kbd{I a M C} to | |
22369 | change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are | |
22370 | working with small positive angles. | |
22371 | ||
22372 | @kindex a b | |
22373 | @pindex calc-substitute | |
22374 | @tindex subst | |
22375 | The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes | |
22376 | all occurrences | |
22377 | of some variable or sub-expression of an expression with a new | |
22378 | sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)} | |
22379 | in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces | |
22380 | @samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}. | |
22381 | Note that this is a purely structural substitution; the lone @samp{x} and | |
22382 | the @samp{sin(2 x)} stayed the same because they did not look like | |
22383 | @samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for | |
a4231b04 | 22384 | doing substitutions. |
d7b8e6c6 EZ |
22385 | |
22386 | The @kbd{a b} command normally prompts for two formulas, the old | |
22387 | one and the new one. If you enter a blank line for the first | |
22388 | prompt, all three arguments are taken from the stack (new, then old, | |
22389 | then target expression). If you type an old formula but then enter a | |
22390 | blank line for the new one, the new formula is taken from top-of-stack | |
22391 | and the target from second-to-top. If you answer both prompts, the | |
22392 | target is taken from top-of-stack as usual. | |
22393 | ||
22394 | Note that @kbd{a b} has no understanding of commutativity or | |
22395 | associativity. The pattern @samp{x+y} will not match the formula | |
22396 | @samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z} | |
22397 | because the @samp{+} operator is left-associative, so the ``deep | |
22398 | structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U} | |
22399 | (@code{calc-unformatted-language}) mode to see the true structure of | |
22400 | a formula. The rewrite rule mechanism, discussed later, does not have | |
22401 | these limitations. | |
22402 | ||
22403 | As an algebraic function, @code{subst} takes three arguments: | |
22404 | Target expression, old, new. Note that @code{subst} is always | |
22405 | evaluated immediately, even if its arguments are variables, so if | |
22406 | you wish to put a call to @code{subst} onto the stack you must | |
22407 | turn the default simplifications off first (with @kbd{m O}). | |
22408 | ||
22409 | @node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra | |
22410 | @section Simplifying Formulas | |
22411 | ||
22412 | @noindent | |
22413 | @kindex a s | |
22414 | @pindex calc-simplify | |
22415 | @tindex simplify | |
22416 | The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies | |
22417 | various algebraic rules to simplify a formula. This includes rules which | |
22418 | are not part of the default simplifications because they may be too slow | |
22419 | to apply all the time, or may not be desirable all of the time. For | |
22420 | example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a} | |
22421 | to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are | |
22422 | simplified to @samp{x}. | |
22423 | ||
22424 | The sections below describe all the various kinds of algebraic | |
22425 | simplifications Calc provides in full detail. None of Calc's | |
22426 | simplification commands are designed to pull rabbits out of hats; | |
22427 | they simply apply certain specific rules to put formulas into | |
22428 | less redundant or more pleasing forms. Serious algebra in Calc | |
22429 | must be done manually, usually with a combination of selections | |
22430 | and rewrite rules. @xref{Rearranging with Selections}. | |
22431 | @xref{Rewrite Rules}. | |
22432 | ||
22433 | @xref{Simplification Modes}, for commands to control what level of | |
22434 | simplification occurs automatically. Normally only the ``default | |
22435 | simplifications'' occur. | |
22436 | ||
22437 | @menu | |
22438 | * Default Simplifications:: | |
22439 | * Algebraic Simplifications:: | |
22440 | * Unsafe Simplifications:: | |
22441 | * Simplification of Units:: | |
22442 | @end menu | |
22443 | ||
22444 | @node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas | |
22445 | @subsection Default Simplifications | |
22446 | ||
22447 | @noindent | |
22448 | @cindex Default simplifications | |
22449 | This section describes the ``default simplifications,'' those which are | |
22450 | normally applied to all results. For example, if you enter the variable | |
a4231b04 JB |
22451 | @expr{x} on the stack twice and push @kbd{+}, Calc's default |
22452 | simplifications automatically change @expr{x + x} to @expr{2 x}. | |
d7b8e6c6 EZ |
22453 | |
22454 | The @kbd{m O} command turns off the default simplifications, so that | |
a4231b04 | 22455 | @expr{x + x} will remain in this form unless you give an explicit |
d7b8e6c6 EZ |
22456 | ``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic |
22457 | Manipulation}. The @kbd{m D} command turns the default simplifications | |
22458 | back on. | |
22459 | ||
22460 | The most basic default simplification is the evaluation of functions. | |
bd712b70 | 22461 | For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)} |
a4231b04 | 22462 | is evaluated to @expr{3}. Evaluation does not occur if the arguments |
bd712b70 JB |
22463 | to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}), |
22464 | range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}), | |
22465 | or if the function name is not recognized (@expr{@tfn{f}(5)}), or if | |
07ce2eb3 | 22466 | Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation |
bd712b70 | 22467 | (@expr{@tfn{sqrt}(2)}). |
d7b8e6c6 EZ |
22468 | |
22469 | Calc simplifies (evaluates) the arguments to a function before it | |
bd712b70 JB |
22470 | simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is |
22471 | simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function | |
d7b8e6c6 EZ |
22472 | itself is applied. There are very few exceptions to this rule: |
22473 | @code{quote}, @code{lambda}, and @code{condition} (the @code{::} | |
22474 | operator) do not evaluate their arguments, @code{if} (the @code{? :} | |
22475 | operator) does not evaluate all of its arguments, and @code{evalto} | |
22476 | does not evaluate its lefthand argument. | |
22477 | ||
22478 | Most commands apply the default simplifications to all arguments they | |
22479 | take from the stack, perform a particular operation, then simplify | |
22480 | the result before pushing it back on the stack. In the common special | |
22481 | case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}], | |
22482 | the arguments are simply popped from the stack and collected into a | |
22483 | suitable function call, which is then simplified (the arguments being | |
22484 | simplified first as part of the process, as described above). | |
22485 | ||
22486 | The default simplifications are too numerous to describe completely | |
22487 | here, but this section will describe the ones that apply to the | |
22488 | major arithmetic operators. This list will be rather technical in | |
22489 | nature, and will probably be interesting to you only if you are | |
22490 | a serious user of Calc's algebra facilities. | |
22491 | ||
22492 | @tex | |
22493 | \bigskip | |
22494 | @end tex | |
22495 | ||
22496 | As well as the simplifications described here, if you have stored | |
22497 | any rewrite rules in the variable @code{EvalRules} then these rules | |
22498 | will also be applied before any built-in default simplifications. | |
22499 | @xref{Automatic Rewrites}, for details. | |
22500 | ||
22501 | @tex | |
22502 | \bigskip | |
22503 | @end tex | |
22504 | ||
22505 | And now, on with the default simplifications: | |
22506 | ||
22507 | Arithmetic operators like @kbd{+} and @kbd{*} always take two | |
22508 | arguments in Calc's internal form. Sums and products of three or | |
22509 | more terms are arranged by the associative law of algebra into | |
a4231b04 JB |
22510 | a left-associative form for sums, @expr{((a + b) + c) + d}, and |
22511 | a right-associative form for products, @expr{a * (b * (c * d))}. | |
22512 | Formulas like @expr{(a + b) + (c + d)} are rearranged to | |
d7b8e6c6 EZ |
22513 | left-associative form, though this rarely matters since Calc's |
22514 | algebra commands are designed to hide the inner structure of | |
22515 | sums and products as much as possible. Sums and products in | |
22516 | their proper associative form will be written without parentheses | |
22517 | in the examples below. | |
22518 | ||
22519 | Sums and products are @emph{not} rearranged according to the | |
a4231b04 | 22520 | commutative law (@expr{a + b} to @expr{b + a}) except in a few |
d7b8e6c6 EZ |
22521 | special cases described below. Some algebra programs always |
22522 | rearrange terms into a canonical order, which enables them to | |
a4231b04 | 22523 | see that @expr{a b + b a} can be simplified to @expr{2 a b}. |
d7b8e6c6 EZ |
22524 | Calc assumes you have put the terms into the order you want |
22525 | and generally leaves that order alone, with the consequence | |
22526 | that formulas like the above will only be simplified if you | |
22527 | explicitly give the @kbd{a s} command. @xref{Algebraic | |
22528 | Simplifications}. | |
22529 | ||
a4231b04 | 22530 | Differences @expr{a - b} are treated like sums @expr{a + (-b)} |
d7b8e6c6 | 22531 | for purposes of simplification; one of the default simplifications |
a4231b04 JB |
22532 | is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b} |
22533 | represents a ``negative-looking'' term, into @expr{a - b} form. | |
d7b8e6c6 | 22534 | ``Negative-looking'' means negative numbers, negated formulas like |
a4231b04 | 22535 | @expr{-x}, and products or quotients in which either term is |
d7b8e6c6 EZ |
22536 | negative-looking. |
22537 | ||
a4231b04 JB |
22538 | Other simplifications involving negation are @expr{-(-x)} to @expr{x}; |
22539 | @expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is | |
d7b8e6c6 | 22540 | negative-looking, simplified by negating that term, or else where |
a4231b04 JB |
22541 | @expr{a} or @expr{b} is any number, by negating that number; |
22542 | @expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}. | |
22543 | (This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only | |
d7b8e6c6 EZ |
22544 | cases where the order of terms in a sum is changed by the default |
22545 | simplifications.) | |
22546 | ||
22547 | The distributive law is used to simplify sums in some cases: | |
a4231b04 | 22548 | @expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents |
8e04863e | 22549 | a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x}) |
a4231b04 | 22550 | and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or |
d7b8e6c6 EZ |
22551 | @kbd{j M} commands to merge sums with non-numeric coefficients |
22552 | using the distributive law. | |
22553 | ||
22554 | The distributive law is only used for sums of two terms, or | |
a4231b04 JB |
22555 | for adjacent terms in a larger sum. Thus @expr{a + b + b + c} |
22556 | is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b} | |
d7b8e6c6 EZ |
22557 | is not simplified. The reason is that comparing all terms of a |
22558 | sum with one another would require time proportional to the | |
22559 | square of the number of terms; Calc relegates potentially slow | |
22560 | operations like this to commands that have to be invoked | |
22561 | explicitly, like @kbd{a s}. | |
22562 | ||
a4231b04 JB |
22563 | Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}. |
22564 | A consequence of the above rules is that @expr{0 - a} is simplified | |
22565 | to @expr{-a}. | |
d7b8e6c6 EZ |
22566 | |
22567 | @tex | |
22568 | \bigskip | |
22569 | @end tex | |
22570 | ||
a4231b04 JB |
22571 | The products @expr{1 a} and @expr{a 1} are simplified to @expr{a}; |
22572 | @expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a}; | |
22573 | @expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that | |
07ce2eb3 | 22574 | in Matrix mode where @expr{a} is not provably scalar the result |
a4231b04 | 22575 | is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is |
d7b8e6c6 EZ |
22576 | infinite the result is @samp{nan}. |
22577 | ||
a4231b04 | 22578 | Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)}, |
d7b8e6c6 EZ |
22579 | where this occurs for negated formulas but not for regular negative |
22580 | numbers. | |
22581 | ||
22582 | Products are commuted only to move numbers to the front: | |
a4231b04 | 22583 | @expr{a b 2} is commuted to @expr{2 a b}. |
d7b8e6c6 | 22584 | |
a4231b04 JB |
22585 | The product @expr{a (b + c)} is distributed over the sum only if |
22586 | @expr{a} and at least one of @expr{b} and @expr{c} are numbers: | |
22587 | @expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula | |
22588 | @expr{(-a) (b - c)}, where @expr{-a} is a negative number, is | |
22589 | rewritten to @expr{a (c - b)}. | |
d7b8e6c6 EZ |
22590 | |
22591 | The distributive law of products and powers is used for adjacent | |
a4231b04 | 22592 | terms of the product: @expr{x^a x^b} goes to |
8e04863e | 22593 | @texline @math{x^{a+b}} |
a4231b04 JB |
22594 | @infoline @expr{x^(a+b)} |
22595 | where @expr{a} is a number, or an implicit 1 (as in @expr{x}), | |
bd712b70 | 22596 | or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for |
a4231b04 JB |
22597 | @expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt} |
22598 | if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively. | |
d7b8e6c6 | 22599 | If the sum of the powers is zero, the product is simplified to |
07ce2eb3 | 22600 | @expr{1} or to @samp{idn(1)} if Matrix mode is enabled. |
d7b8e6c6 EZ |
22601 | |
22602 | The product of a negative power times anything but another negative | |
a4231b04 | 22603 | power is changed to use division: |
8e04863e | 22604 | @texline @math{x^{-2} y} |
a4231b04 | 22605 | @infoline @expr{x^(-2) y} |
07ce2eb3 | 22606 | goes to @expr{y / x^2} unless Matrix mode is |
a4231b04 | 22607 | in effect and neither @expr{x} nor @expr{y} are scalar (in which |
d7b8e6c6 EZ |
22608 | case it is considered unsafe to rearrange the order of the terms). |
22609 | ||
a4231b04 | 22610 | Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also |
07ce2eb3 | 22611 | @expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode. |
d7b8e6c6 EZ |
22612 | |
22613 | @tex | |
22614 | \bigskip | |
22615 | @end tex | |
22616 | ||
22617 | Simplifications for quotients are analogous to those for products. | |
a4231b04 JB |
22618 | The quotient @expr{0 / x} is simplified to @expr{0}, with the same |
22619 | exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1} | |
22620 | and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x}, | |
d7b8e6c6 EZ |
22621 | respectively. |
22622 | ||
a4231b04 | 22623 | The quotient @expr{x / 0} is left unsimplified or changed to an |
d7b8e6c6 EZ |
22624 | infinite quantity, as directed by the current infinite mode. |
22625 | @xref{Infinite Mode}. | |
22626 | ||
a4231b04 | 22627 | The expression |
8e04863e | 22628 | @texline @math{a / b^{-c}} |
a4231b04 JB |
22629 | @infoline @expr{a / b^(-c)} |
22630 | is changed to @expr{a b^c}, where @expr{-c} is any negative-looking | |
22631 | power. Also, @expr{1 / b^c} is changed to | |
8e04863e | 22632 | @texline @math{b^{-c}} |
a4231b04 JB |
22633 | @infoline @expr{b^(-c)} |
22634 | for any power @expr{c}. | |
22635 | ||
22636 | Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)}; | |
22637 | @expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)} | |
07ce2eb3 | 22638 | goes to @expr{(a c) / b} unless Matrix mode prevents this |
a4231b04 JB |
22639 | rearrangement. Similarly, @expr{a / (b:c)} is simplified to |
22640 | @expr{(c:b) a} for any fraction @expr{b:c}. | |
22641 | ||
22642 | The distributive law is applied to @expr{(a + b) / c} only if | |
22643 | @expr{c} and at least one of @expr{a} and @expr{b} are numbers. | |
d7b8e6c6 EZ |
22644 | Quotients of powers and square roots are distributed just as |
22645 | described for multiplication. | |
22646 | ||
22647 | Quotients of products cancel only in the leading terms of the | |
a4231b04 JB |
22648 | numerator and denominator. In other words, @expr{a x b / a y b} |
22649 | is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once | |
d7b8e6c6 EZ |
22650 | again this is because full cancellation can be slow; use @kbd{a s} |
22651 | to cancel all terms of the quotient. | |
22652 | ||
22653 | Quotients of negative-looking values are simplified according | |
a4231b04 JB |
22654 | to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)} |
22655 | to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}. | |
d7b8e6c6 EZ |
22656 | |
22657 | @tex | |
22658 | \bigskip | |
22659 | @end tex | |
22660 | ||
a4231b04 | 22661 | The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)} |
07ce2eb3 | 22662 | in Matrix mode. The formula @expr{0^x} is simplified to @expr{0} |
f317f9ca JB |
22663 | unless @expr{x} is a negative number, complex number or zero. |
22664 | If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an | |
22665 | infinity or an unsimplified formula according to the current infinite | |
22666 | mode. The expression @expr{0^0} is simplified to @expr{1}. | |
a4231b04 JB |
22667 | |
22668 | Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c} | |
22669 | are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c} | |
22670 | is an integer, or if either @expr{a} or @expr{b} are nonnegative | |
22671 | real numbers. Powers of powers @expr{(a^b)^c} are simplified to | |
8e04863e | 22672 | @texline @math{a^{b c}} |
a4231b04 JB |
22673 | @infoline @expr{a^(b c)} |
22674 | only when @expr{c} is an integer and @expr{b c} also | |
d7b8e6c6 EZ |
22675 | evaluates to an integer. Without these restrictions these simplifications |
22676 | would not be safe because of problems with principal values. | |
a4231b04 | 22677 | (In other words, |
8e04863e | 22678 | @texline @math{((-3)^{1/2})^2} |
a4231b04 JB |
22679 | @infoline @expr{((-3)^1:2)^2} |
22680 | is safe to simplify, but | |
8e04863e | 22681 | @texline @math{((-3)^2)^{1/2}} |
a4231b04 JB |
22682 | @infoline @expr{((-3)^2)^1:2} |
22683 | is not.) @xref{Declarations}, for ways to inform Calc that your | |
22684 | variables satisfy these requirements. | |
22685 | ||
bd712b70 | 22686 | As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to |
8e04863e | 22687 | @texline @math{x^{n/2}} |
a4231b04 JB |
22688 | @infoline @expr{x^(n/2)} |
22689 | only for even integers @expr{n}. | |
22690 | ||
22691 | If @expr{a} is known to be real, @expr{b} is an even integer, and | |
22692 | @expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is | |
bd712b70 | 22693 | simplified to @expr{@tfn{abs}(a^(b c))}. |
a4231b04 JB |
22694 | |
22695 | Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an | |
22696 | even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer, | |
22697 | for any negative-looking expression @expr{-a}. | |
22698 | ||
bd712b70 | 22699 | Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers |
8e04863e | 22700 | @texline @math{x^{1:2}} |
a4231b04 JB |
22701 | @infoline @expr{x^1:2} |
22702 | for the purposes of the above-listed simplifications. | |
22703 | ||
22704 | Also, note that | |
8e04863e | 22705 | @texline @math{1 / x^{1:2}} |
a4231b04 JB |
22706 | @infoline @expr{1 / x^1:2} |
22707 | is changed to | |
8e04863e | 22708 | @texline @math{x^{-1:2}}, |
a4231b04 | 22709 | @infoline @expr{x^(-1:2)}, |
bd712b70 | 22710 | but @expr{1 / @tfn{sqrt}(x)} is left alone. |
d7b8e6c6 EZ |
22711 | |
22712 | @tex | |
22713 | \bigskip | |
22714 | @end tex | |
22715 | ||
22716 | Generic identity matrices (@pxref{Matrix Mode}) are simplified by the | |
bd712b70 | 22717 | following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b} |
a4231b04 | 22718 | is provably scalar, or expanded out if @expr{b} is a matrix; |
bd712b70 JB |
22719 | @expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)}; |
22720 | @expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to | |
22721 | @expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b} | |
22722 | if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to | |
22723 | @expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving | |
22724 | @code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where | |
a4231b04 | 22725 | @expr{n} is an integer. |
d7b8e6c6 EZ |
22726 | |
22727 | @tex | |
22728 | \bigskip | |
22729 | @end tex | |
22730 | ||
22731 | The @code{floor} function and other integer truncation functions | |
22732 | vanish if the argument is provably integer-valued, so that | |
bd712b70 | 22733 | @expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}. |
d7b8e6c6 EZ |
22734 | Also, combinations of @code{float}, @code{floor} and its friends, |
22735 | and @code{ffloor} and its friends, are simplified in appropriate | |
22736 | ways. @xref{Integer Truncation}. | |
22737 | ||
bd712b70 JB |
22738 | The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}. |
22739 | The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to | |
22740 | @expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or | |
a4231b04 JB |
22741 | @expr{-x} if @expr{x} is provably nonnegative or nonpositive |
22742 | (@pxref{Declarations}). | |
d7b8e6c6 EZ |
22743 | |
22744 | While most functions do not recognize the variable @code{i} as an | |
22745 | imaginary number, the @code{arg} function does handle the two cases | |
bd712b70 | 22746 | @expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience. |
d7b8e6c6 | 22747 | |
bd712b70 | 22748 | The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}. |
d7b8e6c6 EZ |
22749 | Various other expressions involving @code{conj}, @code{re}, and |
22750 | @code{im} are simplified, especially if some of the arguments are | |
22751 | provably real or involve the constant @code{i}. For example, | |
bd712b70 JB |
22752 | @expr{@tfn{conj}(a + b i)} is changed to |
22753 | @expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a} | |
a4231b04 | 22754 | and @expr{b} are known to be real. |
d7b8e6c6 EZ |
22755 | |
22756 | Functions like @code{sin} and @code{arctan} generally don't have | |
22757 | any default simplifications beyond simply evaluating the functions | |
22758 | for suitable numeric arguments and infinity. The @kbd{a s} command | |
22759 | described in the next section does provide some simplifications for | |
22760 | these functions, though. | |
22761 | ||
a4231b04 | 22762 | One important simplification that does occur is that |
bd712b70 | 22763 | @expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is |
a4231b04 JB |
22764 | simplified to @expr{x} for any @expr{x}. This occurs even if you have |
22765 | stored a different value in the Calc variable @samp{e}; but this would | |
22766 | be a bad idea in any case if you were also using natural logarithms! | |
d7b8e6c6 | 22767 | |
8305d012 | 22768 | Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to |
bd712b70 | 22769 | @tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides |
d7b8e6c6 EZ |
22770 | are either negative-looking or zero are simplified by negating both sides |
22771 | and reversing the inequality. While it might seem reasonable to simplify | |
a4231b04 JB |
22772 | @expr{!!x} to @expr{x}, this would not be valid in general because |
22773 | @expr{!!2} is 1, not 2. | |
d7b8e6c6 EZ |
22774 | |
22775 | Most other Calc functions have few if any default simplifications | |
22776 | defined, aside of course from evaluation when the arguments are | |
22777 | suitable numbers. | |
22778 | ||
22779 | @node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas | |
22780 | @subsection Algebraic Simplifications | |
22781 | ||
22782 | @noindent | |
22783 | @cindex Algebraic simplifications | |
22784 | The @kbd{a s} command makes simplifications that may be too slow to | |
22785 | do all the time, or that may not be desirable all of the time. | |
22786 | If you find these simplifications are worthwhile, you can type | |
22787 | @kbd{m A} to have Calc apply them automatically. | |
22788 | ||
22789 | This section describes all simplifications that are performed by | |
22790 | the @kbd{a s} command. Note that these occur in addition to the | |
22791 | default simplifications; even if the default simplifications have | |
22792 | been turned off by an @kbd{m O} command, @kbd{a s} will turn them | |
22793 | back on temporarily while it simplifies the formula. | |
22794 | ||
22795 | There is a variable, @code{AlgSimpRules}, in which you can put rewrites | |
22796 | to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules}, | |
22797 | but without the special restrictions. Basically, the simplifier does | |
22798 | @samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole | |
22799 | expression being simplified, then it traverses the expression applying | |
22800 | the built-in rules described below. If the result is different from | |
22801 | the original expression, the process repeats with the default | |
22802 | simplifications (including @code{EvalRules}), then @code{AlgSimpRules}, | |
22803 | then the built-in simplifications, and so on. | |
22804 | ||
22805 | @tex | |
22806 | \bigskip | |
22807 | @end tex | |
22808 | ||
22809 | Sums are simplified in two ways. Constant terms are commuted to the | |
a4231b04 | 22810 | end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}. |
d7b8e6c6 | 22811 | The only exception is that a constant will not be commuted away |
a4231b04 JB |
22812 | from the first position of a difference, i.e., @expr{2 - x} is not |
22813 | commuted to @expr{-x + 2}. | |
d7b8e6c6 EZ |
22814 | |
22815 | Also, terms of sums are combined by the distributive law, as in | |
a4231b04 | 22816 | @expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for |
d7b8e6c6 EZ |
22817 | adjacent terms, but @kbd{a s} compares all pairs of terms including |
22818 | non-adjacent ones. | |
22819 | ||
22820 | @tex | |
22821 | \bigskip | |
22822 | @end tex | |
22823 | ||
22824 | Products are sorted into a canonical order using the commutative | |
a4231b04 | 22825 | law. For example, @expr{b c a} is commuted to @expr{a b c}. |
d7b8e6c6 | 22826 | This allows easier comparison of products; for example, the default |
a4231b04 JB |
22827 | simplifications will not change @expr{x y + y x} to @expr{2 x y}, |
22828 | but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y}, | |
d7b8e6c6 EZ |
22829 | and then the default simplifications are able to recognize a sum |
22830 | of identical terms. | |
22831 | ||
22832 | The canonical ordering used to sort terms of products has the | |
22833 | property that real-valued numbers, interval forms and infinities | |
22834 | come first, and are sorted into increasing order. The @kbd{V S} | |
22835 | command uses the same ordering when sorting a vector. | |
22836 | ||
07ce2eb3 | 22837 | Sorting of terms of products is inhibited when Matrix mode is |
d7b8e6c6 EZ |
22838 | turned on; in this case, Calc will never exchange the order of |
22839 | two terms unless it knows at least one of the terms is a scalar. | |
22840 | ||
22841 | Products of powers are distributed by comparing all pairs of | |
22842 | terms, using the same method that the default simplifications | |
22843 | use for adjacent terms of products. | |
22844 | ||
22845 | Even though sums are not sorted, the commutative law is still | |
22846 | taken into account when terms of a product are being compared. | |
a4231b04 JB |
22847 | Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}. |
22848 | A subtle point is that @expr{(x - y) (y - x)} will @emph{not} | |
22849 | be simplified to @expr{-(x - y)^2}; Calc does not notice that | |
d7b8e6c6 | 22850 | one term can be written as a constant times the other, even if |
8e04863e | 22851 | that constant is @mathit{-1}. |
d7b8e6c6 | 22852 | |
a4231b04 JB |
22853 | A fraction times any expression, @expr{(a:b) x}, is changed to |
22854 | a quotient involving integers: @expr{a x / b}. This is not | |
22855 | done for floating-point numbers like @expr{0.5}, however. This | |
d7b8e6c6 EZ |
22856 | is one reason why you may find it convenient to turn Fraction mode |
22857 | on while doing algebra; @pxref{Fraction Mode}. | |
22858 | ||
22859 | @tex | |
22860 | \bigskip | |
22861 | @end tex | |
22862 | ||
22863 | Quotients are simplified by comparing all terms in the numerator | |
22864 | with all terms in the denominator for possible cancellation using | |
a4231b04 | 22865 | the distributive law. For example, @expr{a x^2 b / c x^3 d} will |
029b2a44 | 22866 | cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}. |
a4231b04 | 22867 | (The terms in the denominator will then be rearranged to @expr{c d x} |
d7b8e6c6 EZ |
22868 | as described above.) If there is any common integer or fractional |
22869 | factor in the numerator and denominator, it is cancelled out; | |
a4231b04 | 22870 | for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}. |
d7b8e6c6 EZ |
22871 | |
22872 | Non-constant common factors are not found even by @kbd{a s}. To | |
a4231b04 JB |
22873 | cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first |
22874 | use @kbd{j M} on the product @expr{a x} to Merge the numerator to | |
22875 | @expr{a (1+x)}, which can then be simplified successfully. | |
d7b8e6c6 EZ |
22876 | |
22877 | @tex | |
22878 | \bigskip | |
22879 | @end tex | |
22880 | ||
22881 | Integer powers of the variable @code{i} are simplified according | |
a4231b04 JB |
22882 | to the identity @expr{i^2 = -1}. If you store a new value other |
22883 | than the complex number @expr{(0,1)} in @code{i}, this simplification | |
d7b8e6c6 EZ |
22884 | will no longer occur. This is done by @kbd{a s} instead of by default |
22885 | in case someone (unwisely) uses the name @code{i} for a variable | |
22886 | unrelated to complex numbers; it would be unfortunate if Calc | |
22887 | quietly and automatically changed this formula for reasons the | |
22888 | user might not have been thinking of. | |
22889 | ||
22890 | Square roots of integer or rational arguments are simplified in | |
22891 | several ways. (Note that these will be left unevaluated only in | |
22892 | Symbolic mode.) First, square integer or rational factors are | |
bd712b70 JB |
22893 | pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as |
22894 | @texline @math{2\,@tfn{sqrt}(2)}. | |
a4231b04 JB |
22895 | @infoline @expr{2 sqrt(2)}. |
22896 | Conceptually speaking this implies factoring the argument into primes | |
22897 | and moving pairs of primes out of the square root, but for reasons of | |
22898 | efficiency Calc only looks for primes up to 29. | |
d7b8e6c6 EZ |
22899 | |
22900 | Square roots in the denominator of a quotient are moved to the | |
bd712b70 | 22901 | numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}. |
d7b8e6c6 | 22902 | The same effect occurs for the square root of a fraction: |
bd712b70 | 22903 | @expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}. |
d7b8e6c6 EZ |
22904 | |
22905 | @tex | |
22906 | \bigskip | |
22907 | @end tex | |
22908 | ||
22909 | The @code{%} (modulo) operator is simplified in several ways | |
a4231b04 JB |
22910 | when the modulus @expr{M} is a positive real number. First, if |
22911 | the argument is of the form @expr{x + n} for some real number | |
22912 | @expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For | |
d7b8e6c6 EZ |
22913 | example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}. |
22914 | ||
22915 | If the argument is multiplied by a constant, and this constant | |
22916 | has a common integer divisor with the modulus, then this factor is | |
22917 | cancelled out. For example, @samp{12 x % 15} is changed to | |
22918 | @samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15} | |
22919 | is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may | |
22920 | not seem ``simpler,'' they allow Calc to discover useful information | |
22921 | about modulo forms in the presence of declarations. | |
22922 | ||
22923 | If the modulus is 1, then Calc can use @code{int} declarations to | |
22924 | evaluate the expression. For example, the idiom @samp{x % 2} is | |
22925 | often used to check whether a number is odd or even. As described | |
22926 | above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to | |
22927 | @samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc | |
22928 | can simplify these to 0 and 1 (respectively) if @code{n} has been | |
22929 | declared to be an integer. | |
22930 | ||
22931 | @tex | |
22932 | \bigskip | |
22933 | @end tex | |
22934 | ||
31c912fc JB |
22935 | Trigonometric functions are simplified in several ways. Whenever a |
22936 | products of two trigonometric functions can be replaced by a single | |
22937 | function, the replacement is made; for example, | |
22938 | @expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}. | |
22939 | Reciprocals of trigonometric functions are replaced by their reciprocal | |
22940 | function; for example, @expr{1/@tfn{sec}(x)} is simplified to | |
22941 | @expr{@tfn{cos}(x)}. The corresponding simplifications for the | |
22942 | hyperbolic functions are also handled. | |
22943 | ||
22944 | Trigonometric functions of their inverse functions are | |
22945 | simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is | |
22946 | simplified to @expr{x}, and similarly for @code{cos} and @code{tan}. | |
d7b8e6c6 | 22947 | Trigonometric functions of inverses of different trigonometric |
bd712b70 JB |
22948 | functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))} |
22949 | to @expr{@tfn{sqrt}(1 - x^2)}. | |
d7b8e6c6 | 22950 | |
31c912fc JB |
22951 | If the argument to @code{sin} is negative-looking, it is simplified to |
22952 | @expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}. | |
22953 | Finally, certain special values of the argument are recognized; | |
22954 | @pxref{Trigonometric and Hyperbolic Functions}. | |
22955 | ||
d7b8e6c6 EZ |
22956 | Hyperbolic functions of their inverses and of negative-looking |
22957 | arguments are also handled, as are exponentials of inverse | |
22958 | hyperbolic functions. | |
22959 | ||
22960 | No simplifications for inverse trigonometric and hyperbolic | |
22961 | functions are known, except for negative arguments of @code{arcsin}, | |
22962 | @code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that | |
bd712b70 | 22963 | @expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to |
a4231b04 | 22964 | @expr{x}, since this only correct within an integer multiple of |
8e04863e | 22965 | @texline @math{2 \pi} |
a4231b04 | 22966 | @infoline @expr{2 pi} |
bd712b70 | 22967 | radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is |
a4231b04 | 22968 | simplified to @expr{x} if @expr{x} is known to be real. |
d7b8e6c6 EZ |
22969 | |
22970 | Several simplifications that apply to logarithms and exponentials | |
bd712b70 JB |
22971 | are that @expr{@tfn{exp}(@tfn{ln}(x))}, |
22972 | @texline @tfn{e}@math{^{\ln(x)}}, | |
22973 | @infoline @expr{e^@tfn{ln}(x)}, | |
a4231b04 | 22974 | and |
8e04863e | 22975 | @texline @math{10^{{\rm log10}(x)}} |
bd712b70 JB |
22976 | @infoline @expr{10^@tfn{log10}(x)} |
22977 | all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can | |
a4231b04 | 22978 | reduce to @expr{x} if @expr{x} is provably real. The form |
bd712b70 | 22979 | @expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x} |
a4231b04 | 22980 | is a suitable multiple of |
8e04863e | 22981 | @texline @math{\pi i} |
a4231b04 JB |
22982 | @infoline @expr{pi i} |
22983 | (as described above for the trigonometric functions), then | |
bd712b70 JB |
22984 | @expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally, |
22985 | @expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and | |
a4231b04 JB |
22986 | @code{i} where @expr{x} is provably negative, positive imaginary, or |
22987 | negative imaginary. | |
d7b8e6c6 EZ |
22988 | |
22989 | The error functions @code{erf} and @code{erfc} are simplified when | |
22990 | their arguments are negative-looking or are calls to the @code{conj} | |
22991 | function. | |
22992 | ||
22993 | @tex | |
22994 | \bigskip | |
22995 | @end tex | |
22996 | ||
22997 | Equations and inequalities are simplified by cancelling factors | |
22998 | of products, quotients, or sums on both sides. Inequalities | |
22999 | change sign if a negative multiplicative factor is cancelled. | |
a4231b04 | 23000 | Non-constant multiplicative factors as in @expr{a b = a c} are |
d7b8e6c6 EZ |
23001 | cancelled from equations only if they are provably nonzero (generally |
23002 | because they were declared so; @pxref{Declarations}). Factors | |
23003 | are cancelled from inequalities only if they are nonzero and their | |
23004 | sign is known. | |
23005 | ||
23006 | Simplification also replaces an equation or inequality with | |
23007 | 1 or 0 (``true'' or ``false'') if it can through the use of | |
a4231b04 JB |
23008 | declarations. If @expr{x} is declared to be an integer greater |
23009 | than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are | |
23010 | all simplified to 0, but @expr{x > 3} is simplified to 1. | |
23011 | By a similar analysis, @expr{abs(x) >= 0} is simplified to 1, | |
23012 | as is @expr{x^2 >= 0} if @expr{x} is known to be real. | |
d7b8e6c6 EZ |
23013 | |
23014 | @node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas | |
23015 | @subsection ``Unsafe'' Simplifications | |
23016 | ||
23017 | @noindent | |
23018 | @cindex Unsafe simplifications | |
23019 | @cindex Extended simplification | |
23020 | @kindex a e | |
23021 | @pindex calc-simplify-extended | |
5d67986c RS |
23022 | @ignore |
23023 | @mindex esimpl@idots | |
23024 | @end ignore | |
d7b8e6c6 EZ |
23025 | @tindex esimplify |
23026 | The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command | |
23027 | is like @kbd{a s} | |
23028 | except that it applies some additional simplifications which are not | |
23029 | ``safe'' in all cases. Use this only if you know the values in your | |
23030 | formula lie in the restricted ranges for which these simplifications | |
23031 | are valid. The symbolic integrator uses @kbd{a e}; | |
23032 | one effect of this is that the integrator's results must be used with | |
23033 | caution. Where an integral table will often attach conditions like | |
a4231b04 JB |
23034 | ``for positive @expr{a} only,'' Calc (like most other symbolic |
23035 | integration programs) will simply produce an unqualified result. | |
d7b8e6c6 EZ |
23036 | |
23037 | Because @kbd{a e}'s simplifications are unsafe, it is sometimes better | |
23038 | to type @kbd{C-u -3 a v}, which does extended simplification only | |
23039 | on the top level of the formula without affecting the sub-formulas. | |
23040 | In fact, @kbd{C-u -3 j v} allows you to target extended simplification | |
23041 | to any specific part of a formula. | |
23042 | ||
23043 | The variable @code{ExtSimpRules} contains rewrites to be applied by | |
23044 | the @kbd{a e} command. These are applied in addition to | |
23045 | @code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules} | |
23046 | step described above is simply followed by an @kbd{a r ExtSimpRules} step.) | |
23047 | ||
23048 | Following is a complete list of ``unsafe'' simplifications performed | |
23049 | by @kbd{a e}. | |
23050 | ||
23051 | @tex | |
23052 | \bigskip | |
23053 | @end tex | |
23054 | ||
23055 | Inverse trigonometric or hyperbolic functions, called with their | |
23056 | corresponding non-inverse functions as arguments, are simplified | |
bd712b70 JB |
23057 | by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes |
23058 | to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and | |
23059 | @expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}. | |
d7b8e6c6 | 23060 | These simplifications are unsafe because they are valid only for |
a4231b04 | 23061 | values of @expr{x} in a certain range; outside that range, values |
d7b8e6c6 EZ |
23062 | are folded down to the 360-degree range that the inverse trigonometric |
23063 | functions always produce. | |
23064 | ||
a4231b04 | 23065 | Powers of powers @expr{(x^a)^b} are simplified to |
8e04863e | 23066 | @texline @math{x^{a b}} |
a4231b04 JB |
23067 | @infoline @expr{x^(a b)} |
23068 | for all @expr{a} and @expr{b}. These results will be valid only | |
23069 | in a restricted range of @expr{x}; for example, in | |
8e04863e | 23070 | @texline @math{(x^2)^{1:2}} |
a4231b04 JB |
23071 | @infoline @expr{(x^2)^1:2} |
23072 | the powers cancel to get @expr{x}, which is valid for positive values | |
23073 | of @expr{x} but not for negative or complex values. | |
23074 | ||
bd712b70 | 23075 | Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both |
a4231b04 | 23076 | simplified (possibly unsafely) to |
8e04863e | 23077 | @texline @math{x^{a/2}}. |
a4231b04 JB |
23078 | @infoline @expr{x^(a/2)}. |
23079 | ||
bd712b70 JB |
23080 | Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g., |
23081 | @expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin}, | |
d7b8e6c6 EZ |
23082 | @code{cos}, @code{tan}, @code{sinh}, and @code{cosh}. |
23083 | ||
23084 | Arguments of square roots are partially factored to look for | |
23085 | squared terms that can be extracted. For example, | |
bd712b70 JB |
23086 | @expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to |
23087 | @expr{a b @tfn{sqrt}(a+b)}. | |
d7b8e6c6 | 23088 | |
bd712b70 JB |
23089 | The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))}, |
23090 | @expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also | |
a4231b04 JB |
23091 | unsafe because of problems with principal values (although these |
23092 | simplifications are safe if @expr{x} is known to be real). | |
d7b8e6c6 EZ |
23093 | |
23094 | Common factors are cancelled from products on both sides of an | |
a4231b04 JB |
23095 | equation, even if those factors may be zero: @expr{a x / b x} |
23096 | to @expr{a / b}. Such factors are never cancelled from | |
d7b8e6c6 | 23097 | inequalities: Even @kbd{a e} is not bold enough to reduce |
a4231b04 JB |
23098 | @expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending |
23099 | on whether you believe @expr{x} is positive or negative). | |
d7b8e6c6 EZ |
23100 | The @kbd{a M /} command can be used to divide a factor out of |
23101 | both sides of an inequality. | |
23102 | ||
23103 | @node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas | |
23104 | @subsection Simplification of Units | |
23105 | ||
23106 | @noindent | |
23107 | The simplifications described in this section are applied by the | |
23108 | @kbd{u s} (@code{calc-simplify-units}) command. These are in addition | |
23109 | to the regular @kbd{a s} (but not @kbd{a e}) simplifications described | |
23110 | earlier. @xref{Basic Operations on Units}. | |
23111 | ||
23112 | The variable @code{UnitSimpRules} contains rewrites to be applied by | |
23113 | the @kbd{u s} command. These are applied in addition to @code{EvalRules} | |
23114 | and @code{AlgSimpRules}. | |
23115 | ||
23116 | Scalar mode is automatically put into effect when simplifying units. | |
23117 | @xref{Matrix Mode}. | |
23118 | ||
a4231b04 JB |
23119 | Sums @expr{a + b} involving units are simplified by extracting the |
23120 | units of @expr{a} as if by the @kbd{u x} command (call the result | |
23121 | @expr{u_a}), then simplifying the expression @expr{b / u_a} | |
d7b8e6c6 EZ |
23122 | using @kbd{u b} and @kbd{u s}. If the result has units then the sum |
23123 | is inconsistent and is left alone. Otherwise, it is rewritten | |
a4231b04 | 23124 | in terms of the units @expr{u_a}. |
d7b8e6c6 EZ |
23125 | |
23126 | If units auto-ranging mode is enabled, products or quotients in | |
23127 | which the first argument is a number which is out of range for the | |
23128 | leading unit are modified accordingly. | |
23129 | ||
23130 | When cancelling and combining units in products and quotients, | |
23131 | Calc accounts for unit names that differ only in the prefix letter. | |
23132 | For example, @samp{2 km m} is simplified to @samp{2000 m^2}. | |
23133 | However, compatible but different units like @code{ft} and @code{in} | |
23134 | are not combined in this way. | |
23135 | ||
a4231b04 JB |
23136 | Quotients @expr{a / b} are simplified in three additional ways. First, |
23137 | if @expr{b} is a number or a product beginning with a number, Calc | |
d7b8e6c6 EZ |
23138 | computes the reciprocal of this number and moves it to the numerator. |
23139 | ||
23140 | Second, for each pair of unit names from the numerator and denominator | |
23141 | of a quotient, if the units are compatible (e.g., they are both | |
23142 | units of area) then they are replaced by the ratio between those | |
23143 | units. For example, in @samp{3 s in N / kg cm} the units | |
a4231b04 | 23144 | @samp{in / cm} will be replaced by @expr{2.54}. |
d7b8e6c6 EZ |
23145 | |
23146 | Third, if the units in the quotient exactly cancel out, so that | |
23147 | a @kbd{u b} command on the quotient would produce a dimensionless | |
23148 | number for an answer, then the quotient simplifies to that number. | |
23149 | ||
23150 | For powers and square roots, the ``unsafe'' simplifications | |
a4231b04 JB |
23151 | @expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c}, |
23152 | and @expr{(a^b)^c} to | |
8e04863e | 23153 | @texline @math{a^{b c}} |
a4231b04 JB |
23154 | @infoline @expr{a^(b c)} |
23155 | are done if the powers are real numbers. (These are safe in the context | |
23156 | of units because all numbers involved can reasonably be assumed to be | |
23157 | real.) | |
d7b8e6c6 EZ |
23158 | |
23159 | Also, if a unit name is raised to a fractional power, and the | |
23160 | base units in that unit name all occur to powers which are a | |
23161 | multiple of the denominator of the power, then the unit name | |
23162 | is expanded out into its base units, which can then be simplified | |
23163 | according to the previous paragraph. For example, @samp{acre^1.5} | |
a4231b04 | 23164 | is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre} |
d7b8e6c6 | 23165 | is defined in terms of @samp{m^2}, and that the 2 in the power of |
a4231b04 JB |
23166 | @code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is |
23167 | replaced by approximately | |
8e04863e | 23168 | @texline @math{(4046 m^2)^{1.5}} |
a4231b04 JB |
23169 | @infoline @expr{(4046 m^2)^1.5}, |
23170 | which is then changed to | |
8e04863e | 23171 | @texline @math{4046^{1.5} \, (m^2)^{1.5}}, |
a4231b04 JB |
23172 | @infoline @expr{4046^1.5 (m^2)^1.5}, |
23173 | then to @expr{257440 m^3}. | |
d7b8e6c6 EZ |
23174 | |
23175 | The functions @code{float}, @code{frac}, @code{clean}, @code{abs}, | |
23176 | as well as @code{floor} and the other integer truncation functions, | |
23177 | applied to unit names or products or quotients involving units, are | |
23178 | simplified. For example, @samp{round(1.6 in)} is changed to | |
23179 | @samp{round(1.6) round(in)}; the lefthand term evaluates to 2, | |
23180 | and the righthand term simplifies to @code{in}. | |
23181 | ||
23182 | The functions @code{sin}, @code{cos}, and @code{tan} with arguments | |
23183 | that have angular units like @code{rad} or @code{arcmin} are | |
23184 | simplified by converting to base units (radians), then evaluating | |
23185 | with the angular mode temporarily set to radians. | |
23186 | ||
23187 | @node Polynomials, Calculus, Simplifying Formulas, Algebra | |
23188 | @section Polynomials | |
23189 | ||
23190 | A @dfn{polynomial} is a sum of terms which are coefficients times | |
a4231b04 JB |
23191 | various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4} |
23192 | is a polynomial in @expr{x}. Some formulas can be considered | |
23193 | polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2} | |
23194 | is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients | |
d7b8e6c6 EZ |
23195 | are often numbers, but they may in general be any formulas not |
23196 | involving the base variable. | |
23197 | ||
23198 | @kindex a f | |
23199 | @pindex calc-factor | |
23200 | @tindex factor | |
23201 | The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a | |
23202 | polynomial into a product of terms. For example, the polynomial | |
a4231b04 JB |
23203 | @expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another |
23204 | example, @expr{a c + b d + b c + a d} is factored into the product | |
23205 | @expr{(a + b) (c + d)}. | |
d7b8e6c6 EZ |
23206 | |
23207 | Calc currently has three algorithms for factoring. Formulas which are | |
23208 | linear in several variables, such as the second example above, are | |
23209 | merged according to the distributive law. Formulas which are | |
23210 | polynomials in a single variable, with constant integer or fractional | |
23211 | coefficients, are factored into irreducible linear and/or quadratic | |
23212 | terms. The first example above factors into three linear terms | |
a4231b04 | 23213 | (@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas |
d7b8e6c6 EZ |
23214 | which do not fit the above criteria are handled by the algebraic |
23215 | rewrite mechanism. | |
23216 | ||
23217 | Calc's polynomial factorization algorithm works by using the general | |
23218 | root-finding command (@w{@kbd{a P}}) to solve for the roots of the | |
23219 | polynomial. It then looks for roots which are rational numbers | |
23220 | or complex-conjugate pairs, and converts these into linear and | |
23221 | quadratic terms, respectively. Because it uses floating-point | |
23222 | arithmetic, it may be unable to find terms that involve large | |
23223 | integers (whose number of digits approaches the current precision). | |
23224 | Also, irreducible factors of degree higher than quadratic are not | |
23225 | found, and polynomials in more than one variable are not treated. | |
23226 | (A more robust factorization algorithm may be included in a future | |
23227 | version of Calc.) | |
23228 | ||
23229 | @vindex FactorRules | |
5d67986c RS |
23230 | @ignore |
23231 | @starindex | |
23232 | @end ignore | |
d7b8e6c6 | 23233 | @tindex thecoefs |
5d67986c RS |
23234 | @ignore |
23235 | @starindex | |
23236 | @end ignore | |
23237 | @ignore | |
23238 | @mindex @idots | |
23239 | @end ignore | |
d7b8e6c6 EZ |
23240 | @tindex thefactors |
23241 | The rewrite-based factorization method uses rules stored in the variable | |
23242 | @code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the | |
23243 | operation of rewrite rules. The default @code{FactorRules} are able | |
23244 | to factor quadratic forms symbolically into two linear terms, | |
a4231b04 | 23245 | @expr{(a x + b) (c x + d)}. You can edit these rules to include other |
d7b8e6c6 EZ |
23246 | cases if you wish. To use the rules, Calc builds the formula |
23247 | @samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial | |
23248 | base variable and @code{a}, @code{b}, etc., are polynomial coefficients | |
23249 | (which may be numbers or formulas). The constant term is written first, | |
23250 | i.e., in the @code{a} position. When the rules complete, they should have | |
23251 | changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])} | |
23252 | where each @code{fi} should be a factored term, e.g., @samp{x - ai}. | |
23253 | Calc then multiplies these terms together to get the complete | |
23254 | factored form of the polynomial. If the rules do not change the | |
23255 | @code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the | |
23256 | polynomial alone on the assumption that it is unfactorable. (Note that | |
23257 | the function names @code{thecoefs} and @code{thefactors} are used only | |
23258 | as placeholders; there are no actual Calc functions by those names.) | |
23259 | ||
23260 | @kindex H a f | |
23261 | @tindex factors | |
23262 | The @kbd{H a f} [@code{factors}] command also factors a polynomial, | |
23263 | but it returns a list of factors instead of an expression which is the | |
23264 | product of the factors. Each factor is represented by a sub-vector | |
23265 | of the factor, and the power with which it appears. For example, | |
a4231b04 JB |
23266 | @expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2} |
23267 | in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}. | |
d7b8e6c6 EZ |
23268 | If there is an overall numeric factor, it always comes first in the list. |
23269 | The functions @code{factor} and @code{factors} allow a second argument | |
a4231b04 JB |
23270 | when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with |
23271 | respect to the specific variable @expr{v}. The default is to factor with | |
23272 | respect to all the variables that appear in @expr{x}. | |
d7b8e6c6 EZ |
23273 | |
23274 | @kindex a c | |
23275 | @pindex calc-collect | |
23276 | @tindex collect | |
23277 | The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a | |
23278 | formula as a | |
23279 | polynomial in a given variable, ordered in decreasing powers of that | |
a4231b04 JB |
23280 | variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on |
23281 | the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)}, | |
23282 | and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}. | |
d7b8e6c6 | 23283 | The polynomial will be expanded out using the distributive law as |
a4231b04 JB |
23284 | necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces |
23285 | @expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will | |
d7b8e6c6 EZ |
23286 | not be expanded. |
23287 | ||
23288 | The ``variable'' you specify at the prompt can actually be any | |
23289 | expression: @kbd{a c ln(x+1)} will collect together all terms multiplied | |
23290 | by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears | |
23291 | in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will | |
23292 | treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants. | |
23293 | ||
23294 | @kindex a x | |
23295 | @pindex calc-expand | |
23296 | @tindex expand | |
23297 | The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an | |
23298 | expression by applying the distributive law everywhere. It applies to | |
23299 | products, quotients, and powers involving sums. By default, it fully | |
23300 | distributes all parts of the expression. With a numeric prefix argument, | |
23301 | the distributive law is applied only the specified number of times, then | |
23302 | the partially expanded expression is left on the stack. | |
23303 | ||
23304 | The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use | |
23305 | @kbd{a x} if you want to expand all products of sums in your formula. | |
23306 | Use @kbd{j D} if you want to expand a particular specified term of | |
23307 | the formula. There is an exactly analogous correspondence between | |
23308 | @kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands | |
23309 | also know many other kinds of expansions, such as | |
23310 | @samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f} | |
23311 | do not do.) | |
23312 | ||
23313 | Calc's automatic simplifications will sometimes reverse a partial | |
a4231b04 JB |
23314 | expansion. For example, the first step in expanding @expr{(x+1)^3} is |
23315 | to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries | |
d7b8e6c6 | 23316 | to put this formula onto the stack, though, Calc will automatically |
a4231b04 | 23317 | simplify it back to @expr{(x+1)^3} form. The solution is to turn |
d7b8e6c6 EZ |
23318 | simplification off first (@pxref{Simplification Modes}), or to run |
23319 | @kbd{a x} without a numeric prefix argument so that it expands all | |
23320 | the way in one step. | |
23321 | ||
23322 | @kindex a a | |
23323 | @pindex calc-apart | |
23324 | @tindex apart | |
23325 | The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a | |
23326 | rational function by partial fractions. A rational function is the | |
23327 | quotient of two polynomials; @code{apart} pulls this apart into a | |
23328 | sum of rational functions with simple denominators. In algebraic | |
23329 | notation, the @code{apart} function allows a second argument that | |
23330 | specifies which variable to use as the ``base''; by default, Calc | |
23331 | chooses the base variable automatically. | |
23332 | ||
23333 | @kindex a n | |
23334 | @pindex calc-normalize-rat | |
23335 | @tindex nrat | |
23336 | The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command | |
23337 | attempts to arrange a formula into a quotient of two polynomials. | |
a4231b04 JB |
23338 | For example, given @expr{1 + (a + b/c) / d}, the result would be |
23339 | @expr{(b + a c + c d) / c d}. The quotient is reduced, so that | |
23340 | @kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing | |
23341 | out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}. | |
d7b8e6c6 EZ |
23342 | |
23343 | @kindex a \ | |
23344 | @pindex calc-poly-div | |
23345 | @tindex pdiv | |
23346 | The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides | |
a4231b04 JB |
23347 | two polynomials @expr{u} and @expr{v}, yielding a new polynomial |
23348 | @expr{q}. If several variables occur in the inputs, the inputs are | |
d7b8e6c6 | 23349 | considered multivariate polynomials. (Calc divides by the variable |
a4231b04 | 23350 | with the largest power in @expr{u} first, or, in the case of equal |
d7b8e6c6 | 23351 | powers, chooses the variables in alphabetical order.) For example, |
a4231b04 | 23352 | dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}. |
d7b8e6c6 EZ |
23353 | The remainder from the division, if any, is reported at the bottom |
23354 | of the screen and is also placed in the Trail along with the quotient. | |
23355 | ||
23356 | Using @code{pdiv} in algebraic notation, you can specify the particular | |
5d67986c | 23357 | variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}. |
d7b8e6c6 EZ |
23358 | If @code{pdiv} is given only two arguments (as is always the case with |
23359 | the @kbd{a \} command), then it does a multivariate division as outlined | |
23360 | above. | |
23361 | ||
23362 | @kindex a % | |
23363 | @pindex calc-poly-rem | |
23364 | @tindex prem | |
23365 | The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides | |
a4231b04 JB |
23366 | two polynomials and keeps the remainder @expr{r}. The quotient |
23367 | @expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the | |
23368 | results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}. | |
d7b8e6c6 EZ |
23369 | (This is analogous to plain @kbd{\} and @kbd{%}, which compute the |
23370 | integer quotient and remainder from dividing two numbers.) | |
23371 | ||
23372 | @kindex a / | |
23373 | @kindex H a / | |
23374 | @pindex calc-poly-div-rem | |
23375 | @tindex pdivrem | |
23376 | @tindex pdivide | |
23377 | The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command | |
23378 | divides two polynomials and reports both the quotient and the | |
a4231b04 | 23379 | remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}] |
d7b8e6c6 | 23380 | command divides two polynomials and constructs the formula |
a4231b04 JB |
23381 | @expr{q + r/b} on the stack. (Naturally if the remainder is zero, |
23382 | this will immediately simplify to @expr{q}.) | |
d7b8e6c6 EZ |
23383 | |
23384 | @kindex a g | |
23385 | @pindex calc-poly-gcd | |
23386 | @tindex pgcd | |
23387 | The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes | |
23388 | the greatest common divisor of two polynomials. (The GCD actually | |
23389 | is unique only to within a constant multiplier; Calc attempts to | |
23390 | choose a GCD which will be unsurprising.) For example, the @kbd{a n} | |
23391 | command uses @kbd{a g} to take the GCD of the numerator and denominator | |
23392 | of a quotient, then divides each by the result using @kbd{a \}. (The | |
23393 | definition of GCD ensures that this division can take place without | |
23394 | leaving a remainder.) | |
23395 | ||
23396 | While the polynomials used in operations like @kbd{a /} and @kbd{a g} | |
23397 | often have integer coefficients, this is not required. Calc can also | |
23398 | deal with polynomials over the rationals or floating-point reals. | |
23399 | Polynomials with modulo-form coefficients are also useful in many | |
23400 | applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc | |
23401 | automatically transforms this into a polynomial over the field of | |
23402 | integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}. | |
23403 | ||
23404 | Congratulations and thanks go to Ove Ewerlid | |
23405 | (@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the | |
23406 | polynomial routines used in the above commands. | |
23407 | ||
23408 | @xref{Decomposing Polynomials}, for several useful functions for | |
23409 | extracting the individual coefficients of a polynomial. | |
23410 | ||
23411 | @node Calculus, Solving Equations, Polynomials, Algebra | |
23412 | @section Calculus | |
23413 | ||
23414 | @noindent | |
23415 | The following calculus commands do not automatically simplify their | |
23416 | inputs or outputs using @code{calc-simplify}. You may find it helps | |
23417 | to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help | |
23418 | to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most | |
23419 | readable way. | |
23420 | ||
23421 | @menu | |
23422 | * Differentiation:: | |
23423 | * Integration:: | |
23424 | * Customizing the Integrator:: | |
23425 | * Numerical Integration:: | |
23426 | * Taylor Series:: | |
23427 | @end menu | |
23428 | ||
23429 | @node Differentiation, Integration, Calculus, Calculus | |
23430 | @subsection Differentiation | |
23431 | ||
23432 | @noindent | |
23433 | @kindex a d | |
23434 | @kindex H a d | |
23435 | @pindex calc-derivative | |
23436 | @tindex deriv | |
23437 | @tindex tderiv | |
23438 | The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes | |
23439 | the derivative of the expression on the top of the stack with respect to | |
23440 | some variable, which it will prompt you to enter. Normally, variables | |
23441 | in the formula other than the specified differentiation variable are | |
23442 | considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With | |
23443 | the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used | |
23444 | instead, in which derivatives of variables are not reduced to zero | |
23445 | unless those variables are known to be ``constant,'' i.e., independent | |
23446 | of any other variables. (The built-in special variables like @code{pi} | |
23447 | are considered constant, as are variables that have been declared | |
23448 | @code{const}; @pxref{Declarations}.) | |
23449 | ||
23450 | With a numeric prefix argument @var{n}, this command computes the | |
23451 | @var{n}th derivative. | |
23452 | ||
23453 | When working with trigonometric functions, it is best to switch to | |
07ce2eb3 | 23454 | Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)} |
d7b8e6c6 EZ |
23455 | in degrees is @samp{(pi/180) cos(x)}, probably not the expected |
23456 | answer! | |
23457 | ||
23458 | If you use the @code{deriv} function directly in an algebraic formula, | |
23459 | you can write @samp{deriv(f,x,x0)} which represents the derivative | |
a4231b04 | 23460 | of @expr{f} with respect to @expr{x}, evaluated at the point |
8e04863e | 23461 | @texline @math{x=x_0}. |
a4231b04 | 23462 | @infoline @expr{x=x0}. |
d7b8e6c6 EZ |
23463 | |
23464 | If the formula being differentiated contains functions which Calc does | |
23465 | not know, the derivatives of those functions are produced by adding | |
23466 | primes (apostrophe characters). For example, @samp{deriv(f(2x), x)} | |
23467 | produces @samp{2 f'(2 x)}, where the function @code{f'} represents the | |
23468 | derivative of @code{f}. | |
23469 | ||
23470 | For functions you have defined with the @kbd{Z F} command, Calc expands | |
23471 | the functions according to their defining formulas unless you have | |
23472 | also defined @code{f'} suitably. For example, suppose we define | |
23473 | @samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate | |
23474 | the formula @samp{sinc(2 x)}, the formula will be expanded to | |
23475 | @samp{sin(2 x) / (2 x)} and differentiated. However, if we also | |
23476 | define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the | |
23477 | result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}. | |
23478 | ||
23479 | For multi-argument functions @samp{f(x,y,z)}, the derivative with respect | |
23480 | to the first argument is written @samp{f'(x,y,z)}; derivatives with | |
23481 | respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}. | |
23482 | Various higher-order derivatives can be formed in the obvious way, e.g., | |
23483 | @samp{f'@var{}'(x)} (the second derivative of @code{f}) or | |
23484 | @samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each | |
a4231b04 | 23485 | argument once). |
d7b8e6c6 EZ |
23486 | |
23487 | @node Integration, Customizing the Integrator, Differentiation, Calculus | |
23488 | @subsection Integration | |
23489 | ||
23490 | @noindent | |
23491 | @kindex a i | |
23492 | @pindex calc-integral | |
23493 | @tindex integ | |
23494 | The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the | |
23495 | indefinite integral of the expression on the top of the stack with | |
bc7fb067 JB |
23496 | respect to a prompted-for variable. The integrator is not guaranteed to |
23497 | work for all integrable functions, but it is able to integrate several | |
23498 | large classes of formulas. In particular, any polynomial or rational | |
23499 | function (a polynomial divided by a polynomial) is acceptable. | |
23500 | (Rational functions don't have to be in explicit quotient form, however; | |
8e04863e | 23501 | @texline @math{x/(1+x^{-2})} |
a4231b04 | 23502 | @infoline @expr{x/(1+x^-2)} |
d7b8e6c6 | 23503 | is not strictly a quotient of polynomials, but it is equivalent to |
a4231b04 JB |
23504 | @expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving |
23505 | @expr{x} and @expr{x^2} may appear in rational functions being | |
d7b8e6c6 EZ |
23506 | integrated. Finally, rational functions involving trigonometric or |
23507 | hyperbolic functions can be integrated. | |
23508 | ||
bc7fb067 JB |
23509 | With an argument (@kbd{C-u a i}), this command will compute the definite |
23510 | integral of the expression on top of the stack. In this case, the | |
23511 | command will again prompt for an integration variable, then prompt for a | |
23512 | lower limit and an upper limit. | |
23513 | ||
d7b8e6c6 EZ |
23514 | @ifinfo |
23515 | If you use the @code{integ} function directly in an algebraic formula, | |
23516 | you can also write @samp{integ(f,x,v)} which expresses the resulting | |
23517 | indefinite integral in terms of variable @code{v} instead of @code{x}. | |
23518 | With four arguments, @samp{integ(f(x),x,a,b)} represents a definite | |
23519 | integral from @code{a} to @code{b}. | |
23520 | @end ifinfo | |
177c0ea7 | 23521 | @tex |
d7b8e6c6 EZ |
23522 | If you use the @code{integ} function directly in an algebraic formula, |
23523 | you can also write @samp{integ(f,x,v)} which expresses the resulting | |
23524 | indefinite integral in terms of variable @code{v} instead of @code{x}. | |
23525 | With four arguments, @samp{integ(f(x),x,a,b)} represents a definite | |
23526 | integral $\int_a^b f(x) \, dx$. | |
23527 | @end tex | |
23528 | ||
23529 | Please note that the current implementation of Calc's integrator sometimes | |
23530 | produces results that are significantly more complex than they need to | |
a4231b04 | 23531 | be. For example, the integral Calc finds for |
8e04863e | 23532 | @texline @math{1/(x+\sqrt{x^2+1})} |
a4231b04 | 23533 | @infoline @expr{1/(x+sqrt(x^2+1))} |
d7b8e6c6 EZ |
23534 | is several times more complicated than the answer Mathematica |
23535 | returns for the same input, although the two forms are numerically | |
23536 | equivalent. Also, any indefinite integral should be considered to have | |
23537 | an arbitrary constant of integration added to it, although Calc does not | |
23538 | write an explicit constant of integration in its result. For example, | |
a4231b04 | 23539 | Calc's solution for |
8e04863e | 23540 | @texline @math{1/(1+\tan x)} |
a4231b04 JB |
23541 | @infoline @expr{1/(1+tan(x))} |
23542 | differs from the solution given in the @emph{CRC Math Tables} by a | |
23543 | constant factor of | |
8e04863e | 23544 | @texline @math{\pi i / 2} |
a4231b04 | 23545 | @infoline @expr{pi i / 2}, |
d7b8e6c6 EZ |
23546 | due to a different choice of constant of integration. |
23547 | ||
23548 | The Calculator remembers all the integrals it has done. If conditions | |
23549 | change in a way that would invalidate the old integrals, say, a switch | |
07ce2eb3 | 23550 | from Degrees to Radians mode, then they will be thrown out. If you |
d7b8e6c6 EZ |
23551 | suspect this is not happening when it should, use the |
23552 | @code{calc-flush-caches} command; @pxref{Caches}. | |
23553 | ||
23554 | @vindex IntegLimit | |
23555 | Calc normally will pursue integration by substitution or integration by | |
23556 | parts up to 3 nested times before abandoning an approach as fruitless. | |
23557 | If the integrator is taking too long, you can lower this limit by storing | |
23558 | a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I} | |
23559 | command is a convenient way to edit @code{IntegLimit}.) If this variable | |
23560 | has no stored value or does not contain a nonnegative integer, a limit | |
23561 | of 3 is used. The lower this limit is, the greater the chance that Calc | |
23562 | will be unable to integrate a function it could otherwise handle. Raising | |
23563 | this limit allows the Calculator to solve more integrals, though the time | |
23564 | it takes may grow exponentially. You can monitor the integrator's actions | |
23565 | by creating an Emacs buffer called @code{*Trace*}. If such a buffer | |
23566 | exists, the @kbd{a i} command will write a log of its actions there. | |
23567 | ||
23568 | If you want to manipulate integrals in a purely symbolic way, you can | |
23569 | set the integration nesting limit to 0 to prevent all but fast | |
23570 | table-lookup solutions of integrals. You might then wish to define | |
23571 | rewrite rules for integration by parts, various kinds of substitutions, | |
23572 | and so on. @xref{Rewrite Rules}. | |
23573 | ||
23574 | @node Customizing the Integrator, Numerical Integration, Integration, Calculus | |
23575 | @subsection Customizing the Integrator | |
23576 | ||
23577 | @noindent | |
23578 | @vindex IntegRules | |
23579 | Calc has two built-in rewrite rules called @code{IntegRules} and | |
23580 | @code{IntegAfterRules} which you can edit to define new integration | |
23581 | methods. @xref{Rewrite Rules}. At each step of the integration process, | |
23582 | Calc wraps the current integrand in a call to the fictitious function | |
23583 | @samp{integtry(@var{expr},@var{var})}, where @var{expr} is the | |
23584 | integrand and @var{var} is the integration variable. If your rules | |
23585 | rewrite this to be a plain formula (not a call to @code{integtry}), then | |
23586 | Calc will use this formula as the integral of @var{expr}. For example, | |
23587 | the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to | |
23588 | integrate a function @code{mysin} that acts like the sine function. | |
23589 | Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y} | |
23590 | will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has | |
23591 | automatically made various transformations on the integral to allow it | |
23592 | to use your rule; integral tables generally give rules for | |
23593 | @samp{mysin(a x + b)}, but you don't need to use this much generality | |
23594 | in your @code{IntegRules}. | |
23595 | ||
23596 | @cindex Exponential integral Ei(x) | |
5d67986c RS |
23597 | @ignore |
23598 | @starindex | |
23599 | @end ignore | |
d7b8e6c6 EZ |
23600 | @tindex Ei |
23601 | As a more serious example, the expression @samp{exp(x)/x} cannot be | |
23602 | integrated in terms of the standard functions, so the ``exponential | |
a4231b04 | 23603 | integral'' function |
8e04863e | 23604 | @texline @math{{\rm Ei}(x)} |
a4231b04 JB |
23605 | @infoline @expr{Ei(x)} |
23606 | was invented to describe it. | |
d7b8e6c6 EZ |
23607 | We can get Calc to do this integral in terms of a made-up @code{Ei} |
23608 | function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]} | |
23609 | to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack | |
23610 | and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will | |
23611 | work with Calc's various built-in integration methods (such as | |
23612 | integration by substitution) to solve a variety of other problems | |
23613 | involving @code{Ei}: For example, now Calc will also be able to | |
23614 | integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))} | |
23615 | and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively). | |
23616 | ||
23617 | Your rule may do further integration by calling @code{integ}. For | |
23618 | example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc | |
23619 | to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}. | |
23620 | Note that @code{integ} was called with only one argument. This notation | |
23621 | is allowed only within @code{IntegRules}; it means ``integrate this | |
23622 | with respect to the same integration variable.'' If Calc is unable | |
23623 | to integrate @code{u}, the integration that invoked @code{IntegRules} | |
23624 | also fails. Thus integrating @samp{twice(f(x))} fails, returning the | |
2cbd16b9 | 23625 | unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid |
d7b8e6c6 EZ |
23626 | to call @code{integ} with two or more arguments, however; in this case, |
23627 | if @code{u} is not integrable, @code{twice} itself will still be | |
23628 | integrated: If the above rule is changed to @samp{... := twice(integ(u,x))}, | |
23629 | then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}. | |
23630 | ||
23631 | If a rule instead produces the formula @samp{integsubst(@var{sexpr}, | |
23632 | @var{svar})}, either replacing the top-level @code{integtry} call or | |
23633 | nested anywhere inside the expression, then Calc will apply the | |
23634 | substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to | |
23635 | integrate the original @var{expr}. For example, the rule | |
23636 | @samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds | |
23637 | a square root in the integrand, it should attempt the substitution | |
23638 | @samp{u = sqrt(x)}. (This particular rule is unnecessary because | |
23639 | Calc always tries ``obvious'' substitutions where @var{sexpr} actually | |
23640 | appears in the integrand.) The variable @var{svar} may be the same | |
23641 | as the @var{var} that appeared in the call to @code{integtry}, but | |
23642 | it need not be. | |
23643 | ||
23644 | When integrating according to an @code{integsubst}, Calc uses the | |
23645 | equation solver to find the inverse of @var{sexpr} (if the integrand | |
23646 | refers to @var{var} anywhere except in subexpressions that exactly | |
23647 | match @var{sexpr}). It uses the differentiator to find the derivative | |
23648 | of @var{sexpr} and/or its inverse (it has two methods that use one | |
23649 | derivative or the other). You can also specify these items by adding | |
23650 | extra arguments to the @code{integsubst} your rules construct; the | |
23651 | general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv}, | |
23652 | @var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still | |
23653 | written as a function of @var{svar}), and @var{sprime} is the | |
23654 | derivative of @var{sexpr} with respect to @var{svar}. If you don't | |
23655 | specify these things, and Calc is not able to work them out on its | |
23656 | own with the information it knows, then your substitution rule will | |
23657 | work only in very specific, simple cases. | |
23658 | ||
23659 | Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules}; | |
23660 | in other words, Calc stops rewriting as soon as any rule in your rule | |
23661 | set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)} | |
23662 | example above would keep on adding layers of @code{integsubst} calls | |
23663 | forever!) | |
23664 | ||
23665 | @vindex IntegSimpRules | |
23666 | Another set of rules, stored in @code{IntegSimpRules}, are applied | |
23667 | every time the integrator uses @kbd{a s} to simplify an intermediate | |
23668 | result. For example, putting the rule @samp{twice(x) := 2 x} into | |
23669 | @code{IntegSimpRules} would tell Calc to convert the @code{twice} | |
23670 | function into a form it knows whenever integration is attempted. | |
23671 | ||
23672 | One more way to influence the integrator is to define a function with | |
23673 | the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's | |
23674 | integrator automatically expands such functions according to their | |
23675 | defining formulas, even if you originally asked for the function to | |
23676 | be left unevaluated for symbolic arguments. (Certain other Calc | |
23677 | systems, such as the differentiator and the equation solver, also | |
23678 | do this.) | |
23679 | ||
23680 | @vindex IntegAfterRules | |
23681 | Sometimes Calc is able to find a solution to your integral, but it | |
23682 | expresses the result in a way that is unnecessarily complicated. If | |
23683 | this happens, you can either use @code{integsubst} as described | |
23684 | above to try to hint at a more direct path to the desired result, or | |
23685 | you can use @code{IntegAfterRules}. This is an extra rule set that | |
23686 | runs after the main integrator returns its result; basically, Calc does | |
23687 | an @kbd{a r IntegAfterRules} on the result before showing it to you. | |
23688 | (It also does an @kbd{a s}, without @code{IntegSimpRules}, after that | |
23689 | to further simplify the result.) For example, Calc's integrator | |
23690 | sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)}; | |
23691 | the default @code{IntegAfterRules} rewrite this into the more readable | |
23692 | form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules}, | |
23693 | @code{IntegSimpRules} and @code{IntegAfterRules} are applied any number | |
23694 | of times until no further changes are possible. Rewriting by | |
23695 | @code{IntegAfterRules} occurs only after the main integrator has | |
23696 | finished, not at every step as for @code{IntegRules} and | |
23697 | @code{IntegSimpRules}. | |
23698 | ||
23699 | @node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus | |
23700 | @subsection Numerical Integration | |
23701 | ||
23702 | @noindent | |
23703 | @kindex a I | |
23704 | @pindex calc-num-integral | |
23705 | @tindex ninteg | |
23706 | If you want a purely numerical answer to an integration problem, you can | |
23707 | use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This | |
23708 | command prompts for an integration variable, a lower limit, and an | |
23709 | upper limit. Except for the integration variable, all other variables | |
23710 | that appear in the integrand formula must have stored values. (A stored | |
23711 | value, if any, for the integration variable itself is ignored.) | |
23712 | ||
23713 | Numerical integration works by evaluating your formula at many points in | |
23714 | the specified interval. Calc uses an ``open Romberg'' method; this means | |
23715 | that it does not evaluate the formula actually at the endpoints (so that | |
23716 | it is safe to integrate @samp{sin(x)/x} from zero, for example). Also, | |
23717 | the Romberg method works especially well when the function being | |
23718 | integrated is fairly smooth. If the function is not smooth, Calc will | |
23719 | have to evaluate it at quite a few points before it can accurately | |
23720 | determine the value of the integral. | |
23721 | ||
23722 | Integration is much faster when the current precision is small. It is | |
23723 | best to set the precision to the smallest acceptable number of digits | |
23724 | before you use @kbd{a I}. If Calc appears to be taking too long, press | |
23725 | @kbd{C-g} to halt it and try a lower precision. If Calc still appears | |
23726 | to need hundreds of evaluations, check to make sure your function is | |
23727 | well-behaved in the specified interval. | |
23728 | ||
23729 | It is possible for the lower integration limit to be @samp{-inf} (minus | |
23730 | infinity). Likewise, the upper limit may be plus infinity. Calc | |
23731 | internally transforms the integral into an equivalent one with finite | |
23732 | limits. However, integration to or across singularities is not supported: | |
23733 | The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found | |
23734 | by Calc's symbolic integrator, for example), but @kbd{a I} will fail | |
23735 | because the integrand goes to infinity at one of the endpoints. | |
23736 | ||
23737 | @node Taylor Series, , Numerical Integration, Calculus | |
23738 | @subsection Taylor Series | |
23739 | ||
23740 | @noindent | |
23741 | @kindex a t | |
23742 | @pindex calc-taylor | |
23743 | @tindex taylor | |
23744 | The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a | |
23745 | power series expansion or Taylor series of a function. You specify the | |
23746 | variable and the desired number of terms. You may give an expression of | |
23747 | the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead | |
23748 | of just a variable to produce a Taylor expansion about the point @var{a}. | |
23749 | You may specify the number of terms with a numeric prefix argument; | |
23750 | otherwise the command will prompt you for the number of terms. Note that | |
23751 | many series expansions have coefficients of zero for some terms, so you | |
a4231b04 | 23752 | may appear to get fewer terms than you asked for. |
d7b8e6c6 EZ |
23753 | |
23754 | If the @kbd{a i} command is unable to find a symbolic integral for a | |
23755 | function, you can get an approximation by integrating the function's | |
23756 | Taylor series. | |
23757 | ||
23758 | @node Solving Equations, Numerical Solutions, Calculus, Algebra | |
23759 | @section Solving Equations | |
23760 | ||
23761 | @noindent | |
23762 | @kindex a S | |
23763 | @pindex calc-solve-for | |
23764 | @tindex solve | |
23765 | @cindex Equations, solving | |
23766 | @cindex Solving equations | |
23767 | The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges | |
23768 | an equation to solve for a specific variable. An equation is an | |
a4231b04 JB |
23769 | expression of the form @expr{L = R}. For example, the command @kbd{a S x} |
23770 | will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the | |
d7b8e6c6 | 23771 | input is not an equation, it is treated like an equation of the |
a4231b04 | 23772 | form @expr{X = 0}. |
d7b8e6c6 | 23773 | |
a4231b04 | 23774 | This command also works for inequalities, as in @expr{y < 3x + 6}. |
d7b8e6c6 | 23775 | Some inequalities cannot be solved where the analogous equation could |
a4231b04 | 23776 | be; for example, solving |
8e04863e | 23777 | @texline @math{a < b \, c} |
a4231b04 JB |
23778 | @infoline @expr{a < b c} |
23779 | for @expr{b} is impossible | |
23780 | without knowing the sign of @expr{c}. In this case, @kbd{a S} will | |
23781 | produce the result | |
8e04863e | 23782 | @texline @math{b \mathbin{\hbox{\code{!=}}} a/c} |
a4231b04 JB |
23783 | @infoline @expr{b != a/c} |
23784 | (using the not-equal-to operator) to signify that the direction of the | |
23785 | inequality is now unknown. The inequality | |
8e04863e | 23786 | @texline @math{a \le b \, c} |
a4231b04 JB |
23787 | @infoline @expr{a <= b c} |
23788 | is not even partially solved. @xref{Declarations}, for a way to tell | |
23789 | Calc that the signs of the variables in a formula are in fact known. | |
d7b8e6c6 EZ |
23790 | |
23791 | Two useful commands for working with the result of @kbd{a S} are | |
a4231b04 JB |
23792 | @kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2} |
23793 | to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates | |
23794 | another formula with @expr{x} set equal to @expr{y/3 - 2}. | |
d7b8e6c6 | 23795 | |
177c0ea7 | 23796 | @menu |
d7b8e6c6 EZ |
23797 | * Multiple Solutions:: |
23798 | * Solving Systems of Equations:: | |
23799 | * Decomposing Polynomials:: | |
23800 | @end menu | |
23801 | ||
23802 | @node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations | |
23803 | @subsection Multiple Solutions | |
23804 | ||
23805 | @noindent | |
23806 | @kindex H a S | |
23807 | @tindex fsolve | |
23808 | Some equations have more than one solution. The Hyperbolic flag | |
23809 | (@code{H a S}) [@code{fsolve}] tells the solver to report the fully | |
23810 | general family of solutions. It will invent variables @code{n1}, | |
23811 | @code{n2}, @dots{}, which represent independent arbitrary integers, and | |
23812 | @code{s1}, @code{s2}, @dots{}, which represent independent arbitrary | |
8e04863e | 23813 | signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic |
d7b8e6c6 EZ |
23814 | flag, Calc will use zero in place of all arbitrary integers, and plus |
23815 | one in place of all arbitrary signs. Note that variables like @code{n1} | |
23816 | and @code{s1} are not given any special interpretation in Calc except by | |
23817 | the equation solver itself. As usual, you can use the @w{@kbd{s l}} | |
23818 | (@code{calc-let}) command to obtain solutions for various actual values | |
23819 | of these variables. | |
23820 | ||
23821 | For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to | |
23822 | get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the | |
23823 | equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to | |
23824 | think about it is that the square-root operation is really a | |
23825 | two-valued function; since every Calc function must return a | |
23826 | single result, @code{sqrt} chooses to return the positive result. | |
23827 | Then @kbd{H a S} doctors this result using @code{s1} to indicate | |
23828 | the full set of possible values of the mathematical square-root. | |
23829 | ||
23830 | There is a similar phenomenon going the other direction: Suppose | |
23831 | we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides | |
23832 | to get @samp{y = x^2}. This is correct, except that it introduces | |
23833 | some dubious solutions. Consider solving @samp{sqrt(y) = -3}: | |
a4231b04 | 23834 | Calc will report @expr{y = 9} as a valid solution, which is true |
d7b8e6c6 EZ |
23835 | in the mathematical sense of square-root, but false (there is no |
23836 | solution) for the actual Calc positive-valued @code{sqrt}. This | |
23837 | happens for both @kbd{a S} and @kbd{H a S}. | |
23838 | ||
23839 | @cindex @code{GenCount} variable | |
23840 | @vindex GenCount | |
5d67986c RS |
23841 | @ignore |
23842 | @starindex | |
23843 | @end ignore | |
d7b8e6c6 | 23844 | @tindex an |
5d67986c RS |
23845 | @ignore |
23846 | @starindex | |
23847 | @end ignore | |
d7b8e6c6 EZ |
23848 | @tindex as |
23849 | If you store a positive integer in the Calc variable @code{GenCount}, | |
23850 | then Calc will generate formulas of the form @samp{as(@var{n})} for | |
23851 | arbitrary signs, and @samp{an(@var{n})} for arbitrary integers, | |
23852 | where @var{n} represents successive values taken by incrementing | |
23853 | @code{GenCount} by one. While the normal arbitrary sign and | |
23854 | integer symbols start over at @code{s1} and @code{n1} with each | |
23855 | new Calc command, the @code{GenCount} approach will give each | |
23856 | arbitrary value a name that is unique throughout the entire Calc | |
23857 | session. Also, the arbitrary values are function calls instead | |
23858 | of variables, which is advantageous in some cases. For example, | |
23859 | you can make a rewrite rule that recognizes all arbitrary signs | |
23860 | using a pattern like @samp{as(n)}. The @kbd{s l} command only works | |
23861 | on variables, but you can use the @kbd{a b} (@code{calc-substitute}) | |
23862 | command to substitute actual values for function calls like @samp{as(3)}. | |
23863 | ||
23864 | The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient | |
33108698 | 23865 | way to create or edit this variable. Press @kbd{C-c C-c} to finish. |
d7b8e6c6 EZ |
23866 | |
23867 | If you have not stored a value in @code{GenCount}, or if the value | |
23868 | in that variable is not a positive integer, the regular | |
23869 | @code{s1}/@code{n1} notation is used. | |
23870 | ||
23871 | @kindex I a S | |
23872 | @kindex H I a S | |
23873 | @tindex finv | |
23874 | @tindex ffinv | |
23875 | With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression | |
23876 | on top of the stack as a function of the specified variable and solves | |
23877 | to find the inverse function, written in terms of the same variable. | |
a4231b04 | 23878 | For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}. |
d7b8e6c6 EZ |
23879 | You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a |
23880 | fully general inverse, as described above. | |
23881 | ||
23882 | @kindex a P | |
23883 | @pindex calc-poly-roots | |
23884 | @tindex roots | |
23885 | Some equations, specifically polynomials, have a known, finite number | |
23886 | of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}] | |
23887 | command uses @kbd{H a S} to solve an equation in general form, then, for | |
23888 | all arbitrary-sign variables like @code{s1}, and all arbitrary-integer | |
23889 | variables like @code{n1} for which @code{n1} only usefully varies over | |
23890 | a finite range, it expands these variables out to all their possible | |
23891 | values. The results are collected into a vector, which is returned. | |
23892 | For example, @samp{roots(x^4 = 1, x)} returns the four solutions | |
23893 | @samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree | |
23894 | polynomial will always have @var{n} roots on the complex plane. | |
23895 | (If you have given a @code{real} declaration for the solution | |
23896 | variable, then only the real-valued solutions, if any, will be | |
23897 | reported; @pxref{Declarations}.) | |
23898 | ||
23899 | Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver | |
23900 | symbolic solutions if the polynomial has symbolic coefficients. Also | |
23901 | note that Calc's solver is not able to get exact symbolic solutions | |
a4231b04 | 23902 | to all polynomials. Polynomials containing powers up to @expr{x^4} |
d7b8e6c6 | 23903 | can always be solved exactly; polynomials of higher degree sometimes |
a4231b04 JB |
23904 | can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1}, |
23905 | which can be solved for @expr{x^3} using the quadratic equation, and then | |
23906 | for @expr{x} by taking cube roots. But in many cases, like | |
23907 | @expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial | |
d7b8e6c6 | 23908 | into a form it can solve. The @kbd{a P} command can still deliver a |
07ce2eb3 JB |
23909 | list of numerical roots, however, provided that Symbolic mode (@kbd{m s}) |
23910 | is not turned on. (If you work with Symbolic mode on, recall that the | |
d7b8e6c6 | 23911 | @kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the |
07ce2eb3 | 23912 | formula on the stack with Symbolic mode temporarily off.) Naturally, |
28665d46 | 23913 | @kbd{a P} can only provide numerical roots if the polynomial coefficients |
d7b8e6c6 EZ |
23914 | are all numbers (real or complex). |
23915 | ||
23916 | @node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations | |
23917 | @subsection Solving Systems of Equations | |
23918 | ||
23919 | @noindent | |
23920 | @cindex Systems of equations, symbolic | |
23921 | You can also use the commands described above to solve systems of | |
23922 | simultaneous equations. Just create a vector of equations, then | |
23923 | specify a vector of variables for which to solve. (You can omit | |
23924 | the surrounding brackets when entering the vector of variables | |
23925 | at the prompt.) | |
23926 | ||
23927 | For example, putting @samp{[x + y = a, x - y = b]} on the stack | |
23928 | and typing @kbd{a S x,y @key{RET}} produces the vector of solutions | |
23929 | @samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will | |
23930 | have the same length as the variables vector, and the variables | |
23931 | will be listed in the same order there. Note that the solutions | |
23932 | are not always simplified as far as possible; the solution for | |
a4231b04 | 23933 | @expr{x} here could be improved by an application of the @kbd{a n} |
d7b8e6c6 EZ |
23934 | command. |
23935 | ||
23936 | Calc's algorithm works by trying to eliminate one variable at a | |
23937 | time by solving one of the equations for that variable and then | |
23938 | substituting into the other equations. Calc will try all the | |
23939 | possibilities, but you can speed things up by noting that Calc | |
23940 | first tries to eliminate the first variable with the first | |
23941 | equation, then the second variable with the second equation, | |
23942 | and so on. It also helps to put the simpler (e.g., more linear) | |
23943 | equations toward the front of the list. Calc's algorithm will | |
23944 | solve any system of linear equations, and also many kinds of | |
23945 | nonlinear systems. | |
23946 | ||
5d67986c RS |
23947 | @ignore |
23948 | @starindex | |
23949 | @end ignore | |
d7b8e6c6 EZ |
23950 | @tindex elim |
23951 | Normally there will be as many variables as equations. If you | |
23952 | give fewer variables than equations (an ``over-determined'' system | |
23953 | of equations), Calc will find a partial solution. For example, | |
23954 | typing @kbd{a S y @key{RET}} with the above system of equations | |
23955 | would produce @samp{[y = a - x]}. There are now several ways to | |
23956 | express this solution in terms of the original variables; Calc uses | |
23957 | the first one that it finds. You can control the choice by adding | |
23958 | variable specifiers of the form @samp{elim(@var{v})} to the | |
23959 | variables list. This says that @var{v} should be eliminated from | |
23960 | the equations; the variable will not appear at all in the solution. | |
23961 | For example, typing @kbd{a S y,elim(x)} would yield | |
23962 | @samp{[y = a - (b+a)/2]}. | |
23963 | ||
23964 | If the variables list contains only @code{elim} specifiers, | |
23965 | Calc simply eliminates those variables from the equations | |
23966 | and then returns the resulting set of equations. For example, | |
23967 | @kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable | |
23968 | eliminated will reduce the number of equations in the system | |
23969 | by one. | |
23970 | ||
23971 | Again, @kbd{a S} gives you one solution to the system of | |
23972 | equations. If there are several solutions, you can use @kbd{H a S} | |
23973 | to get a general family of solutions, or, if there is a finite | |
23974 | number of solutions, you can use @kbd{a P} to get a list. (In | |
23975 | the latter case, the result will take the form of a matrix where | |
23976 | the rows are different solutions and the columns correspond to the | |
23977 | variables you requested.) | |
23978 | ||
23979 | Another way to deal with certain kinds of overdetermined systems of | |
23980 | equations is the @kbd{a F} command, which does least-squares fitting | |
23981 | to satisfy the equations. @xref{Curve Fitting}. | |
23982 | ||
23983 | @node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations | |
23984 | @subsection Decomposing Polynomials | |
23985 | ||
23986 | @noindent | |
5d67986c RS |
23987 | @ignore |
23988 | @starindex | |
23989 | @end ignore | |
d7b8e6c6 EZ |
23990 | @tindex poly |
23991 | The @code{poly} function takes a polynomial and a variable as | |
23992 | arguments, and returns a vector of polynomial coefficients (constant | |
23993 | coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns | |
a4231b04 | 23994 | @expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x}, |
d7b8e6c6 | 23995 | the call to @code{poly} is left in symbolic form. If the input does |
a4231b04 | 23996 | not involve the variable @expr{x}, the input is returned in a list |
d7b8e6c6 | 23997 | of length one, representing a polynomial with only a constant |
a4231b04 | 23998 | coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}. |
d7b8e6c6 | 23999 | The last element of the returned vector is guaranteed to be nonzero; |
a4231b04 JB |
24000 | note that @samp{poly(0, x)} returns the empty vector @expr{[]}. |
24001 | Note also that @expr{x} may actually be any formula; for example, | |
24002 | @samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}. | |
d7b8e6c6 EZ |
24003 | |
24004 | @cindex Coefficients of polynomial | |
24005 | @cindex Degree of polynomial | |
a4231b04 JB |
24006 | To get the @expr{x^k} coefficient of polynomial @expr{p}, use |
24007 | @samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p}, | |
d7b8e6c6 EZ |
24008 | use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)} |
24009 | returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)} | |
a4231b04 | 24010 | gives the @expr{x^2} coefficient of this polynomial, 6. |
d7b8e6c6 | 24011 | |
5d67986c RS |
24012 | @ignore |
24013 | @starindex | |
24014 | @end ignore | |
d7b8e6c6 EZ |
24015 | @tindex gpoly |
24016 | One important feature of the solver is its ability to recognize | |
24017 | formulas which are ``essentially'' polynomials. This ability is | |
24018 | made available to the user through the @code{gpoly} function, which | |
24019 | is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}. | |
24020 | If @var{expr} is a polynomial in some term which includes @var{var}, then | |
24021 | this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]} | |
24022 | where @var{x} is the term that depends on @var{var}, @var{c} is a | |
24023 | vector of polynomial coefficients (like the one returned by @code{poly}), | |
24024 | and @var{a} is a multiplier which is usually 1. Basically, | |
24025 | @samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} + | |
24026 | @var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is | |
24027 | guaranteed to be non-zero, and @var{c} will not equal @samp{[1]} | |
24028 | (i.e., the trivial decomposition @var{expr} = @var{x} is not | |
24029 | considered a polynomial). One side effect is that @samp{gpoly(x, x)} | |
24030 | and @samp{gpoly(6, x)}, both of which might be expected to recognize | |
24031 | their arguments as polynomials, will not because the decomposition | |
24032 | is considered trivial. | |
24033 | ||
24034 | For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]}, | |
a4231b04 | 24035 | since the expanded form of this polynomial is @expr{4 - 4 x + x^2}. |
d7b8e6c6 EZ |
24036 | |
24037 | The term @var{x} may itself be a polynomial in @var{var}. This is | |
24038 | done to reduce the size of the @var{c} vector. For example, | |
24039 | @samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]}, | |
a4231b04 JB |
24040 | since a quadratic polynomial in @expr{x^2} is easier to solve than |
24041 | a quartic polynomial in @expr{x}. | |
d7b8e6c6 EZ |
24042 | |
24043 | A few more examples of the kinds of polynomials @code{gpoly} can | |
24044 | discover: | |
24045 | ||
24046 | @smallexample | |
24047 | sin(x) - 1 [sin(x), [-1, 1], 1] | |
24048 | x + 1/x - 1 [x, [1, -1, 1], 1/x] | |
24049 | x + 1/x [x^2, [1, 1], 1/x] | |
24050 | x^3 + 2 x [x^2, [2, 1], x] | |
24051 | x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2] | |
24052 | x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1] | |
24053 | (exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x] | |
24054 | @end smallexample | |
24055 | ||
24056 | The @code{poly} and @code{gpoly} functions accept a third integer argument | |
24057 | which specifies the largest degree of polynomial that is acceptable. | |
a4231b04 | 24058 | If this is @expr{n}, then only @var{c} vectors of length @expr{n+1} |
d7b8e6c6 EZ |
24059 | or less will be returned. Otherwise, the @code{poly} or @code{gpoly} |
24060 | call will remain in symbolic form. For example, the equation solver | |
24061 | can handle quartics and smaller polynomials, so it calls | |
24062 | @samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr} | |
24063 | can be treated by its linear, quadratic, cubic, or quartic formulas. | |
24064 | ||
5d67986c RS |
24065 | @ignore |
24066 | @starindex | |
24067 | @end ignore | |
d7b8e6c6 EZ |
24068 | @tindex pdeg |
24069 | The @code{pdeg} function computes the degree of a polynomial; | |
24070 | @samp{pdeg(p,x)} is the highest power of @code{x} that appears in | |
24071 | @code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is | |
24072 | much more efficient. If @code{p} is constant with respect to @code{x}, | |
24073 | then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x} | |
24074 | (e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated. | |
24075 | It is possible to omit the second argument @code{x}, in which case | |
24076 | @samp{pdeg(p)} returns the highest total degree of any term of the | |
24077 | polynomial, counting all variables that appear in @code{p}. Note | |
24078 | that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c}; | |
24079 | the degree of the constant zero is considered to be @code{-inf} | |
24080 | (minus infinity). | |
24081 | ||
5d67986c RS |
24082 | @ignore |
24083 | @starindex | |
24084 | @end ignore | |
d7b8e6c6 EZ |
24085 | @tindex plead |
24086 | The @code{plead} function finds the leading term of a polynomial. | |
24087 | Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))}, | |
24088 | though again more efficient. In particular, @samp{plead((2x+1)^10, x)} | |
24089 | returns 1024 without expanding out the list of coefficients. The | |
a4231b04 | 24090 | value of @code{plead(p,x)} will be zero only if @expr{p = 0}. |
d7b8e6c6 | 24091 | |
5d67986c RS |
24092 | @ignore |
24093 | @starindex | |
24094 | @end ignore | |
d7b8e6c6 EZ |
24095 | @tindex pcont |
24096 | The @code{pcont} function finds the @dfn{content} of a polynomial. This | |
24097 | is the greatest common divisor of all the coefficients of the polynomial. | |
24098 | With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)} | |
24099 | to get a list of coefficients, then uses @code{pgcd} (the polynomial | |
24100 | GCD function) to combine these into an answer. For example, | |
24101 | @samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is | |
24102 | basically the ``biggest'' polynomial that can be divided into @code{p} | |
24103 | exactly. The sign of the content is the same as the sign of the leading | |
24104 | coefficient. | |
24105 | ||
24106 | With only one argument, @samp{pcont(p)} computes the numerical | |
24107 | content of the polynomial, i.e., the @code{gcd} of the numerical | |
24108 | coefficients of all the terms in the formula. Note that @code{gcd} | |
24109 | is defined on rational numbers as well as integers; it computes | |
24110 | the @code{gcd} of the numerators and the @code{lcm} of the | |
24111 | denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3. | |
24112 | Dividing the polynomial by this number will clear all the | |
24113 | denominators, as well as dividing by any common content in the | |
24114 | numerators. The numerical content of a polynomial is negative only | |
24115 | if all the coefficients in the polynomial are negative. | |
24116 | ||
5d67986c RS |
24117 | @ignore |
24118 | @starindex | |
24119 | @end ignore | |
d7b8e6c6 EZ |
24120 | @tindex pprim |
24121 | The @code{pprim} function finds the @dfn{primitive part} of a | |
24122 | polynomial, which is simply the polynomial divided (using @code{pdiv} | |
24123 | if necessary) by its content. If the input polynomial has rational | |
24124 | coefficients, the result will have integer coefficients in simplest | |
24125 | terms. | |
24126 | ||
24127 | @node Numerical Solutions, Curve Fitting, Solving Equations, Algebra | |
24128 | @section Numerical Solutions | |
24129 | ||
24130 | @noindent | |
24131 | Not all equations can be solved symbolically. The commands in this | |
24132 | section use numerical algorithms that can find a solution to a specific | |
24133 | instance of an equation to any desired accuracy. Note that the | |
24134 | numerical commands are slower than their algebraic cousins; it is a | |
24135 | good idea to try @kbd{a S} before resorting to these commands. | |
24136 | ||
24137 | (@xref{Curve Fitting}, for some other, more specialized, operations | |
24138 | on numerical data.) | |
24139 | ||
24140 | @menu | |
24141 | * Root Finding:: | |
24142 | * Minimization:: | |
24143 | * Numerical Systems of Equations:: | |
24144 | @end menu | |
24145 | ||
24146 | @node Root Finding, Minimization, Numerical Solutions, Numerical Solutions | |
24147 | @subsection Root Finding | |
24148 | ||
24149 | @noindent | |
24150 | @kindex a R | |
24151 | @pindex calc-find-root | |
24152 | @tindex root | |
24153 | @cindex Newton's method | |
24154 | @cindex Roots of equations | |
24155 | @cindex Numerical root-finding | |
24156 | The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a | |
24157 | numerical solution (or @dfn{root}) of an equation. (This command treats | |
24158 | inequalities the same as equations. If the input is any other kind | |
a4231b04 | 24159 | of formula, it is interpreted as an equation of the form @expr{X = 0}.) |
d7b8e6c6 EZ |
24160 | |
24161 | The @kbd{a R} command requires an initial guess on the top of the | |
24162 | stack, and a formula in the second-to-top position. It prompts for a | |
24163 | solution variable, which must appear in the formula. All other variables | |
24164 | that appear in the formula must have assigned values, i.e., when | |
24165 | a value is assigned to the solution variable and the formula is | |
24166 | evaluated with @kbd{=}, it should evaluate to a number. Any assigned | |
24167 | value for the solution variable itself is ignored and unaffected by | |
24168 | this command. | |
24169 | ||
24170 | When the command completes, the initial guess is replaced on the stack | |
24171 | by a vector of two numbers: The value of the solution variable that | |
24172 | solves the equation, and the difference between the lefthand and | |
24173 | righthand sides of the equation at that value. Ordinarily, the second | |
24174 | number will be zero or very nearly zero. (Note that Calc uses a | |
24175 | slightly higher precision while finding the root, and thus the second | |
24176 | number may be slightly different from the value you would compute from | |
24177 | the equation yourself.) | |
24178 | ||
24179 | The @kbd{v h} (@code{calc-head}) command is a handy way to extract | |
24180 | the first element of the result vector, discarding the error term. | |
24181 | ||
24182 | The initial guess can be a real number, in which case Calc searches | |
24183 | for a real solution near that number, or a complex number, in which | |
24184 | case Calc searches the whole complex plane near that number for a | |
24185 | solution, or it can be an interval form which restricts the search | |
24186 | to real numbers inside that interval. | |
24187 | ||
24188 | Calc tries to use @kbd{a d} to take the derivative of the equation. | |
24189 | If this succeeds, it uses Newton's method. If the equation is not | |
24190 | differentiable Calc uses a bisection method. (If Newton's method | |
24191 | appears to be going astray, Calc switches over to bisection if it | |
24192 | can, or otherwise gives up. In this case it may help to try again | |
24193 | with a slightly different initial guess.) If the initial guess is a | |
24194 | complex number, the function must be differentiable. | |
24195 | ||
24196 | If the formula (or the difference between the sides of an equation) | |
24197 | is negative at one end of the interval you specify and positive at | |
24198 | the other end, the root finder is guaranteed to find a root. | |
24199 | Otherwise, Calc subdivides the interval into small parts looking for | |
24200 | positive and negative values to bracket the root. When your guess is | |
24201 | an interval, Calc will not look outside that interval for a root. | |
24202 | ||
24203 | @kindex H a R | |
24204 | @tindex wroot | |
24205 | The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except | |
24206 | that if the initial guess is an interval for which the function has | |
24207 | the same sign at both ends, then rather than subdividing the interval | |
24208 | Calc attempts to widen it to enclose a root. Use this mode if | |
24209 | you are not sure if the function has a root in your interval. | |
24210 | ||
24211 | If the function is not differentiable, and you give a simple number | |
24212 | instead of an interval as your initial guess, Calc uses this widening | |
24213 | process even if you did not type the Hyperbolic flag. (If the function | |
24214 | @emph{is} differentiable, Calc uses Newton's method which does not | |
24215 | require a bounding interval in order to work.) | |
24216 | ||
24217 | If Calc leaves the @code{root} or @code{wroot} function in symbolic | |
24218 | form on the stack, it will normally display an explanation for why | |
24219 | no root was found. If you miss this explanation, press @kbd{w} | |
24220 | (@code{calc-why}) to get it back. | |
24221 | ||
24222 | @node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions | |
24223 | @subsection Minimization | |
24224 | ||
24225 | @noindent | |
24226 | @kindex a N | |
24227 | @kindex H a N | |
24228 | @kindex a X | |
24229 | @kindex H a X | |
24230 | @pindex calc-find-minimum | |
24231 | @pindex calc-find-maximum | |
24232 | @tindex minimize | |
24233 | @tindex maximize | |
24234 | @cindex Minimization, numerical | |
24235 | The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command | |
24236 | finds a minimum value for a formula. It is very similar in operation | |
24237 | to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial | |
24238 | guess on the stack, and are prompted for the name of a variable. The guess | |
24239 | may be either a number near the desired minimum, or an interval enclosing | |
24240 | the desired minimum. The function returns a vector containing the | |
269b7745 | 24241 | value of the variable which minimizes the formula's value, along |
d7b8e6c6 EZ |
24242 | with the minimum value itself. |
24243 | ||
24244 | Note that this command looks for a @emph{local} minimum. Many functions | |
a4231b04 | 24245 | have more than one minimum; some, like |
8e04863e | 24246 | @texline @math{x \sin x}, |
a4231b04 JB |
24247 | @infoline @expr{x sin(x)}, |
24248 | have infinitely many. In fact, there is no easy way to define the | |
24249 | ``global'' minimum of | |
8e04863e | 24250 | @texline @math{x \sin x} |
a4231b04 JB |
24251 | @infoline @expr{x sin(x)} |
24252 | but Calc can still locate any particular local minimum | |
d7b8e6c6 EZ |
24253 | for you. Calc basically goes downhill from the initial guess until it |
24254 | finds a point at which the function's value is greater both to the left | |
24255 | and to the right. Calc does not use derivatives when minimizing a function. | |
24256 | ||
24257 | If your initial guess is an interval and it looks like the minimum | |
24258 | occurs at one or the other endpoint of the interval, Calc will return | |
a4231b04 JB |
24259 | that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x} |
24260 | over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over | |
24261 | @expr{(2..3]} would report no minimum found. In general, you should | |
d7b8e6c6 | 24262 | use closed intervals to find literally the minimum value in that |
a4231b04 | 24263 | range of @expr{x}, or open intervals to find the local minimum, if |
d7b8e6c6 EZ |
24264 | any, that happens to lie in that range. |
24265 | ||
24266 | Most functions are smooth and flat near their minimum values. Because | |
24267 | of this flatness, if the current precision is, say, 12 digits, the | |
24268 | variable can only be determined meaningfully to about six digits. Thus | |
24269 | you should set the precision to twice as many digits as you need in your | |
24270 | answer. | |
24271 | ||
5d67986c RS |
24272 | @ignore |
24273 | @mindex wmin@idots | |
24274 | @end ignore | |
d7b8e6c6 | 24275 | @tindex wminimize |
5d67986c RS |
24276 | @ignore |
24277 | @mindex wmax@idots | |
24278 | @end ignore | |
d7b8e6c6 EZ |
24279 | @tindex wmaximize |
24280 | The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R}, | |
24281 | expands the guess interval to enclose a minimum rather than requiring | |
24282 | that the minimum lie inside the interval you supply. | |
24283 | ||
24284 | The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and | |
24285 | @kbd{H a X} [@code{wmaximize}] commands effectively minimize the | |
24286 | negative of the formula you supply. | |
24287 | ||
24288 | The formula must evaluate to a real number at all points inside the | |
24289 | interval (or near the initial guess if the guess is a number). If | |
24290 | the initial guess is a complex number the variable will be minimized | |
24291 | over the complex numbers; if it is real or an interval it will | |
24292 | be minimized over the reals. | |
24293 | ||
24294 | @node Numerical Systems of Equations, , Minimization, Numerical Solutions | |
24295 | @subsection Systems of Equations | |
24296 | ||
24297 | @noindent | |
24298 | @cindex Systems of equations, numerical | |
24299 | The @kbd{a R} command can also solve systems of equations. In this | |
24300 | case, the equation should instead be a vector of equations, the | |
24301 | guess should instead be a vector of numbers (intervals are not | |
24302 | supported), and the variable should be a vector of variables. You | |
24303 | can omit the brackets while entering the list of variables. Each | |
24304 | equation must be differentiable by each variable for this mode to | |
24305 | work. The result will be a vector of two vectors: The variable | |
24306 | values that solved the system of equations, and the differences | |
24307 | between the sides of the equations with those variable values. | |
24308 | There must be the same number of equations as variables. Since | |
24309 | only plain numbers are allowed as guesses, the Hyperbolic flag has | |
24310 | no effect when solving a system of equations. | |
24311 | ||
24312 | It is also possible to minimize over many variables with @kbd{a N} | |
24313 | (or maximize with @kbd{a X}). Once again the variable name should | |
24314 | be replaced by a vector of variables, and the initial guess should | |
24315 | be an equal-sized vector of initial guesses. But, unlike the case of | |
24316 | multidimensional @kbd{a R}, the formula being minimized should | |
24317 | still be a single formula, @emph{not} a vector. Beware that | |
24318 | multidimensional minimization is currently @emph{very} slow. | |
24319 | ||
24320 | @node Curve Fitting, Summations, Numerical Solutions, Algebra | |
24321 | @section Curve Fitting | |
24322 | ||
24323 | @noindent | |
24324 | The @kbd{a F} command fits a set of data to a @dfn{model formula}, | |
a4231b04 | 24325 | such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters |
d7b8e6c6 | 24326 | to be determined. For a typical set of measured data there will be |
a4231b04 | 24327 | no single @expr{m} and @expr{b} that exactly fit the data; in this |
d7b8e6c6 EZ |
24328 | case, Calc chooses values of the parameters that provide the closest |
24329 | possible fit. | |
24330 | ||
24331 | @menu | |
24332 | * Linear Fits:: | |
24333 | * Polynomial and Multilinear Fits:: | |
24334 | * Error Estimates for Fits:: | |
24335 | * Standard Nonlinear Models:: | |
24336 | * Curve Fitting Details:: | |
24337 | * Interpolation:: | |
24338 | @end menu | |
24339 | ||
24340 | @node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting | |
24341 | @subsection Linear Fits | |
24342 | ||
24343 | @noindent | |
24344 | @kindex a F | |
24345 | @pindex calc-curve-fit | |
24346 | @tindex fit | |
24347 | @cindex Linear regression | |
24348 | @cindex Least-squares fits | |
24349 | The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts | |
a4231b04 JB |
24350 | to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a |
24351 | straight line, polynomial, or other function of @expr{x}. For the | |
d7b8e6c6 EZ |
24352 | moment we will consider only the case of fitting to a line, and we |
24353 | will ignore the issue of whether or not the model was in fact a good | |
24354 | fit for the data. | |
24355 | ||
a4231b04 JB |
24356 | In a standard linear least-squares fit, we have a set of @expr{(x,y)} |
24357 | data points that we wish to fit to the model @expr{y = m x + b} | |
24358 | by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y} | |
d7b8e6c6 | 24359 | values calculated from the formula be as close as possible to the actual |
a4231b04 JB |
24360 | @expr{y} values in the data set. (In a polynomial fit, the model is |
24361 | instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit, | |
24362 | we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is | |
24363 | @expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.) | |
24364 | ||
24365 | In the model formula, variables like @expr{x} and @expr{x_2} are called | |
24366 | the @dfn{independent variables}, and @expr{y} is the @dfn{dependent | |
24367 | variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called | |
d7b8e6c6 EZ |
24368 | the @dfn{parameters} of the model. |
24369 | ||
24370 | The @kbd{a F} command takes the data set to be fitted from the stack. | |
24371 | By default, it expects the data in the form of a matrix. For example, | |
a4231b04 | 24372 | for a linear or polynomial fit, this would be a |
8e04863e | 24373 | @texline @math{2\times N} |
a4231b04 JB |
24374 | @infoline 2xN |
24375 | matrix where the first row is a list of @expr{x} values and the second | |
24376 | row has the corresponding @expr{y} values. For the multilinear fit | |
24377 | shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2}, | |
24378 | @expr{x_3}, and @expr{y}, respectively). | |
24379 | ||
24380 | If you happen to have an | |
8e04863e | 24381 | @texline @math{N\times2} |
a4231b04 JB |
24382 | @infoline Nx2 |
24383 | matrix instead of a | |
8e04863e | 24384 | @texline @math{2\times N} |
a4231b04 JB |
24385 | @infoline 2xN |
24386 | matrix, just press @kbd{v t} first to transpose the matrix. | |
d7b8e6c6 EZ |
24387 | |
24388 | After you type @kbd{a F}, Calc prompts you to select a model. For a | |
24389 | linear fit, press the digit @kbd{1}. | |
24390 | ||
24391 | Calc then prompts for you to name the variables. By default it chooses | |
a4231b04 JB |
24392 | high letters like @expr{x} and @expr{y} for independent variables and |
24393 | low letters like @expr{a} and @expr{b} for parameters. (The dependent | |
d7b8e6c6 EZ |
24394 | variable doesn't need a name.) The two kinds of variables are separated |
24395 | by a semicolon. Since you generally care more about the names of the | |
24396 | independent variables than of the parameters, Calc also allows you to | |
24397 | name only those and let the parameters use default names. | |
24398 | ||
24399 | For example, suppose the data matrix | |
24400 | ||
24401 | @ifinfo | |
d7b8e6c6 | 24402 | @example |
5d67986c | 24403 | @group |
d7b8e6c6 EZ |
24404 | [ [ 1, 2, 3, 4, 5 ] |
24405 | [ 5, 7, 9, 11, 13 ] ] | |
d7b8e6c6 | 24406 | @end group |
5d67986c | 24407 | @end example |
d7b8e6c6 EZ |
24408 | @end ifinfo |
24409 | @tex | |
24410 | \turnoffactive | |
24411 | \turnoffactive | |
24412 | \beforedisplay | |
24413 | $$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr | |
24414 | 5 & 7 & 9 & 11 & 13 } | |
24415 | $$ | |
24416 | \afterdisplay | |
24417 | @end tex | |
24418 | ||
24419 | @noindent | |
24420 | is on the stack and we wish to do a simple linear fit. Type | |
5d67986c | 24421 | @kbd{a F}, then @kbd{1} for the model, then @key{RET} to use |
a4231b04 | 24422 | the default names. The result will be the formula @expr{3 + 2 x} |
d7b8e6c6 | 24423 | on the stack. Calc has created the model expression @kbd{a + b x}, |
a4231b04 | 24424 | then found the optimal values of @expr{a} and @expr{b} to fit the |
d7b8e6c6 | 24425 | data. (In this case, it was able to find an exact fit.) Calc then |
a4231b04 | 24426 | substituted those values for @expr{a} and @expr{b} in the model |
d7b8e6c6 EZ |
24427 | formula. |
24428 | ||
24429 | The @kbd{a F} command puts two entries in the trail. One is, as | |
24430 | always, a copy of the result that went to the stack; the other is | |
24431 | a vector of the actual parameter values, written as equations: | |
a4231b04 | 24432 | @expr{[a = 3, b = 2]}, in case you'd rather read them in a list |
d7b8e6c6 | 24433 | than pick them out of the formula. (You can type @kbd{t y} |
b275eac7 | 24434 | to move this vector to the stack; see @ref{Trail Commands}. |
d7b8e6c6 EZ |
24435 | |
24436 | Specifying a different independent variable name will affect the | |
5d67986c RS |
24437 | resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}. |
24438 | Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect | |
d7b8e6c6 EZ |
24439 | the equations that go into the trail. |
24440 | ||
24441 | @tex | |
24442 | \bigskip | |
24443 | @end tex | |
24444 | ||
24445 | To see what happens when the fit is not exact, we could change | |
24446 | the number 13 in the data matrix to 14 and try the fit again. | |
24447 | The result is: | |
24448 | ||
24449 | @example | |
24450 | 2.6 + 2.2 x | |
24451 | @end example | |
24452 | ||
5d67986c | 24453 | Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows |
d7b8e6c6 EZ |
24454 | a reasonably close match to the y-values in the data. |
24455 | ||
24456 | @example | |
24457 | [4.8, 7., 9.2, 11.4, 13.6] | |
24458 | @end example | |
24459 | ||
5d67986c | 24460 | Since there is no line which passes through all the @var{n} data points, |
d7b8e6c6 EZ |
24461 | Calc has chosen a line that best approximates the data points using |
24462 | the method of least squares. The idea is to define the @dfn{chi-square} | |
24463 | error measure | |
24464 | ||
24465 | @ifinfo | |
24466 | @example | |
24467 | chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N) | |
24468 | @end example | |
24469 | @end ifinfo | |
24470 | @tex | |
24471 | \turnoffactive | |
24472 | \beforedisplay | |
24473 | $$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$ | |
24474 | \afterdisplay | |
24475 | @end tex | |
24476 | ||
24477 | @noindent | |
a4231b04 JB |
24478 | which is clearly zero if @expr{a + b x} exactly fits all data points, |
24479 | and increases as various @expr{a + b x_i} values fail to match the | |
24480 | corresponding @expr{y_i} values. There are several reasons why the | |
24481 | summand is squared, one of them being to ensure that | |
8e04863e | 24482 | @texline @math{\chi^2 \ge 0}. |
a4231b04 JB |
24483 | @infoline @expr{chi^2 >= 0}. |
24484 | Least-squares fitting simply chooses the values of @expr{a} and @expr{b} | |
24485 | for which the error | |
8e04863e | 24486 | @texline @math{\chi^2} |
a4231b04 JB |
24487 | @infoline @expr{chi^2} |
24488 | is as small as possible. | |
d7b8e6c6 EZ |
24489 | |
24490 | Other kinds of models do the same thing but with a different model | |
a4231b04 | 24491 | formula in place of @expr{a + b x_i}. |
d7b8e6c6 EZ |
24492 | |
24493 | @tex | |
24494 | \bigskip | |
24495 | @end tex | |
24496 | ||
24497 | A numeric prefix argument causes the @kbd{a F} command to take the | |
5d67986c RS |
24498 | data in some other form than one big matrix. A positive argument @var{n} |
24499 | will take @var{N} items from the stack, corresponding to the @var{n} rows | |
24500 | of a data matrix. In the linear case, @var{n} must be 2 since there | |
d7b8e6c6 EZ |
24501 | is always one independent variable and one dependent variable. |
24502 | ||
24503 | A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two | |
a4231b04 JB |
24504 | items from the stack, an @var{n}-row matrix of @expr{x} values, and a |
24505 | vector of @expr{y} values. If there is only one independent variable, | |
24506 | the @expr{x} values can be either a one-row matrix or a plain vector, | |
d7b8e6c6 EZ |
24507 | in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix. |
24508 | ||
24509 | @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting | |
24510 | @subsection Polynomial and Multilinear Fits | |
24511 | ||
24512 | @noindent | |
24513 | To fit the data to higher-order polynomials, just type one of the | |
24514 | digits @kbd{2} through @kbd{9} when prompted for a model. For example, | |
24515 | we could fit the original data matrix from the previous section | |
24516 | (with 13, not 14) to a parabola instead of a line by typing | |
5d67986c | 24517 | @kbd{a F 2 @key{RET}}. |
d7b8e6c6 EZ |
24518 | |
24519 | @example | |
24520 | 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999 | |
24521 | @end example | |
24522 | ||
24523 | Note that since the constant and linear terms are enough to fit the | |
24524 | data exactly, it's no surprise that Calc chose a tiny contribution | |
a4231b04 | 24525 | for @expr{x^2}. (The fact that it's not exactly zero is due only |
d7b8e6c6 | 24526 | to roundoff error. Since our data are exact integers, we could get |
07ce2eb3 | 24527 | an exact answer by typing @kbd{m f} first to get Fraction mode. |
a4231b04 | 24528 | Then the @expr{x^2} term would vanish altogether. Usually, though, |
07ce2eb3 | 24529 | the data being fitted will be approximate floats so Fraction mode |
d7b8e6c6 EZ |
24530 | won't help.) |
24531 | ||
24532 | Doing the @kbd{a F 2} fit on the data set with 14 instead of 13 | |
a4231b04 | 24533 | gives a much larger @expr{x^2} contribution, as Calc bends the |
d7b8e6c6 EZ |
24534 | line slightly to improve the fit. |
24535 | ||
24536 | @example | |
24537 | 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998 | |
24538 | @end example | |
24539 | ||
24540 | An important result from the theory of polynomial fitting is that it | |
5d67986c | 24541 | is always possible to fit @var{n} data points exactly using a polynomial |
8e04863e | 24542 | of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}. |
d7b8e6c6 EZ |
24543 | Using the modified (14) data matrix, a model number of 4 gives |
24544 | a polynomial that exactly matches all five data points: | |
24545 | ||
24546 | @example | |
24547 | 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4. | |
24548 | @end example | |
24549 | ||
24550 | The actual coefficients we get with a precision of 12, like | |
a4231b04 | 24551 | @expr{0.0416666663588}, clearly suffer from loss of precision. |
d7b8e6c6 EZ |
24552 | It is a good idea to increase the working precision to several |
24553 | digits beyond what you need when you do a fitting operation. | |
07ce2eb3 | 24554 | Or, if your data are exact, use Fraction mode to get exact |
d7b8e6c6 EZ |
24555 | results. |
24556 | ||
24557 | You can type @kbd{i} instead of a digit at the model prompt to fit | |
24558 | the data exactly to a polynomial. This just counts the number of | |
24559 | columns of the data matrix to choose the degree of the polynomial | |
24560 | automatically. | |
24561 | ||
24562 | Fitting data ``exactly'' to high-degree polynomials is not always | |
24563 | a good idea, though. High-degree polynomials have a tendency to | |
24564 | wiggle uncontrollably in between the fitting data points. Also, | |
24565 | if the exact-fit polynomial is going to be used to interpolate or | |
24566 | extrapolate the data, it is numerically better to use the @kbd{a p} | |
24567 | command described below. @xref{Interpolation}. | |
24568 | ||
24569 | @tex | |
24570 | \bigskip | |
24571 | @end tex | |
24572 | ||
24573 | Another generalization of the linear model is to assume the | |
a4231b04 JB |
24574 | @expr{y} values are a sum of linear contributions from several |
24575 | @expr{x} values. This is a @dfn{multilinear} fit, and it is also | |
d7b8e6c6 EZ |
24576 | selected by the @kbd{1} digit key. (Calc decides whether the fit |
24577 | is linear or multilinear by counting the rows in the data matrix.) | |
24578 | ||
24579 | Given the data matrix, | |
24580 | ||
d7b8e6c6 | 24581 | @example |
5d67986c | 24582 | @group |
d7b8e6c6 EZ |
24583 | [ [ 1, 2, 3, 4, 5 ] |
24584 | [ 7, 2, 3, 5, 2 ] | |
24585 | [ 14.5, 15, 18.5, 22.5, 24 ] ] | |
d7b8e6c6 | 24586 | @end group |
5d67986c | 24587 | @end example |
d7b8e6c6 EZ |
24588 | |
24589 | @noindent | |
a4231b04 JB |
24590 | the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the |
24591 | second row @expr{y}, and will fit the values in the third row to the | |
24592 | model @expr{a + b x + c y}. | |
d7b8e6c6 EZ |
24593 | |
24594 | @example | |
24595 | 8. + 3. x + 0.5 y | |
24596 | @end example | |
24597 | ||
24598 | Calc can do multilinear fits with any number of independent variables | |
24599 | (i.e., with any number of data rows). | |
24600 | ||
24601 | @tex | |
24602 | \bigskip | |
24603 | @end tex | |
24604 | ||
24605 | Yet another variation is @dfn{homogeneous} linear models, in which | |
24606 | the constant term is known to be zero. In the linear case, this | |
a4231b04 JB |
24607 | means the model formula is simply @expr{a x}; in the multilinear |
24608 | case, the model might be @expr{a x + b y + c z}; and in the polynomial | |
24609 | case, the model could be @expr{a x + b x^2 + c x^3}. You can get | |
d7b8e6c6 EZ |
24610 | a homogeneous linear or multilinear model by pressing the letter |
24611 | @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}. | |
24612 | ||
24613 | It is certainly possible to have other constrained linear models, | |
a4231b04 | 24614 | like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single |
d7b8e6c6 EZ |
24615 | key to select models like these, a later section shows how to enter |
24616 | any desired model by hand. In the first case, for example, you | |
24617 | would enter @kbd{a F ' 2.3 + a x}. | |
24618 | ||
24619 | Another class of models that will work but must be entered by hand | |
a4231b04 | 24620 | are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}. |
d7b8e6c6 EZ |
24621 | |
24622 | @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting | |
24623 | @subsection Error Estimates for Fits | |
24624 | ||
24625 | @noindent | |
24626 | @kindex H a F | |
24627 | @tindex efit | |
24628 | With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same | |
24629 | fitting operation as @kbd{a F}, but reports the coefficients as error | |
24630 | forms instead of plain numbers. Fitting our two data matrices (first | |
24631 | with 13, then with 14) to a line with @kbd{H a F} gives the results, | |
24632 | ||
24633 | @example | |
24634 | 3. + 2. x | |
24635 | 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x | |
24636 | @end example | |
24637 | ||
24638 | In the first case the estimated errors are zero because the linear | |
24639 | fit is perfect. In the second case, the errors are nonzero but | |
24640 | moderately small, because the data are still very close to linear. | |
24641 | ||
24642 | It is also possible for the @emph{input} to a fitting operation to | |
24643 | contain error forms. The data values must either all include errors | |
24644 | or all be plain numbers. Error forms can go anywhere but generally | |
24645 | go on the numbers in the last row of the data matrix. If the last | |
24646 | row contains error forms | |
bd712b70 JB |
24647 | @texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}', |
24648 | @infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}', | |
a4231b04 | 24649 | then the |
8e04863e | 24650 | @texline @math{\chi^2} |
a4231b04 | 24651 | @infoline @expr{chi^2} |
d7b8e6c6 EZ |
24652 | statistic is now, |
24653 | ||
24654 | @ifinfo | |
24655 | @example | |
24656 | chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N) | |
24657 | @end example | |
24658 | @end ifinfo | |
24659 | @tex | |
24660 | \turnoffactive | |
24661 | \beforedisplay | |
24662 | $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$ | |
24663 | \afterdisplay | |
24664 | @end tex | |
24665 | ||
24666 | @noindent | |
24667 | so that data points with larger error estimates contribute less to | |
24668 | the fitting operation. | |
24669 | ||
24670 | If there are error forms on other rows of the data matrix, all the | |
24671 | errors for a given data point are combined; the square root of the | |
a4231b04 | 24672 | sum of the squares of the errors forms the |
8e04863e | 24673 | @texline @math{\sigma_i} |
a4231b04 JB |
24674 | @infoline @expr{sigma_i} |
24675 | used for the data point. | |
d7b8e6c6 EZ |
24676 | |
24677 | Both @kbd{a F} and @kbd{H a F} can accept error forms in the input | |
24678 | matrix, although if you are concerned about error analysis you will | |
24679 | probably use @kbd{H a F} so that the output also contains error | |
24680 | estimates. | |
24681 | ||
a4231b04 | 24682 | If the input contains error forms but all the |
8e04863e | 24683 | @texline @math{\sigma_i} |
a4231b04 JB |
24684 | @infoline @expr{sigma_i} |
24685 | values are the same, it is easy to see that the resulting fitted model | |
24686 | will be the same as if the input did not have error forms at all | |
8e04863e | 24687 | @texline (@math{\chi^2} |
a4231b04 JB |
24688 | @infoline (@expr{chi^2} |
24689 | is simply scaled uniformly by | |
8e04863e | 24690 | @texline @math{1 / \sigma^2}, |
a4231b04 JB |
24691 | @infoline @expr{1 / sigma^2}, |
24692 | which doesn't affect where it has a minimum). But there @emph{will} be | |
24693 | a difference in the estimated errors of the coefficients reported by | |
24694 | @kbd{H a F}. | |
d7b8e6c6 | 24695 | |
28665d46 | 24696 | Consult any text on statistical modeling of data for a discussion |
d7b8e6c6 EZ |
24697 | of where these error estimates come from and how they should be |
24698 | interpreted. | |
24699 | ||
24700 | @tex | |
24701 | \bigskip | |
24702 | @end tex | |
24703 | ||
24704 | @kindex I a F | |
24705 | @tindex xfit | |
24706 | With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more | |
24707 | information. The result is a vector of six items: | |
24708 | ||
24709 | @enumerate | |
24710 | @item | |
24711 | The model formula with error forms for its coefficients or | |
24712 | parameters. This is the result that @kbd{H a F} would have | |
24713 | produced. | |
24714 | ||
24715 | @item | |
24716 | A vector of ``raw'' parameter values for the model. These are the | |
24717 | polynomial coefficients or other parameters as plain numbers, in the | |
24718 | same order as the parameters appeared in the final prompt of the | |
a4231b04 JB |
24719 | @kbd{I a F} command. For polynomials of degree @expr{d}, this vector |
24720 | will have length @expr{M = d+1} with the constant term first. | |
d7b8e6c6 EZ |
24721 | |
24722 | @item | |
a4231b04 | 24723 | The covariance matrix @expr{C} computed from the fit. This is |
5d67986c | 24724 | an @var{m}x@var{m} symmetric matrix; the diagonal elements |
8e04863e | 24725 | @texline @math{C_{jj}} |
a4231b04 JB |
24726 | @infoline @expr{C_j_j} |
24727 | are the variances | |
8e04863e | 24728 | @texline @math{\sigma_j^2} |
a4231b04 JB |
24729 | @infoline @expr{sigma_j^2} |
24730 | of the parameters. The other elements are covariances | |
8e04863e | 24731 | @texline @math{\sigma_{ij}^2} |
a4231b04 JB |
24732 | @infoline @expr{sigma_i_j^2} |
24733 | that describe the correlation between pairs of parameters. (A related | |
24734 | set of numbers, the @dfn{linear correlation coefficients} | |
8e04863e | 24735 | @texline @math{r_{ij}}, |
a4231b04 JB |
24736 | @infoline @expr{r_i_j}, |
24737 | are defined as | |
8e04863e | 24738 | @texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.) |
a4231b04 | 24739 | @infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.) |
d7b8e6c6 EZ |
24740 | |
24741 | @item | |
a4231b04 | 24742 | A vector of @expr{M} ``parameter filter'' functions whose |
d7b8e6c6 EZ |
24743 | meanings are described below. If no filters are necessary this |
24744 | will instead be an empty vector; this is always the case for the | |
24745 | polynomial and multilinear fits described so far. | |
24746 | ||
24747 | @item | |
a4231b04 | 24748 | The value of |
8e04863e | 24749 | @texline @math{\chi^2} |
a4231b04 JB |
24750 | @infoline @expr{chi^2} |
24751 | for the fit, calculated by the formulas shown above. This gives a | |
24752 | measure of the quality of the fit; statisticians consider | |
8e04863e | 24753 | @texline @math{\chi^2 \approx N - M} |
a4231b04 JB |
24754 | @infoline @expr{chi^2 = N - M} |
24755 | to indicate a moderately good fit (where again @expr{N} is the number of | |
24756 | data points and @expr{M} is the number of parameters). | |
d7b8e6c6 EZ |
24757 | |
24758 | @item | |
a4231b04 | 24759 | A measure of goodness of fit expressed as a probability @expr{Q}. |
d7b8e6c6 | 24760 | This is computed from the @code{utpc} probability distribution |
a4231b04 | 24761 | function using |
8e04863e | 24762 | @texline @math{\chi^2} |
a4231b04 JB |
24763 | @infoline @expr{chi^2} |
24764 | with @expr{N - M} degrees of freedom. A | |
d7b8e6c6 | 24765 | value of 0.5 implies a good fit; some texts recommend that often |
a4231b04 JB |
24766 | @expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In |
24767 | particular, | |
8e04863e | 24768 | @texline @math{\chi^2} |
a4231b04 JB |
24769 | @infoline @expr{chi^2} |
24770 | statistics assume the errors in your inputs | |
d7b8e6c6 | 24771 | follow a normal (Gaussian) distribution; if they don't, you may |
a4231b04 | 24772 | have to accept smaller values of @expr{Q}. |
d7b8e6c6 | 24773 | |
a4231b04 | 24774 | The @expr{Q} value is computed only if the input included error |
d7b8e6c6 | 24775 | estimates. Otherwise, Calc will report the symbol @code{nan} |
a4231b04 | 24776 | for @expr{Q}. The reason is that in this case the |
8e04863e | 24777 | @texline @math{\chi^2} |
a4231b04 | 24778 | @infoline @expr{chi^2} |
d7b8e6c6 EZ |
24779 | value has effectively been used to estimate the original errors |
24780 | in the input, and thus there is no redundant information left | |
24781 | over to use for a confidence test. | |
24782 | @end enumerate | |
24783 | ||
24784 | @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting | |
24785 | @subsection Standard Nonlinear Models | |
24786 | ||
24787 | @noindent | |
24788 | The @kbd{a F} command also accepts other kinds of models besides | |
24789 | lines and polynomials. Some common models have quick single-key | |
24790 | abbreviations; others must be entered by hand as algebraic formulas. | |
24791 | ||
24792 | Here is a complete list of the standard models recognized by @kbd{a F}: | |
24793 | ||
24794 | @table @kbd | |
24795 | @item 1 | |
8e04863e | 24796 | Linear or multilinear. @mathit{a + b x + c y + d z}. |
d7b8e6c6 | 24797 | @item 2-9 |
8e04863e | 24798 | Polynomials. @mathit{a + b x + c x^2 + d x^3}. |
d7b8e6c6 | 24799 | @item e |
bd712b70 | 24800 | Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}. |
d7b8e6c6 | 24801 | @item E |
bd712b70 | 24802 | Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}. |
d7b8e6c6 | 24803 | @item x |
bd712b70 | 24804 | Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}. |
d7b8e6c6 | 24805 | @item X |
bd712b70 | 24806 | Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}. |
d7b8e6c6 | 24807 | @item l |
bd712b70 | 24808 | Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}. |
d7b8e6c6 | 24809 | @item L |
bd712b70 | 24810 | Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}. |
d7b8e6c6 | 24811 | @item ^ |
8e04863e | 24812 | General exponential. @mathit{a b^x c^y}. |
d7b8e6c6 | 24813 | @item p |
8e04863e | 24814 | Power law. @mathit{a x^b y^c}. |
d7b8e6c6 | 24815 | @item q |
8e04863e | 24816 | Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}. |
d7b8e6c6 | 24817 | @item g |
a4231b04 | 24818 | Gaussian. |
8e04863e JB |
24819 | @texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}. |
24820 | @infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}. | |
d7b8e6c6 EZ |
24821 | @end table |
24822 | ||
24823 | All of these models are used in the usual way; just press the appropriate | |
24824 | letter at the model prompt, and choose variable names if you wish. The | |
24825 | result will be a formula as shown in the above table, with the best-fit | |
24826 | values of the parameters substituted. (You may find it easier to read | |
24827 | the parameter values from the vector that is placed in the trail.) | |
24828 | ||
24829 | All models except Gaussian and polynomials can generalize as shown to any | |
24830 | number of independent variables. Also, all the built-in models have an | |
a4231b04 | 24831 | additive or multiplicative parameter shown as @expr{a} in the above table |
d7b8e6c6 EZ |
24832 | which can be replaced by zero or one, as appropriate, by typing @kbd{h} |
24833 | before the model key. | |
24834 | ||
24835 | Note that many of these models are essentially equivalent, but express | |
a4231b04 | 24836 | the parameters slightly differently. For example, @expr{a b^x} and |
d7b8e6c6 EZ |
24837 | the other two exponential models are all algebraic rearrangements of |
24838 | each other. Also, the ``quadratic'' model is just a degree-2 polynomial | |
24839 | with the parameters expressed differently. Use whichever form best | |
24840 | matches the problem. | |
24841 | ||
24842 | The HP-28/48 calculators support four different models for curve | |
24843 | fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}. | |
24844 | These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)}, | |
24845 | @samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case, | |
a4231b04 JB |
24846 | @expr{a} is what the HP-48 identifies as the ``intercept,'' and |
24847 | @expr{b} is what it calls the ``slope.'' | |
d7b8e6c6 EZ |
24848 | |
24849 | @tex | |
24850 | \bigskip | |
24851 | @end tex | |
24852 | ||
24853 | If the model you want doesn't appear on this list, press @kbd{'} | |
24854 | (the apostrophe key) at the model prompt to enter any algebraic | |
24855 | formula, such as @kbd{m x - b}, as the model. (Not all models | |
24856 | will work, though---see the next section for details.) | |
24857 | ||
a4231b04 | 24858 | The model can also be an equation like @expr{y = m x + b}. |
d7b8e6c6 EZ |
24859 | In this case, Calc thinks of all the rows of the data matrix on |
24860 | equal terms; this model effectively has two parameters | |
a4231b04 JB |
24861 | (@expr{m} and @expr{b}) and two independent variables (@expr{x} |
24862 | and @expr{y}), with no ``dependent'' variables. Model equations | |
24863 | do not need to take this @expr{y =} form. For example, the | |
24864 | implicit line equation @expr{a x + b y = 1} works fine as a | |
d7b8e6c6 EZ |
24865 | model. |
24866 | ||
24867 | When you enter a model, Calc makes an alphabetical list of all | |
24868 | the variables that appear in the model. These are used for the | |
24869 | default parameters, independent variables, and dependent variable | |
24870 | (in that order). If you enter a plain formula (not an equation), | |
24871 | Calc assumes the dependent variable does not appear in the formula | |
24872 | and thus does not need a name. | |
24873 | ||
a4231b04 | 24874 | For example, if the model formula has the variables @expr{a,mu,sigma,t,x}, |
d7b8e6c6 | 24875 | and the data matrix has three rows (meaning two independent variables), |
a4231b04 JB |
24876 | Calc will use @expr{a,mu,sigma} as the default parameters, and the |
24877 | data rows will be named @expr{t} and @expr{x}, respectively. If you | |
24878 | enter an equation instead of a plain formula, Calc will use @expr{a,mu} | |
24879 | as the parameters, and @expr{sigma,t,x} as the three independent | |
d7b8e6c6 EZ |
24880 | variables. |
24881 | ||
24882 | You can, of course, override these choices by entering something | |
24883 | different at the prompt. If you leave some variables out of the list, | |
24884 | those variables must have stored values and those stored values will | |
24885 | be used as constants in the model. (Stored values for the parameters | |
24886 | and independent variables are ignored by the @kbd{a F} command.) | |
24887 | If you list only independent variables, all the remaining variables | |
24888 | in the model formula will become parameters. | |
24889 | ||
24890 | If there are @kbd{$} signs in the model you type, they will stand | |
24891 | for parameters and all other variables (in alphabetical order) | |
24892 | will be independent. Use @kbd{$} for one parameter, @kbd{$$} for | |
24893 | another, and so on. Thus @kbd{$ x + $$} is another way to describe | |
24894 | a linear model. | |
24895 | ||
24896 | If you type a @kbd{$} instead of @kbd{'} at the model prompt itself, | |
24897 | Calc will take the model formula from the stack. (The data must then | |
24898 | appear at the second stack level.) The same conventions are used to | |
24899 | choose which variables in the formula are independent by default and | |
24900 | which are parameters. | |
24901 | ||
24902 | Models taken from the stack can also be expressed as vectors of | |
a4231b04 JB |
24903 | two or three elements, @expr{[@var{model}, @var{vars}]} or |
24904 | @expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars} | |
d7b8e6c6 EZ |
24905 | and @var{params} may be either a variable or a vector of variables. |
24906 | (If @var{params} is omitted, all variables in @var{model} except | |
a4231b04 | 24907 | those listed as @var{vars} are parameters.) |
d7b8e6c6 EZ |
24908 | |
24909 | When you enter a model manually with @kbd{'}, Calc puts a 3-vector | |
24910 | describing the model in the trail so you can get it back if you wish. | |
24911 | ||
24912 | @tex | |
24913 | \bigskip | |
24914 | @end tex | |
24915 | ||
24916 | @vindex Model1 | |
24917 | @vindex Model2 | |
24918 | Finally, you can store a model in one of the Calc variables | |
24919 | @code{Model1} or @code{Model2}, then use this model by typing | |
24920 | @kbd{a F u} or @kbd{a F U} (respectively). The value stored in | |
24921 | the variable can be any of the formats that @kbd{a F $} would | |
24922 | accept for a model on the stack. | |
24923 | ||
24924 | @tex | |
24925 | \bigskip | |
24926 | @end tex | |
24927 | ||
24928 | Calc uses the principal values of inverse functions like @code{ln} | |
24929 | and @code{arcsin} when doing fits. For example, when you enter | |
24930 | the model @samp{y = sin(a t + b)} Calc actually uses the easier | |
24931 | form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always | |
8e04863e | 24932 | returns results in the range from @mathit{-90} to 90 degrees (or the |
d7b8e6c6 EZ |
24933 | equivalent range in radians). Suppose you had data that you |
24934 | believed to represent roughly three oscillations of a sine wave, | |
a4231b04 | 24935 | so that the argument of the sine might go from zero to |
8e04863e JB |
24936 | @texline @math{3\times360} |
24937 | @infoline @mathit{3*360} | |
a4231b04 | 24938 | degrees. |
d7b8e6c6 EZ |
24939 | The above model would appear to be a good way to determine the |
24940 | true frequency and phase of the sine wave, but in practice it | |
24941 | would fail utterly. The righthand side of the actual model | |
a4231b04 | 24942 | @samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but |
8e04863e | 24943 | the lefthand side will bounce back and forth between @mathit{-90} and 90. |
a4231b04 | 24944 | No values of @expr{a} and @expr{b} can make the two sides match, |
d7b8e6c6 EZ |
24945 | even approximately. |
24946 | ||
24947 | There is no good solution to this problem at present. You could | |
24948 | restrict your data to small enough ranges so that the above problem | |
24949 | doesn't occur (i.e., not straddling any peaks in the sine wave). | |
24950 | Or, in this case, you could use a totally different method such as | |
24951 | Fourier analysis, which is beyond the scope of the @kbd{a F} command. | |
24952 | (Unfortunately, Calc does not currently have any facilities for | |
24953 | taking Fourier and related transforms.) | |
24954 | ||
24955 | @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting | |
24956 | @subsection Curve Fitting Details | |
24957 | ||
24958 | @noindent | |
24959 | Calc's internal least-squares fitter can only handle multilinear | |
24960 | models. More precisely, it can handle any model of the form | |
a4231b04 JB |
24961 | @expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c} |
24962 | are the parameters and @expr{x,y,z} are the independent variables | |
d7b8e6c6 EZ |
24963 | (of course there can be any number of each, not just three). |
24964 | ||
24965 | In a simple multilinear or polynomial fit, it is easy to see how | |
24966 | to convert the model into this form. For example, if the model | |
a4231b04 JB |
24967 | is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x}, |
24968 | and @expr{h(x) = x^2} are suitable functions. | |
d7b8e6c6 EZ |
24969 | |
24970 | For other models, Calc uses a variety of algebraic manipulations | |
24971 | to try to put the problem into the form | |
24972 | ||
24973 | @smallexample | |
24974 | Y(x,y,z) = A(a,b,c) F(x,y,z) + B(a,b,c) G(x,y,z) + C(a,b,c) H(x,y,z) | |
24975 | @end smallexample | |
24976 | ||
24977 | @noindent | |
a4231b04 JB |
24978 | where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes |
24979 | @expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points, | |
24980 | does a standard linear fit to find the values of @expr{A}, @expr{B}, | |
24981 | and @expr{C}, then uses the equation solver to solve for @expr{a,b,c} | |
24982 | in terms of @expr{A,B,C}. | |
d7b8e6c6 EZ |
24983 | |
24984 | A remarkable number of models can be cast into this general form. | |
24985 | We'll look at two examples here to see how it works. The power-law | |
a4231b04 | 24986 | model @expr{y = a x^b} with two independent variables and two parameters |
d7b8e6c6 EZ |
24987 | can be rewritten as follows: |
24988 | ||
24989 | @example | |
24990 | y = a x^b | |
24991 | y = a exp(b ln(x)) | |
24992 | y = exp(ln(a) + b ln(x)) | |
24993 | ln(y) = ln(a) + b ln(x) | |
24994 | @end example | |
24995 | ||
24996 | @noindent | |
a4231b04 | 24997 | which matches the desired form with |
8e04863e | 24998 | @texline @math{Y = \ln(y)}, |
a4231b04 | 24999 | @infoline @expr{Y = ln(y)}, |
8e04863e | 25000 | @texline @math{A = \ln(a)}, |
a4231b04 JB |
25001 | @infoline @expr{A = ln(a)}, |
25002 | @expr{F = 1}, @expr{B = b}, and | |
8e04863e | 25003 | @texline @math{G = \ln(x)}. |
a4231b04 JB |
25004 | @infoline @expr{G = ln(x)}. |
25005 | Calc thus computes the logarithms of your @expr{y} and @expr{x} values, | |
25006 | does a linear fit for @expr{A} and @expr{B}, then solves to get | |
8e04863e | 25007 | @texline @math{a = \exp(A)} |
a4231b04 JB |
25008 | @infoline @expr{a = exp(A)} |
25009 | and @expr{b = B}. | |
d7b8e6c6 EZ |
25010 | |
25011 | Another interesting example is the ``quadratic'' model, which can | |
25012 | be handled by expanding according to the distributive law. | |
25013 | ||
25014 | @example | |
25015 | y = a + b*(x - c)^2 | |
25016 | y = a + b c^2 - 2 b c x + b x^2 | |
25017 | @end example | |
25018 | ||
25019 | @noindent | |
a4231b04 | 25020 | which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1}, |
8e04863e | 25021 | @expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily |
a4231b04 JB |
25022 | have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and |
25023 | @expr{H = x^2}. | |
d7b8e6c6 EZ |
25024 | |
25025 | The Gaussian model looks quite complicated, but a closer examination | |
25026 | shows that it's actually similar to the quadratic model but with an | |
a4231b04 | 25027 | exponential that can be brought to the top and moved into @expr{Y}. |
d7b8e6c6 EZ |
25028 | |
25029 | An example of a model that cannot be put into general linear | |
25030 | form is a Gaussian with a constant background added on, i.e., | |
a4231b04 | 25031 | @expr{d} + the regular Gaussian formula. If you have a model like |
d7b8e6c6 EZ |
25032 | this, your best bet is to replace enough of your parameters with |
25033 | constants to make the model linearizable, then adjust the constants | |
25034 | manually by doing a series of fits. You can compare the fits by | |
25035 | graphing them, by examining the goodness-of-fit measures returned by | |
25036 | @kbd{I a F}, or by some other method suitable to your application. | |
25037 | Note that some models can be linearized in several ways. The | |
a4231b04 JB |
25038 | Gaussian-plus-@var{d} model can be linearized by setting @expr{d} |
25039 | (the background) to a constant, or by setting @expr{b} (the standard | |
25040 | deviation) and @expr{c} (the mean) to constants. | |
d7b8e6c6 EZ |
25041 | |
25042 | To fit a model with constants substituted for some parameters, just | |
25043 | store suitable values in those parameter variables, then omit them | |
25044 | from the list of parameters when you answer the variables prompt. | |
25045 | ||
25046 | @tex | |
25047 | \bigskip | |
25048 | @end tex | |
25049 | ||
25050 | A last desperate step would be to use the general-purpose | |
25051 | @code{minimize} function rather than @code{fit}. After all, both | |
a4231b04 | 25052 | functions solve the problem of minimizing an expression (the |
8e04863e | 25053 | @texline @math{\chi^2} |
a4231b04 | 25054 | @infoline @expr{chi^2} |
d7b8e6c6 EZ |
25055 | sum) by adjusting certain parameters in the expression. The @kbd{a F} |
25056 | command is able to use a vastly more efficient algorithm due to its | |
25057 | special knowledge about linear chi-square sums, but the @kbd{a N} | |
25058 | command can do the same thing by brute force. | |
25059 | ||
25060 | A compromise would be to pick out a few parameters without which the | |
25061 | fit is linearizable, and use @code{minimize} on a call to @code{fit} | |
25062 | which efficiently takes care of the rest of the parameters. The thing | |
a4231b04 | 25063 | to be minimized would be the value of |
8e04863e | 25064 | @texline @math{\chi^2} |
a4231b04 JB |
25065 | @infoline @expr{chi^2} |
25066 | returned as the fifth result of the @code{xfit} function: | |
d7b8e6c6 EZ |
25067 | |
25068 | @smallexample | |
25069 | minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess) | |
25070 | @end smallexample | |
25071 | ||
25072 | @noindent | |
25073 | where @code{gaus} represents the Gaussian model with background, | |
25074 | @code{data} represents the data matrix, and @code{guess} represents | |
a4231b04 | 25075 | the initial guess for @expr{d} that @code{minimize} requires. |
d7b8e6c6 EZ |
25076 | This operation will only be, shall we say, extraordinarily slow |
25077 | rather than astronomically slow (as would be the case if @code{minimize} | |
25078 | were used by itself to solve the problem). | |
25079 | ||
25080 | @tex | |
25081 | \bigskip | |
25082 | @end tex | |
25083 | ||
25084 | The @kbd{I a F} [@code{xfit}] command is somewhat trickier when | |
25085 | nonlinear models are used. The second item in the result is the | |
a4231b04 | 25086 | vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The |
d7b8e6c6 EZ |
25087 | covariance matrix is written in terms of those raw parameters. |
25088 | The fifth item is a vector of @dfn{filter} expressions. This | |
25089 | is the empty vector @samp{[]} if the raw parameters were the same | |
a4231b04 | 25090 | as the requested parameters, i.e., if @expr{A = a}, @expr{B = b}, |
d7b8e6c6 EZ |
25091 | and so on (which is always true if the model is already linear |
25092 | in the parameters as written, e.g., for polynomial fits). If the | |
25093 | parameters had to be rearranged, the fifth item is instead a vector | |
25094 | of one formula per parameter in the original model. The raw | |
25095 | parameters are expressed in these ``filter'' formulas as | |
a4231b04 | 25096 | @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B}, |
d7b8e6c6 EZ |
25097 | and so on. |
25098 | ||
25099 | When Calc needs to modify the model to return the result, it replaces | |
25100 | @samp{fitdummy(1)} in all the filters with the first item in the raw | |
25101 | parameters list, and so on for the other raw parameters, then | |
25102 | evaluates the resulting filter formulas to get the actual parameter | |
25103 | values to be substituted into the original model. In the case of | |
25104 | @kbd{H a F} and @kbd{I a F} where the parameters must be error forms, | |
25105 | Calc uses the square roots of the diagonal entries of the covariance | |
25106 | matrix as error values for the raw parameters, then lets Calc's | |
25107 | standard error-form arithmetic take it from there. | |
25108 | ||
25109 | If you use @kbd{I a F} with a nonlinear model, be sure to remember | |
25110 | that the covariance matrix is in terms of the raw parameters, | |
25111 | @emph{not} the actual requested parameters. It's up to you to | |
25112 | figure out how to interpret the covariances in the presence of | |
25113 | nontrivial filter functions. | |
25114 | ||
25115 | Things are also complicated when the input contains error forms. | |
a4231b04 JB |
25116 | Suppose there are three independent and dependent variables, @expr{x}, |
25117 | @expr{y}, and @expr{z}, one or more of which are error forms in the | |
d7b8e6c6 | 25118 | data. Calc combines all the error values by taking the square root |
a4231b04 JB |
25119 | of the sum of the squares of the errors. It then changes @expr{x} |
25120 | and @expr{y} to be plain numbers, and makes @expr{z} into an error | |
25121 | form with this combined error. The @expr{Y(x,y,z)} part of the | |
d7b8e6c6 | 25122 | linearized model is evaluated, and the result should be an error |
a4231b04 | 25123 | form. The error part of that result is used for |
8e04863e | 25124 | @texline @math{\sigma_i} |
a4231b04 JB |
25125 | @infoline @expr{sigma_i} |
25126 | for the data point. If for some reason @expr{Y(x,y,z)} does not return | |
25127 | an error form, the combined error from @expr{z} is used directly for | |
8e04863e | 25128 | @texline @math{\sigma_i}. |
a4231b04 JB |
25129 | @infoline @expr{sigma_i}. |
25130 | Finally, @expr{z} is also stripped of its error | |
25131 | for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on; | |
d7b8e6c6 EZ |
25132 | the righthand side of the linearized model is computed in regular |
25133 | arithmetic with no error forms. | |
25134 | ||
25135 | (While these rules may seem complicated, they are designed to do | |
a4231b04 JB |
25136 | the most reasonable thing in the typical case that @expr{Y(x,y,z)} |
25137 | depends only on the dependent variable @expr{z}, and in fact is | |
25138 | often simply equal to @expr{z}. For common cases like polynomials | |
d7b8e6c6 | 25139 | and multilinear models, the combined error is simply used as the |
8e04863e | 25140 | @texline @math{\sigma} |
a4231b04 JB |
25141 | @infoline @expr{sigma} |
25142 | for the data point with no further ado.) | |
d7b8e6c6 EZ |
25143 | |
25144 | @tex | |
25145 | \bigskip | |
25146 | @end tex | |
25147 | ||
25148 | @vindex FitRules | |
25149 | It may be the case that the model you wish to use is linearizable, | |
25150 | but Calc's built-in rules are unable to figure it out. Calc uses | |
25151 | its algebraic rewrite mechanism to linearize a model. The rewrite | |
25152 | rules are kept in the variable @code{FitRules}. You can edit this | |
25153 | variable using the @kbd{s e FitRules} command; in fact, there is | |
25154 | a special @kbd{s F} command just for editing @code{FitRules}. | |
25155 | @xref{Operations on Variables}. | |
25156 | ||
25157 | @xref{Rewrite Rules}, for a discussion of rewrite rules. | |
25158 | ||
5d67986c RS |
25159 | @ignore |
25160 | @starindex | |
25161 | @end ignore | |
d7b8e6c6 | 25162 | @tindex fitvar |
5d67986c RS |
25163 | @ignore |
25164 | @starindex | |
25165 | @end ignore | |
25166 | @ignore | |
25167 | @mindex @idots | |
25168 | @end ignore | |
d7b8e6c6 | 25169 | @tindex fitparam |
5d67986c RS |
25170 | @ignore |
25171 | @starindex | |
25172 | @end ignore | |
25173 | @ignore | |
25174 | @mindex @null | |
25175 | @end ignore | |
d7b8e6c6 | 25176 | @tindex fitmodel |
5d67986c RS |
25177 | @ignore |
25178 | @starindex | |
25179 | @end ignore | |
25180 | @ignore | |
25181 | @mindex @null | |
25182 | @end ignore | |
d7b8e6c6 | 25183 | @tindex fitsystem |
5d67986c RS |
25184 | @ignore |
25185 | @starindex | |
25186 | @end ignore | |
25187 | @ignore | |
25188 | @mindex @null | |
25189 | @end ignore | |
d7b8e6c6 EZ |
25190 | @tindex fitdummy |
25191 | Calc uses @code{FitRules} as follows. First, it converts the model | |
25192 | to an equation if necessary and encloses the model equation in a | |
25193 | call to the function @code{fitmodel} (which is not actually a defined | |
25194 | function in Calc; it is only used as a placeholder by the rewrite rules). | |
25195 | Parameter variables are renamed to function calls @samp{fitparam(1)}, | |
25196 | @samp{fitparam(2)}, and so on, and independent variables are renamed | |
25197 | to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable | |
25198 | is the highest-numbered @code{fitvar}. For example, the power law | |
a4231b04 | 25199 | model @expr{a x^b} is converted to @expr{y = a x^b}, then to |
d7b8e6c6 | 25200 | |
d7b8e6c6 | 25201 | @smallexample |
5d67986c | 25202 | @group |
d7b8e6c6 | 25203 | fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2)) |
d7b8e6c6 | 25204 | @end group |
5d67986c | 25205 | @end smallexample |
d7b8e6c6 EZ |
25206 | |
25207 | Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}. | |
25208 | (The zero prefix means that rewriting should continue until no further | |
25209 | changes are possible.) | |
25210 | ||
25211 | When rewriting is complete, the @code{fitmodel} call should have | |
25212 | been replaced by a @code{fitsystem} call that looks like this: | |
25213 | ||
25214 | @example | |
25215 | fitsystem(@var{Y}, @var{FGH}, @var{abc}) | |
25216 | @end example | |
25217 | ||
25218 | @noindent | |
a4231b04 JB |
25219 | where @var{Y} is a formula that describes the function @expr{Y(x,y,z)}, |
25220 | @var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]}, | |
d7b8e6c6 | 25221 | and @var{abc} is the vector of parameter filters which refer to the |
a4231b04 JB |
25222 | raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} |
25223 | for @expr{B}, etc. While the number of raw parameters (the length of | |
d7b8e6c6 EZ |
25224 | the @var{FGH} vector) is usually the same as the number of original |
25225 | parameters (the length of the @var{abc} vector), this is not required. | |
25226 | ||
25227 | The power law model eventually boils down to | |
25228 | ||
d7b8e6c6 | 25229 | @smallexample |
5d67986c | 25230 | @group |
d7b8e6c6 EZ |
25231 | fitsystem(ln(fitvar(2)), |
25232 | [1, ln(fitvar(1))], | |
25233 | [exp(fitdummy(1)), fitdummy(2)]) | |
d7b8e6c6 | 25234 | @end group |
5d67986c | 25235 | @end smallexample |
d7b8e6c6 EZ |
25236 | |
25237 | The actual implementation of @code{FitRules} is complicated; it | |
25238 | proceeds in four phases. First, common rearrangements are done | |
25239 | to try to bring linear terms together and to isolate functions like | |
25240 | @code{exp} and @code{ln} either all the way ``out'' (so that they | |
25241 | can be put into @var{Y}) or all the way ``in'' (so that they can | |
25242 | be put into @var{abc} or @var{FGH}). In particular, all | |
25243 | non-constant powers are converted to logs-and-exponentials form, | |
25244 | and the distributive law is used to expand products of sums. | |
25245 | Quotients are rewritten to use the @samp{fitinv} function, where | |
a4231b04 | 25246 | @samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules} |
d7b8e6c6 EZ |
25247 | are operating. (The use of @code{fitinv} makes recognition of |
25248 | linear-looking forms easier.) If you modify @code{FitRules}, you | |
25249 | will probably only need to modify the rules for this phase. | |
25250 | ||
25251 | Phase two, whose rules can actually also apply during phases one | |
25252 | and three, first rewrites @code{fitmodel} to a two-argument | |
25253 | form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is | |
a4231b04 JB |
25254 | initially zero and @var{model} has been changed from @expr{a=b} |
25255 | to @expr{a-b} form. It then tries to peel off invertible functions | |
d7b8e6c6 EZ |
25256 | from the outside of @var{model} and put them into @var{Y} instead, |
25257 | calling the equation solver to invert the functions. Finally, when | |
25258 | this is no longer possible, the @code{fitmodel} is changed to a | |
25259 | four-argument @code{fitsystem}, where the fourth argument is | |
25260 | @var{model} and the @var{FGH} and @var{abc} vectors are initially | |
25261 | empty. (The last vector is really @var{ABC}, corresponding to | |
25262 | raw parameters, for now.) | |
25263 | ||
25264 | Phase three converts a sum of items in the @var{model} to a sum | |
25265 | of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent | |
25266 | terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a} | |
25267 | is all factors that do not involve any variables, @var{b} is all | |
25268 | factors that involve only parameters, and @var{c} is the factors | |
25269 | that involve only independent variables. (If this decomposition | |
25270 | is not possible, the rule set will not complete and Calc will | |
25271 | complain that the model is too complex.) Then @code{fitpart}s | |
25272 | with equal @var{b} or @var{c} components are merged back together | |
25273 | using the distributive law in order to minimize the number of | |
25274 | raw parameters needed. | |
25275 | ||
25276 | Phase four moves the @code{fitpart} terms into the @var{FGH} and | |
25277 | @var{ABC} vectors. Also, some of the algebraic expansions that | |
25278 | were done in phase 1 are undone now to make the formulas more | |
25279 | computationally efficient. Finally, it calls the solver one more | |
25280 | time to convert the @var{ABC} vector to an @var{abc} vector, and | |
25281 | removes the fourth @var{model} argument (which by now will be zero) | |
25282 | to obtain the three-argument @code{fitsystem} that the linear | |
25283 | least-squares solver wants to see. | |
25284 | ||
5d67986c RS |
25285 | @ignore |
25286 | @starindex | |
25287 | @end ignore | |
25288 | @ignore | |
25289 | @mindex hasfit@idots | |
25290 | @end ignore | |
d7b8e6c6 | 25291 | @tindex hasfitparams |
5d67986c RS |
25292 | @ignore |
25293 | @starindex | |
25294 | @end ignore | |
25295 | @ignore | |
25296 | @mindex @null | |
25297 | @end ignore | |
d7b8e6c6 EZ |
25298 | @tindex hasfitvars |
25299 | Two functions which are useful in connection with @code{FitRules} | |
25300 | are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check | |
a4231b04 | 25301 | whether @expr{x} refers to any parameters or independent variables, |
d7b8e6c6 EZ |
25302 | respectively. Specifically, these functions return ``true'' if the |
25303 | argument contains any @code{fitparam} (or @code{fitvar}) function | |
25304 | calls, and ``false'' otherwise. (Recall that ``true'' means a | |
25305 | nonzero number, and ``false'' means zero. The actual nonzero number | |
25306 | returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s | |
25307 | or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.) | |
25308 | ||
25309 | @tex | |
25310 | \bigskip | |
25311 | @end tex | |
25312 | ||
25313 | The @code{fit} function in algebraic notation normally takes four | |
25314 | arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})}, | |
25315 | where @var{model} is the model formula as it would be typed after | |
25316 | @kbd{a F '}, @var{vars} is the independent variable or a vector of | |
25317 | independent variables, @var{params} likewise gives the parameter(s), | |
25318 | and @var{data} is the data matrix. Note that the length of @var{vars} | |
25319 | must be equal to the number of rows in @var{data} if @var{model} is | |
25320 | an equation, or one less than the number of rows if @var{model} is | |
25321 | a plain formula. (Actually, a name for the dependent variable is | |
25322 | allowed but will be ignored in the plain-formula case.) | |
25323 | ||
25324 | If @var{params} is omitted, the parameters are all variables in | |
25325 | @var{model} except those that appear in @var{vars}. If @var{vars} | |
25326 | is also omitted, Calc sorts all the variables that appear in | |
25327 | @var{model} alphabetically and uses the higher ones for @var{vars} | |
25328 | and the lower ones for @var{params}. | |
25329 | ||
25330 | Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed | |
25331 | where @var{modelvec} is a 2- or 3-vector describing the model | |
25332 | and variables, as discussed previously. | |
25333 | ||
25334 | If Calc is unable to do the fit, the @code{fit} function is left | |
25335 | in symbolic form, ordinarily with an explanatory message. The | |
25336 | message will be ``Model expression is too complex'' if the | |
25337 | linearizer was unable to put the model into the required form. | |
25338 | ||
25339 | The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit} | |
25340 | (for @kbd{I a F}) functions are completely analogous. | |
25341 | ||
25342 | @node Interpolation, , Curve Fitting Details, Curve Fitting | |
25343 | @subsection Polynomial Interpolation | |
25344 | ||
25345 | @kindex a p | |
25346 | @pindex calc-poly-interp | |
25347 | @tindex polint | |
25348 | The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does | |
a4231b04 | 25349 | a polynomial interpolation at a particular @expr{x} value. It takes |
d7b8e6c6 | 25350 | two arguments from the stack: A data matrix of the sort used by |
a4231b04 | 25351 | @kbd{a F}, and a single number which represents the desired @expr{x} |
d7b8e6c6 | 25352 | value. Calc effectively does an exact polynomial fit as if by @kbd{a F i}, |
a4231b04 JB |
25353 | then substitutes the @expr{x} value into the result in order to get an |
25354 | approximate @expr{y} value based on the fit. (Calc does not actually | |
d7b8e6c6 EZ |
25355 | use @kbd{a F i}, however; it uses a direct method which is both more |
25356 | efficient and more numerically stable.) | |
25357 | ||
a4231b04 JB |
25358 | The result of @kbd{a p} is actually a vector of two values: The @expr{y} |
25359 | value approximation, and an error measure @expr{dy} that reflects Calc's | |
d7b8e6c6 | 25360 | estimation of the probable error of the approximation at that value of |
a4231b04 JB |
25361 | @expr{x}. If the input @expr{x} is equal to any of the @expr{x} values |
25362 | in the data matrix, the output @expr{y} will be the corresponding @expr{y} | |
25363 | value from the matrix, and the output @expr{dy} will be exactly zero. | |
d7b8e6c6 EZ |
25364 | |
25365 | A prefix argument of 2 causes @kbd{a p} to take separate x- and | |
25366 | y-vectors from the stack instead of one data matrix. | |
25367 | ||
a4231b04 JB |
25368 | If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of |
25369 | interpolated results for each of those @expr{x} values. (The matrix will | |
25370 | have two columns, the @expr{y} values and the @expr{dy} values.) | |
25371 | If @expr{x} is a formula instead of a number, the @code{polint} function | |
d7b8e6c6 EZ |
25372 | remains in symbolic form; use the @kbd{a "} command to expand it out to |
25373 | a formula that describes the fit in symbolic terms. | |
25374 | ||
25375 | In all cases, the @kbd{a p} command leaves the data vectors or matrix | |
a4231b04 | 25376 | on the stack. Only the @expr{x} value is replaced by the result. |
d7b8e6c6 EZ |
25377 | |
25378 | @kindex H a p | |
25379 | @tindex ratint | |
25380 | The @kbd{H a p} [@code{ratint}] command does a rational function | |
25381 | interpolation. It is used exactly like @kbd{a p}, except that it | |
25382 | uses as its model the quotient of two polynomials. If there are | |
a4231b04 JB |
25383 | @expr{N} data points, the numerator and denominator polynomials will |
25384 | each have degree @expr{N/2} (if @expr{N} is odd, the denominator will | |
d7b8e6c6 EZ |
25385 | have degree one higher than the numerator). |
25386 | ||
25387 | Rational approximations have the advantage that they can accurately | |
25388 | describe functions that have poles (points at which the function's value | |
25389 | goes to infinity, so that the denominator polynomial of the approximation | |
a4231b04 | 25390 | goes to zero). If @expr{x} corresponds to a pole of the fitted rational |
d7b8e6c6 EZ |
25391 | function, then the result will be a division by zero. If Infinite mode |
25392 | is enabled, the result will be @samp{[uinf, uinf]}. | |
25393 | ||
25394 | There is no way to get the actual coefficients of the rational function | |
25395 | used by @kbd{H a p}. (The algorithm never generates these coefficients | |
25396 | explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s | |
25397 | capabilities to fit.) | |
25398 | ||
25399 | @node Summations, Logical Operations, Curve Fitting, Algebra | |
25400 | @section Summations | |
25401 | ||
25402 | @noindent | |
25403 | @cindex Summation of a series | |
25404 | @kindex a + | |
25405 | @pindex calc-summation | |
25406 | @tindex sum | |
25407 | The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes | |
25408 | the sum of a formula over a certain range of index values. The formula | |
25409 | is taken from the top of the stack; the command prompts for the | |
25410 | name of the summation index variable, the lower limit of the | |
25411 | sum (any formula), and the upper limit of the sum. If you | |
25412 | enter a blank line at any of these prompts, that prompt and | |
25413 | any later ones are answered by reading additional elements from | |
5d67986c | 25414 | the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}} |
d7b8e6c6 EZ |
25415 | produces the result 55. |
25416 | @tex | |
25417 | \turnoffactive | |
25418 | $$ \sum_{k=1}^5 k^2 = 55 $$ | |
25419 | @end tex | |
25420 | ||
25421 | The choice of index variable is arbitrary, but it's best not to | |
25422 | use a variable with a stored value. In particular, while | |
25423 | @code{i} is often a favorite index variable, it should be avoided | |
a4231b04 | 25424 | in Calc because @code{i} has the imaginary constant @expr{(0, 1)} |
d7b8e6c6 | 25425 | as a value. If you pressed @kbd{=} on a sum over @code{i}, it would |
a4231b04 | 25426 | be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}! |
d7b8e6c6 | 25427 | If you really want to use @code{i} as an index variable, use |
5d67986c | 25428 | @w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable. |
d7b8e6c6 EZ |
25429 | (@xref{Storing Variables}.) |
25430 | ||
25431 | A numeric prefix argument steps the index by that amount rather | |
5d67986c | 25432 | than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}} |
d7b8e6c6 EZ |
25433 | yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix |
25434 | argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the | |
25435 | step value, in which case you can enter any formula or enter | |
25436 | a blank line to take the step value from the stack. With the | |
25437 | @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from | |
25438 | the stack: The formula, the variable, the lower limit, the | |
25439 | upper limit, and (at the top of the stack), the step value. | |
25440 | ||
25441 | Calc knows how to do certain sums in closed form. For example, | |
25442 | @samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular, | |
25443 | this is possible if the formula being summed is polynomial or | |
25444 | exponential in the index variable. Sums of logarithms are | |
25445 | transformed into logarithms of products. Sums of trigonometric | |
25446 | and hyperbolic functions are transformed to sums of exponentials | |
25447 | and then done in closed form. Also, of course, sums in which the | |
25448 | lower and upper limits are both numbers can always be evaluated | |
25449 | just by grinding them out, although Calc will use closed forms | |
25450 | whenever it can for the sake of efficiency. | |
25451 | ||
25452 | The notation for sums in algebraic formulas is | |
25453 | @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}. | |
25454 | If @var{step} is omitted, it defaults to one. If @var{high} is | |
25455 | omitted, @var{low} is actually the upper limit and the lower limit | |
25456 | is one. If @var{low} is also omitted, the limits are @samp{-inf} | |
25457 | and @samp{inf}, respectively. | |
25458 | ||
25459 | Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)} | |
a4231b04 | 25460 | returns @expr{1}. This is done by evaluating the sum in closed |
d7b8e6c6 EZ |
25461 | form (to @samp{1. - 0.5^n} in this case), then evaluating this |
25462 | formula with @code{n} set to @code{inf}. Calc's usual rules | |
25463 | for ``infinite'' arithmetic can find the answer from there. If | |
25464 | infinite arithmetic yields a @samp{nan}, or if the sum cannot be | |
25465 | solved in closed form, Calc leaves the @code{sum} function in | |
25466 | symbolic form. @xref{Infinities}. | |
25467 | ||
25468 | As a special feature, if the limits are infinite (or omitted, as | |
25469 | described above) but the formula includes vectors subscripted by | |
25470 | expressions that involve the iteration variable, Calc narrows | |
25471 | the limits to include only the range of integers which result in | |
2cbd16b9 | 25472 | valid subscripts for the vector. For example, the sum |
d7b8e6c6 EZ |
25473 | @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}. |
25474 | ||
25475 | The limits of a sum do not need to be integers. For example, | |
25476 | @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}. | |
25477 | Calc computes the number of iterations using the formula | |
25478 | @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must, | |
25479 | after simplification as if by @kbd{a s}, evaluate to an integer. | |
25480 | ||
25481 | If the number of iterations according to the above formula does | |
ce7c7522 | 25482 | not come out to an integer, the sum is invalid and will be left |
d7b8e6c6 EZ |
25483 | in symbolic form. However, closed forms are still supplied, and |
25484 | you are on your honor not to misuse the resulting formulas by | |
25485 | substituting mismatched bounds into them. For example, | |
25486 | @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and | |
25487 | evaluate the closed form solution for the limits 1 and 10 to get | |
25488 | the rather dubious answer, 29.25. | |
25489 | ||
25490 | If the lower limit is greater than the upper limit (assuming a | |
25491 | positive step size), the result is generally zero. However, | |
25492 | Calc only guarantees a zero result when the upper limit is | |
25493 | exactly one step less than the lower limit, i.e., if the number | |
8e04863e | 25494 | of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero |
d7b8e6c6 EZ |
25495 | but the sum from @samp{n} to @samp{n-2} may report a nonzero value |
25496 | if Calc used a closed form solution. | |
25497 | ||
a4231b04 | 25498 | Calc's logical predicates like @expr{a < b} return 1 for ``true'' |
d7b8e6c6 EZ |
25499 | and 0 for ``false.'' @xref{Logical Operations}. This can be |
25500 | used to advantage for building conditional sums. For example, | |
25501 | @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all | |
25502 | prime numbers from 1 to 20; the @code{prime} predicate returns 1 if | |
25503 | its argument is prime and 0 otherwise. You can read this expression | |
a4231b04 | 25504 | as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed, |
d7b8e6c6 EZ |
25505 | @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes |
25506 | squared, since the limits default to plus and minus infinity, but | |
25507 | there are no such sums that Calc's built-in rules can do in | |
25508 | closed form. | |
25509 | ||
25510 | As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the | |
a4231b04 JB |
25511 | sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding |
25512 | one value @expr{k_0}. Slightly more tricky is the summand | |
d7b8e6c6 | 25513 | @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe |
a4231b04 JB |
25514 | the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where |
25515 | this would be a division by zero. But at @expr{k = k_0}, this | |
25516 | formula works out to the indeterminate form @expr{0 / 0}, which | |
d7b8e6c6 EZ |
25517 | Calc will not assume is zero. Better would be to use |
25518 | @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does | |
a4231b04 | 25519 | an ``if-then-else'' test: This expression says, ``if |
8e04863e | 25520 | @texline @math{k \ne k_0}, |
a4231b04 JB |
25521 | @infoline @expr{k != k_0}, |
25522 | then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)} | |
25523 | will not even be evaluated by Calc when @expr{k = k_0}. | |
d7b8e6c6 EZ |
25524 | |
25525 | @cindex Alternating sums | |
25526 | @kindex a - | |
25527 | @pindex calc-alt-summation | |
25528 | @tindex asum | |
25529 | The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command | |
25530 | computes an alternating sum. Successive terms of the sequence | |
25531 | are given alternating signs, with the first term (corresponding | |
25532 | to the lower index value) being positive. Alternating sums | |
25533 | are converted to normal sums with an extra term of the form | |
25534 | @samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately | |
25535 | if the step value is other than one. For example, the Taylor | |
25536 | series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}. | |
25537 | (Calc cannot evaluate this infinite series, but it can approximate | |
25538 | it if you replace @code{inf} with any particular odd number.) | |
25539 | Calc converts this series to a regular sum with a step of one, | |
25540 | namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}. | |
25541 | ||
25542 | @cindex Product of a sequence | |
25543 | @kindex a * | |
25544 | @pindex calc-product | |
25545 | @tindex prod | |
25546 | The @kbd{a *} (@code{calc-product}) [@code{prod}] command is | |
25547 | the analogous way to take a product of many terms. Calc also knows | |
25548 | some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}. | |
25549 | Conditional products can be written @samp{prod(k^prime(k), k, 1, n)} | |
25550 | or @samp{prod(prime(k) ? k : 1, k, 1, n)}. | |
25551 | ||
25552 | @kindex a T | |
25553 | @pindex calc-tabulate | |
25554 | @tindex table | |
25555 | The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command | |
25556 | evaluates a formula at a series of iterated index values, just | |
25557 | like @code{sum} and @code{prod}, but its result is simply a | |
25558 | vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)} | |
25559 | produces @samp{[a_1, a_3, a_5, a_7]}. | |
25560 | ||
25561 | @node Logical Operations, Rewrite Rules, Summations, Algebra | |
25562 | @section Logical Operations | |
25563 | ||
25564 | @noindent | |
25565 | The following commands and algebraic functions return true/false values, | |
25566 | where 1 represents ``true'' and 0 represents ``false.'' In cases where | |
25567 | a truth value is required (such as for the condition part of a rewrite | |
25568 | rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any | |
25569 | nonzero value is accepted to mean ``true.'' (Specifically, anything | |
25570 | for which @code{dnonzero} returns 1 is ``true,'' and anything for | |
25571 | which @code{dnonzero} returns 0 or cannot decide is assumed ``false.'' | |
25572 | Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then'' | |
25573 | portion if its condition is provably true, but it will execute the | |
a4231b04 | 25574 | ``else'' portion for any condition like @expr{a = b} that is not |
d7b8e6c6 EZ |
25575 | provably true, even if it might be true. Algebraic functions that |
25576 | have conditions as arguments, like @code{? :} and @code{&&}, remain | |
25577 | unevaluated if the condition is neither provably true nor provably | |
25578 | false. @xref{Declarations}.) | |
25579 | ||
25580 | @kindex a = | |
25581 | @pindex calc-equal-to | |
25582 | @tindex eq | |
25583 | @tindex = | |
25584 | @tindex == | |
25585 | The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function | |
25586 | (which can also be written @samp{a = b} or @samp{a == b} in an algebraic | |
a4231b04 | 25587 | formula) is true if @expr{a} and @expr{b} are equal, either because they |
d7b8e6c6 EZ |
25588 | are identical expressions, or because they are numbers which are |
25589 | numerically equal. (Thus the integer 1 is considered equal to the float | |
a4231b04 | 25590 | 1.0.) If the equality of @expr{a} and @expr{b} cannot be determined, |
d7b8e6c6 EZ |
25591 | the comparison is left in symbolic form. Note that as a command, this |
25592 | operation pops two values from the stack and pushes back either a 1 or | |
25593 | a 0, or a formula @samp{a = b} if the values' equality cannot be determined. | |
25594 | ||
25595 | Many Calc commands use @samp{=} formulas to represent @dfn{equations}. | |
25596 | For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges | |
25597 | an equation to solve for a given variable. The @kbd{a M} | |
25598 | (@code{calc-map-equation}) command can be used to apply any | |
25599 | function to both sides of an equation; for example, @kbd{2 a M *} | |
25600 | multiplies both sides of the equation by two. Note that just | |
25601 | @kbd{2 *} would not do the same thing; it would produce the formula | |
25602 | @samp{2 (a = b)} which represents 2 if the equality is true or | |
25603 | zero if not. | |
25604 | ||
25605 | The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =} | |
25606 | or @samp{a = b = c}) tests if all of its arguments are equal. In | |
25607 | algebraic notation, the @samp{=} operator is unusual in that it is | |
25608 | neither left- nor right-associative: @samp{a = b = c} is not the | |
25609 | same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare | |
25610 | one variable with the 1 or 0 that results from comparing two other | |
25611 | variables). | |
25612 | ||
25613 | @kindex a # | |
25614 | @pindex calc-not-equal-to | |
25615 | @tindex neq | |
25616 | @tindex != | |
25617 | The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or | |
a4231b04 | 25618 | @samp{a != b} function, is true if @expr{a} and @expr{b} are not equal. |
d7b8e6c6 | 25619 | This also works with more than two arguments; @samp{a != b != c != d} |
a4231b04 | 25620 | tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are |
d7b8e6c6 EZ |
25621 | distinct numbers. |
25622 | ||
25623 | @kindex a < | |
25624 | @tindex lt | |
5d67986c RS |
25625 | @ignore |
25626 | @mindex @idots | |
25627 | @end ignore | |
d7b8e6c6 | 25628 | @kindex a > |
5d67986c RS |
25629 | @ignore |
25630 | @mindex @null | |
25631 | @end ignore | |
d7b8e6c6 | 25632 | @kindex a [ |
5d67986c RS |
25633 | @ignore |
25634 | @mindex @null | |
25635 | @end ignore | |
d7b8e6c6 EZ |
25636 | @kindex a ] |
25637 | @pindex calc-less-than | |
25638 | @pindex calc-greater-than | |
25639 | @pindex calc-less-equal | |
25640 | @pindex calc-greater-equal | |
5d67986c RS |
25641 | @ignore |
25642 | @mindex @null | |
25643 | @end ignore | |
d7b8e6c6 | 25644 | @tindex gt |
5d67986c RS |
25645 | @ignore |
25646 | @mindex @null | |
25647 | @end ignore | |
d7b8e6c6 | 25648 | @tindex leq |
5d67986c RS |
25649 | @ignore |
25650 | @mindex @null | |
25651 | @end ignore | |
d7b8e6c6 | 25652 | @tindex geq |
5d67986c RS |
25653 | @ignore |
25654 | @mindex @null | |
25655 | @end ignore | |
d7b8e6c6 | 25656 | @tindex < |
5d67986c RS |
25657 | @ignore |
25658 | @mindex @null | |
25659 | @end ignore | |
d7b8e6c6 | 25660 | @tindex > |
5d67986c RS |
25661 | @ignore |
25662 | @mindex @null | |
25663 | @end ignore | |
d7b8e6c6 | 25664 | @tindex <= |
5d67986c RS |
25665 | @ignore |
25666 | @mindex @null | |
25667 | @end ignore | |
d7b8e6c6 EZ |
25668 | @tindex >= |
25669 | The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}] | |
a4231b04 | 25670 | operation is true if @expr{a} is less than @expr{b}. Similar functions |
d7b8e6c6 EZ |
25671 | are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}], |
25672 | @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and | |
25673 | @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}]. | |
25674 | ||
25675 | While the inequality functions like @code{lt} do not accept more | |
25676 | than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an | |
25677 | equivalent expression involving intervals: @samp{b in [a .. c)}. | |
25678 | (See the description of @code{in} below.) All four combinations | |
25679 | of @samp{<} and @samp{<=} are allowed, or any of the four combinations | |
25680 | of @samp{>} and @samp{>=}. Four-argument constructions like | |
25681 | @samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that | |
25682 | involve both equalities and inequalities, are not allowed. | |
25683 | ||
25684 | @kindex a . | |
25685 | @pindex calc-remove-equal | |
25686 | @tindex rmeq | |
25687 | The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts | |
25688 | the righthand side of the equation or inequality on the top of the | |
25689 | stack. It also works elementwise on vectors. For example, if | |
25690 | @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces | |
25691 | @samp{[2.34, z / 2]}. As a special case, if the righthand side is a | |
25692 | variable and the lefthand side is a number (as in @samp{2.34 = x}), then | |
25693 | Calc keeps the lefthand side instead. Finally, this command works with | |
25694 | assignments @samp{x := 2.34} as well as equations, always taking the | |
12874db7 | 25695 | righthand side, and for @samp{=>} (evaluates-to) operators, always |
d7b8e6c6 EZ |
25696 | taking the lefthand side. |
25697 | ||
25698 | @kindex a & | |
25699 | @pindex calc-logical-and | |
25700 | @tindex land | |
25701 | @tindex && | |
25702 | The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}] | |
25703 | function is true if both of its arguments are true, i.e., are | |
a4231b04 JB |
25704 | non-zero numbers. In this case, the result will be either @expr{a} or |
25705 | @expr{b}, chosen arbitrarily. If either argument is zero, the result is | |
d7b8e6c6 EZ |
25706 | zero. Otherwise, the formula is left in symbolic form. |
25707 | ||
25708 | @kindex a | | |
25709 | @pindex calc-logical-or | |
25710 | @tindex lor | |
25711 | @tindex || | |
25712 | The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}] | |
25713 | function is true if either or both of its arguments are true (nonzero). | |
25714 | The result is whichever argument was nonzero, choosing arbitrarily if both | |
a4231b04 | 25715 | are nonzero. If both @expr{a} and @expr{b} are zero, the result is |
d7b8e6c6 EZ |
25716 | zero. |
25717 | ||
25718 | @kindex a ! | |
25719 | @pindex calc-logical-not | |
25720 | @tindex lnot | |
25721 | @tindex ! | |
25722 | The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}] | |
a4231b04 JB |
25723 | function is true if @expr{a} is false (zero), or false if @expr{a} is |
25724 | true (nonzero). It is left in symbolic form if @expr{a} is not a | |
d7b8e6c6 EZ |
25725 | number. |
25726 | ||
25727 | @kindex a : | |
25728 | @pindex calc-logical-if | |
25729 | @tindex if | |
5d67986c RS |
25730 | @ignore |
25731 | @mindex ? : | |
25732 | @end ignore | |
d7b8e6c6 | 25733 | @tindex ? |
5d67986c RS |
25734 | @ignore |
25735 | @mindex @null | |
25736 | @end ignore | |
d7b8e6c6 EZ |
25737 | @tindex : |
25738 | @cindex Arguments, not evaluated | |
25739 | The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}] | |
a4231b04 JB |
25740 | function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero |
25741 | number or zero, respectively. If @expr{a} is not a number, the test is | |
25742 | left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in | |
d7b8e6c6 EZ |
25743 | any way. In algebraic formulas, this is one of the few Calc functions |
25744 | whose arguments are not automatically evaluated when the function itself | |
25745 | is evaluated. The others are @code{lambda}, @code{quote}, and | |
25746 | @code{condition}. | |
25747 | ||
25748 | One minor surprise to watch out for is that the formula @samp{a?3:4} | |
25749 | will not work because the @samp{3:4} is parsed as a fraction instead of | |
25750 | as three separate symbols. Type something like @samp{a ? 3 : 4} or | |
25751 | @samp{a?(3):4} instead. | |
25752 | ||
a4231b04 JB |
25753 | As a special case, if @expr{a} evaluates to a vector, then both @expr{b} |
25754 | and @expr{c} are evaluated; the result is a vector of the same length | |
25755 | as @expr{a} whose elements are chosen from corresponding elements of | |
25756 | @expr{b} and @expr{c} according to whether each element of @expr{a} | |
25757 | is zero or nonzero. Each of @expr{b} and @expr{c} must be either a | |
25758 | vector of the same length as @expr{a}, or a non-vector which is matched | |
25759 | with all elements of @expr{a}. | |
d7b8e6c6 EZ |
25760 | |
25761 | @kindex a @{ | |
25762 | @pindex calc-in-set | |
25763 | @tindex in | |
25764 | The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if | |
a4231b04 JB |
25765 | the number @expr{a} is in the set of numbers represented by @expr{b}. |
25766 | If @expr{b} is an interval form, @expr{a} must be one of the values | |
25767 | encompassed by the interval. If @expr{b} is a vector, @expr{a} must be | |
d7b8e6c6 | 25768 | equal to one of the elements of the vector. (If any vector elements are |
a4231b04 JB |
25769 | intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a |
25770 | plain number, @expr{a} must be numerically equal to @expr{b}. | |
d7b8e6c6 EZ |
25771 | @xref{Set Operations}, for a group of commands that manipulate sets |
25772 | of this sort. | |
25773 | ||
5d67986c RS |
25774 | @ignore |
25775 | @starindex | |
25776 | @end ignore | |
d7b8e6c6 EZ |
25777 | @tindex typeof |
25778 | The @samp{typeof(a)} function produces an integer or variable which | |
a4231b04 | 25779 | characterizes @expr{a}. If @expr{a} is a number, vector, or variable, |
d7b8e6c6 EZ |
25780 | the result will be one of the following numbers: |
25781 | ||
25782 | @example | |
25783 | 1 Integer | |
25784 | 2 Fraction | |
25785 | 3 Floating-point number | |
25786 | 4 HMS form | |
25787 | 5 Rectangular complex number | |
25788 | 6 Polar complex number | |
25789 | 7 Error form | |
25790 | 8 Interval form | |
25791 | 9 Modulo form | |
25792 | 10 Date-only form | |
25793 | 11 Date/time form | |
25794 | 12 Infinity (inf, uinf, or nan) | |
25795 | 100 Variable | |
25796 | 101 Vector (but not a matrix) | |
25797 | 102 Matrix | |
25798 | @end example | |
25799 | ||
a4231b04 | 25800 | Otherwise, @expr{a} is a formula, and the result is a variable which |
d7b8e6c6 EZ |
25801 | represents the name of the top-level function call. |
25802 | ||
5d67986c RS |
25803 | @ignore |
25804 | @starindex | |
25805 | @end ignore | |
d7b8e6c6 | 25806 | @tindex integer |
5d67986c RS |
25807 | @ignore |
25808 | @starindex | |
25809 | @end ignore | |
d7b8e6c6 | 25810 | @tindex real |
5d67986c RS |
25811 | @ignore |
25812 | @starindex | |
25813 | @end ignore | |
d7b8e6c6 | 25814 | @tindex constant |
a4231b04 | 25815 | The @samp{integer(a)} function returns true if @expr{a} is an integer. |
d7b8e6c6 | 25816 | The @samp{real(a)} function |
a4231b04 JB |
25817 | is true if @expr{a} is a real number, either integer, fraction, or |
25818 | float. The @samp{constant(a)} function returns true if @expr{a} is | |
d7b8e6c6 EZ |
25819 | any of the objects for which @code{typeof} would produce an integer |
25820 | code result except for variables, and provided that the components of | |
25821 | an object like a vector or error form are themselves constant. | |
25822 | Note that infinities do not satisfy any of these tests, nor do | |
a4231b04 | 25823 | special constants like @code{pi} and @code{e}. |
d7b8e6c6 EZ |
25824 | |
25825 | @xref{Declarations}, for a set of similar functions that recognize | |
25826 | formulas as well as actual numbers. For example, @samp{dint(floor(x))} | |
25827 | is true because @samp{floor(x)} is provably integer-valued, but | |
25828 | @samp{integer(floor(x))} does not because @samp{floor(x)} is not | |
25829 | literally an integer constant. | |
25830 | ||
5d67986c RS |
25831 | @ignore |
25832 | @starindex | |
25833 | @end ignore | |
d7b8e6c6 EZ |
25834 | @tindex refers |
25835 | The @samp{refers(a,b)} function is true if the variable (or sub-expression) | |
a4231b04 | 25836 | @expr{b} appears in @expr{a}, or false otherwise. Unlike the other |
d7b8e6c6 EZ |
25837 | tests described here, this function returns a definite ``no'' answer |
25838 | even if its arguments are still in symbolic form. The only case where | |
a4231b04 JB |
25839 | @code{refers} will be left unevaluated is if @expr{a} is a plain |
25840 | variable (different from @expr{b}). | |
d7b8e6c6 | 25841 | |
5d67986c RS |
25842 | @ignore |
25843 | @starindex | |
25844 | @end ignore | |
d7b8e6c6 | 25845 | @tindex negative |
a4231b04 JB |
25846 | The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative, |
25847 | because it is a negative number, because it is of the form @expr{-x}, | |
d7b8e6c6 EZ |
25848 | or because it is a product or quotient with a term that looks negative. |
25849 | This is most useful in rewrite rules. Beware that @samp{negative(a)} | |
a4231b04 | 25850 | evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only |
d7b8e6c6 EZ |
25851 | be stored in a formula if the default simplifications are turned off |
25852 | first with @kbd{m O} (or if it appears in an unevaluated context such | |
25853 | as a rewrite rule condition). | |
25854 | ||
5d67986c RS |
25855 | @ignore |
25856 | @starindex | |
25857 | @end ignore | |
d7b8e6c6 | 25858 | @tindex variable |
a4231b04 JB |
25859 | The @samp{variable(a)} function is true if @expr{a} is a variable, |
25860 | or false if not. If @expr{a} is a function call, this test is left | |
d7b8e6c6 EZ |
25861 | in symbolic form. Built-in variables like @code{pi} and @code{inf} |
25862 | are considered variables like any others by this test. | |
25863 | ||
5d67986c RS |
25864 | @ignore |
25865 | @starindex | |
25866 | @end ignore | |
d7b8e6c6 | 25867 | @tindex nonvar |
a4231b04 | 25868 | The @samp{nonvar(a)} function is true if @expr{a} is a non-variable. |
d7b8e6c6 EZ |
25869 | If its argument is a variable it is left unsimplified; it never |
25870 | actually returns zero. However, since Calc's condition-testing | |
25871 | commands consider ``false'' anything not provably true, this is | |
25872 | often good enough. | |
25873 | ||
5d67986c RS |
25874 | @ignore |
25875 | @starindex | |
25876 | @end ignore | |
d7b8e6c6 | 25877 | @tindex lin |
5d67986c RS |
25878 | @ignore |
25879 | @starindex | |
25880 | @end ignore | |
d7b8e6c6 | 25881 | @tindex linnt |
5d67986c RS |
25882 | @ignore |
25883 | @starindex | |
25884 | @end ignore | |
d7b8e6c6 | 25885 | @tindex islin |
5d67986c RS |
25886 | @ignore |
25887 | @starindex | |
25888 | @end ignore | |
d7b8e6c6 EZ |
25889 | @tindex islinnt |
25890 | @cindex Linearity testing | |
25891 | The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt} | |
25892 | check if an expression is ``linear,'' i.e., can be written in the form | |
a4231b04 JB |
25893 | @expr{a + b x} for some constants @expr{a} and @expr{b}, and some |
25894 | variable or subformula @expr{x}. The function @samp{islin(f,x)} checks | |
25895 | if formula @expr{f} is linear in @expr{x}, returning 1 if so. For | |
d7b8e6c6 EZ |
25896 | example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and |
25897 | @samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function | |
25898 | is similar, except that instead of returning 1 it returns the vector | |
a4231b04 JB |
25899 | @expr{[a, b, x]}. For the above examples, this vector would be |
25900 | @expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and | |
25901 | @expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin} | |
d7b8e6c6 EZ |
25902 | generally remain unevaluated for expressions which are not linear, |
25903 | e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second | |
25904 | argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))} | |
25905 | returns true. | |
25906 | ||
25907 | The @code{linnt} and @code{islinnt} functions perform a similar check, | |
25908 | but require a ``non-trivial'' linear form, which means that the | |
a4231b04 JB |
25909 | @expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)} |
25910 | returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]}, | |
d7b8e6c6 EZ |
25911 | but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated |
25912 | (in other words, these formulas are considered to be only ``trivially'' | |
a4231b04 | 25913 | linear in @expr{x}). |
d7b8e6c6 EZ |
25914 | |
25915 | All four linearity-testing functions allow you to omit the second | |
25916 | argument, in which case the input may be linear in any non-constant | |
a4231b04 JB |
25917 | formula. Here, the @expr{a=0}, @expr{b=1} case is also considered |
25918 | trivial, and only constant values for @expr{a} and @expr{b} are | |
25919 | recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]}, | |
25920 | @samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)} | |
25921 | returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the | |
d7b8e6c6 EZ |
25922 | first two cases but not the third. Also, neither @code{lin} nor |
25923 | @code{linnt} accept plain constants as linear in the one-argument | |
25924 | case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false. | |
25925 | ||
5d67986c RS |
25926 | @ignore |
25927 | @starindex | |
25928 | @end ignore | |
d7b8e6c6 | 25929 | @tindex istrue |
a4231b04 JB |
25930 | The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero |
25931 | number or provably nonzero formula, or 0 if @expr{a} is anything else. | |
d7b8e6c6 EZ |
25932 | Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is |
25933 | used to make sure they are not evaluated prematurely. (Note that | |
25934 | declarations are used when deciding whether a formula is true; | |
25935 | @code{istrue} returns 1 when @code{dnonzero} would return 1, and | |
25936 | it returns 0 when @code{dnonzero} would return 0 or leave itself | |
25937 | in symbolic form.) | |
25938 | ||
25939 | @node Rewrite Rules, , Logical Operations, Algebra | |
25940 | @section Rewrite Rules | |
25941 | ||
25942 | @noindent | |
25943 | @cindex Rewrite rules | |
25944 | @cindex Transformations | |
25945 | @cindex Pattern matching | |
25946 | @kindex a r | |
25947 | @pindex calc-rewrite | |
25948 | @tindex rewrite | |
25949 | The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes | |
25950 | substitutions in a formula according to a specified pattern or patterns | |
25951 | known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute}) | |
25952 | matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)} | |
25953 | matches only the @code{sin} function applied to the variable @code{x}, | |
25954 | rewrite rules match general kinds of formulas; rewriting using the rule | |
25955 | @samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces | |
25956 | it with @code{cos} of that same argument. The only significance of the | |
25957 | name @code{x} is that the same name is used on both sides of the rule. | |
25958 | ||
25959 | Rewrite rules rearrange formulas already in Calc's memory. | |
25960 | @xref{Syntax Tables}, to read about @dfn{syntax rules}, which are | |
25961 | similar to algebraic rewrite rules but operate when new algebraic | |
25962 | entries are being parsed, converting strings of characters into | |
25963 | Calc formulas. | |
25964 | ||
25965 | @menu | |
25966 | * Entering Rewrite Rules:: | |
25967 | * Basic Rewrite Rules:: | |
25968 | * Conditional Rewrite Rules:: | |
25969 | * Algebraic Properties of Rewrite Rules:: | |
25970 | * Other Features of Rewrite Rules:: | |
25971 | * Composing Patterns in Rewrite Rules:: | |
25972 | * Nested Formulas with Rewrite Rules:: | |
25973 | * Multi-Phase Rewrite Rules:: | |
25974 | * Selections with Rewrite Rules:: | |
25975 | * Matching Commands:: | |
25976 | * Automatic Rewrites:: | |
25977 | * Debugging Rewrites:: | |
25978 | * Examples of Rewrite Rules:: | |
25979 | @end menu | |
25980 | ||
25981 | @node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules | |
25982 | @subsection Entering Rewrite Rules | |
25983 | ||
25984 | @noindent | |
25985 | Rewrite rules normally use the ``assignment'' operator | |
25986 | @samp{@var{old} := @var{new}}. | |
25987 | This operator is equivalent to the function call @samp{assign(old, new)}. | |
25988 | The @code{assign} function is undefined by itself in Calc, so an | |
25989 | assignment formula such as a rewrite rule will be left alone by ordinary | |
25990 | Calc commands. But certain commands, like the rewrite system, interpret | |
a4231b04 | 25991 | assignments in special ways. |
d7b8e6c6 EZ |
25992 | |
25993 | For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace | |
25994 | every occurrence of the sine of something, squared, with one minus the | |
25995 | square of the cosine of that same thing. All by itself as a formula | |
25996 | on the stack it does nothing, but when given to the @kbd{a r} command | |
25997 | it turns that command into a sine-squared-to-cosine-squared converter. | |
25998 | ||
25999 | To specify a set of rules to be applied all at once, make a vector of | |
26000 | rules. | |
26001 | ||
26002 | When @kbd{a r} prompts you to enter the rewrite rules, you can answer | |
26003 | in several ways: | |
26004 | ||
26005 | @enumerate | |
26006 | @item | |
5d67986c | 26007 | With a rule: @kbd{f(x) := g(x) @key{RET}}. |
d7b8e6c6 | 26008 | @item |
5d67986c | 26009 | With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}. |
d7b8e6c6 EZ |
26010 | (You can omit the enclosing square brackets if you wish.) |
26011 | @item | |
26012 | With the name of a variable that contains the rule or rules vector: | |
5d67986c | 26013 | @kbd{myrules @key{RET}}. |
d7b8e6c6 EZ |
26014 | @item |
26015 | With any formula except a rule, a vector, or a variable name; this | |
26016 | will be interpreted as the @var{old} half of a rewrite rule, | |
26017 | and you will be prompted a second time for the @var{new} half: | |
26018 | @kbd{f(x) @key{RET} g(x) @key{RET}}. | |
26019 | @item | |
26020 | With a blank line, in which case the rule, rules vector, or variable | |
26021 | will be taken from the top of the stack (and the formula to be | |
26022 | rewritten will come from the second-to-top position). | |
26023 | @end enumerate | |
26024 | ||
26025 | If you enter the rules directly (as opposed to using rules stored | |
26026 | in a variable), those rules will be put into the Trail so that you | |
26027 | can retrieve them later. @xref{Trail Commands}. | |
26028 | ||
26029 | It is most convenient to store rules you use often in a variable and | |
26030 | invoke them by giving the variable name. The @kbd{s e} | |
26031 | (@code{calc-edit-variable}) command is an easy way to create or edit a | |
26032 | rule set stored in a variable. You may also wish to use @kbd{s p} | |
26033 | (@code{calc-permanent-variable}) to save your rules permanently; | |
a4231b04 | 26034 | @pxref{Operations on Variables}. |
d7b8e6c6 EZ |
26035 | |
26036 | Rewrite rules are compiled into a special internal form for faster | |
26037 | matching. If you enter a rule set directly it must be recompiled | |
26038 | every time. If you store the rules in a variable and refer to them | |
26039 | through that variable, they will be compiled once and saved away | |
26040 | along with the variable for later reference. This is another good | |
26041 | reason to store your rules in a variable. | |
26042 | ||
26043 | Calc also accepts an obsolete notation for rules, as vectors | |
26044 | @samp{[@var{old}, @var{new}]}. But because it is easily confused with a | |
26045 | vector of two rules, the use of this notation is no longer recommended. | |
26046 | ||
26047 | @node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules | |
26048 | @subsection Basic Rewrite Rules | |
26049 | ||
26050 | @noindent | |
a4231b04 JB |
26051 | To match a particular formula @expr{x} with a particular rewrite rule |
26052 | @samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with | |
d7b8e6c6 | 26053 | the structure of @var{old}. Variables that appear in @var{old} are |
a4231b04 | 26054 | treated as @dfn{meta-variables}; the corresponding positions in @expr{x} |
d7b8e6c6 EZ |
26055 | may contain any sub-formulas. For example, the pattern @samp{f(x,y)} |
26056 | would match the expression @samp{f(12, a+1)} with the meta-variable | |
26057 | @samp{x} corresponding to 12 and with @samp{y} corresponding to | |
26058 | @samp{a+1}. However, this pattern would not match @samp{f(12)} or | |
26059 | @samp{g(12, a+1)}, since there is no assignment of the meta-variables | |
26060 | that will make the pattern match these expressions. Notice that if | |
26061 | the pattern is a single meta-variable, it will match any expression. | |
26062 | ||
26063 | If a given meta-variable appears more than once in @var{old}, the | |
a4231b04 | 26064 | corresponding sub-formulas of @expr{x} must be identical. Thus |
d7b8e6c6 EZ |
26065 | the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and |
26066 | @samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}. | |
26067 | (@xref{Conditional Rewrite Rules}, for a way to match the latter.) | |
26068 | ||
26069 | Things other than variables must match exactly between the pattern | |
26070 | and the target formula. To match a particular variable exactly, use | |
26071 | the pseudo-function @samp{quote(v)} in the pattern. For example, the | |
26072 | pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or | |
26073 | @samp{sin(a)+y}. | |
26074 | ||
26075 | The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi}, | |
26076 | @samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match | |
26077 | literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like | |
26078 | @samp{sin(d + quote(e) + f)}. | |
26079 | ||
26080 | If the @var{old} pattern is found to match a given formula, that | |
26081 | formula is replaced by @var{new}, where any occurrences in @var{new} | |
26082 | of meta-variables from the pattern are replaced with the sub-formulas | |
26083 | that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)} | |
26084 | to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}. | |
26085 | ||
26086 | The normal @kbd{a r} command applies rewrite rules over and over | |
26087 | throughout the target formula until no further changes are possible | |
26088 | (up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one | |
26089 | change at a time. | |
26090 | ||
26091 | @node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules | |
26092 | @subsection Conditional Rewrite Rules | |
26093 | ||
26094 | @noindent | |
26095 | A rewrite rule can also be @dfn{conditional}, written in the form | |
26096 | @samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete | |
26097 | form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part | |
26098 | is present in the | |
26099 | rule, this is an additional condition that must be satisfied before | |
26100 | the rule is accepted. Once @var{old} has been successfully matched | |
26101 | to the target expression, @var{cond} is evaluated (with all the | |
26102 | meta-variables substituted for the values they matched) and simplified | |
26103 | with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero | |
26104 | number or any other object known to be nonzero (@pxref{Declarations}), | |
26105 | the rule is accepted. If the result is zero or if it is a symbolic | |
26106 | formula that is not known to be nonzero, the rule is rejected. | |
26107 | @xref{Logical Operations}, for a number of functions that return | |
a4231b04 | 26108 | 1 or 0 according to the results of various tests. |
d7b8e6c6 | 26109 | |
a4231b04 | 26110 | For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n} |
d7b8e6c6 | 26111 | is replaced by a positive or nonpositive number, respectively (or if |
a4231b04 | 26112 | @expr{n} has been declared to be positive or nonpositive). Thus, |
d7b8e6c6 EZ |
26113 | the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to |
26114 | @samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)} | |
a4231b04 | 26115 | (assuming no outstanding declarations for @expr{a}). In the case of |
d7b8e6c6 EZ |
26116 | @samp{f(-3, 2)}, the condition can be shown not to be satisfied; in |
26117 | the case of @samp{f(12, a+1)}, the condition merely cannot be shown | |
26118 | to be satisfied, but that is enough to reject the rule. | |
26119 | ||
26120 | While Calc will use declarations to reason about variables in the | |
26121 | formula being rewritten, declarations do not apply to meta-variables. | |
26122 | For example, the rule @samp{f(a) := g(a+1)} will match for any values | |
26123 | of @samp{a}, such as complex numbers, vectors, or formulas, even if | |
26124 | @samp{a} has been declared to be real or scalar. If you want the | |
26125 | meta-variable @samp{a} to match only literal real numbers, use | |
26126 | @samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only | |
26127 | reals and formulas which are provably real, use @samp{dreal(a)} as | |
26128 | the condition. | |
26129 | ||
26130 | The @samp{::} operator is a shorthand for the @code{condition} | |
26131 | function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to | |
26132 | the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}. | |
26133 | ||
26134 | If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3} | |
26135 | or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent. | |
26136 | ||
26137 | It is also possible to embed conditions inside the pattern: | |
26138 | @samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational | |
26139 | convenience, though; where a condition appears in a rule has no | |
26140 | effect on when it is tested. The rewrite-rule compiler automatically | |
26141 | decides when it is best to test each condition while a rule is being | |
26142 | matched. | |
26143 | ||
26144 | Certain conditions are handled as special cases by the rewrite rule | |
a4231b04 | 26145 | system and are tested very efficiently: Where @expr{x} is any |
d7b8e6c6 | 26146 | meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)}, |
a4231b04 | 26147 | @samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y} |
d7b8e6c6 EZ |
26148 | is either a constant or another meta-variable and @samp{>=} may be |
26149 | replaced by any of the six relational operators, and @samp{x % a = b} | |
a4231b04 | 26150 | where @expr{a} and @expr{b} are constants. Other conditions, like |
d7b8e6c6 EZ |
26151 | @samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check |
26152 | since Calc must bring the whole evaluator and simplifier into play. | |
26153 | ||
26154 | An interesting property of @samp{::} is that neither of its arguments | |
26155 | will be touched by Calc's default simplifications. This is important | |
26156 | because conditions often are expressions that cannot safely be | |
26157 | evaluated early. For example, the @code{typeof} function never | |
26158 | remains in symbolic form; entering @samp{typeof(a)} will put the | |
26159 | number 100 (the type code for variables like @samp{a}) on the stack. | |
26160 | But putting the condition @samp{... :: typeof(a) = 6} on the stack | |
26161 | is safe since @samp{::} prevents the @code{typeof} from being | |
26162 | evaluated until the condition is actually used by the rewrite system. | |
26163 | ||
26164 | Since @samp{::} protects its lefthand side, too, you can use a dummy | |
26165 | condition to protect a rule that must itself not evaluate early. | |
26166 | For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on | |
26167 | the stack because it will immediately evaluate to @samp{a(f,x) := f(x)}, | |
26168 | where the meta-variable-ness of @code{f} on the righthand side has been | |
26169 | lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course | |
26170 | the condition @samp{1} is always true (nonzero) so it has no effect on | |
26171 | the functioning of the rule. (The rewrite compiler will ensure that | |
26172 | it doesn't even impact the speed of matching the rule.) | |
26173 | ||
26174 | @node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules | |
26175 | @subsection Algebraic Properties of Rewrite Rules | |
26176 | ||
26177 | @noindent | |
26178 | The rewrite mechanism understands the algebraic properties of functions | |
26179 | like @samp{+} and @samp{*}. In particular, pattern matching takes | |
26180 | the associativity and commutativity of the following functions into | |
26181 | account: | |
26182 | ||
26183 | @smallexample | |
26184 | + - * = != && || and or xor vint vunion vxor gcd lcm max min beta | |
26185 | @end smallexample | |
26186 | ||
26187 | For example, the rewrite rule: | |
26188 | ||
26189 | @example | |
26190 | a x + b x := (a + b) x | |
26191 | @end example | |
26192 | ||
26193 | @noindent | |
26194 | will match formulas of the form, | |
26195 | ||
26196 | @example | |
26197 | a x + b x, x a + x b, a x + x b, x a + b x | |
26198 | @end example | |
26199 | ||
26200 | Rewrites also understand the relationship between the @samp{+} and @samp{-} | |
26201 | operators. The above rewrite rule will also match the formulas, | |
26202 | ||
26203 | @example | |
26204 | a x - b x, x a - x b, a x - x b, x a - b x | |
26205 | @end example | |
26206 | ||
26207 | @noindent | |
26208 | by matching @samp{b} in the pattern to @samp{-b} from the formula. | |
26209 | ||
26210 | Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this | |
26211 | pattern will check all pairs of terms for possible matches. The rewrite | |
26212 | will take whichever suitable pair it discovers first. | |
26213 | ||
26214 | In general, a pattern using an associative operator like @samp{a + b} | |
5d67986c | 26215 | will try @var{2 n} different ways to match a sum of @var{n} terms |
d7b8e6c6 EZ |
26216 | like @samp{x + y + z - w}. First, @samp{a} is matched against each |
26217 | of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b} | |
26218 | being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc. | |
26219 | If none of these succeed, then @samp{b} is matched against each of the | |
26220 | four terms with @samp{a} matching the remainder. Half-and-half matches, | |
26221 | like @samp{(x + y) + (z - w)}, are not tried. | |
26222 | ||
26223 | Note that @samp{*} is not commutative when applied to matrices, but | |
26224 | rewrite rules pretend that it is. If you type @kbd{m v} to enable | |
07ce2eb3 | 26225 | Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*} |
d7b8e6c6 EZ |
26226 | literally, ignoring its usual commutativity property. (In the |
26227 | current implementation, the associativity also vanishes---it is as | |
26228 | if the pattern had been enclosed in a @code{plain} marker; see below.) | |
26229 | If you are applying rewrites to formulas with matrices, it's best to | |
07ce2eb3 | 26230 | enable Matrix mode first to prevent algebraically incorrect rewrites |
d7b8e6c6 EZ |
26231 | from occurring. |
26232 | ||
26233 | The pattern @samp{-x} will actually match any expression. For example, | |
26234 | the rule | |
26235 | ||
26236 | @example | |
26237 | f(-x) := -f(x) | |
26238 | @end example | |
26239 | ||
26240 | @noindent | |
26241 | will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use | |
26242 | a @code{plain} marker as described below, or add a @samp{negative(x)} | |
26243 | condition. The @code{negative} function is true if its argument | |
26244 | ``looks'' negative, for example, because it is a negative number or | |
26245 | because it is a formula like @samp{-x}. The new rule using this | |
26246 | condition is: | |
26247 | ||
26248 | @example | |
26249 | f(x) := -f(-x) :: negative(x) @r{or, equivalently,} | |
26250 | f(-x) := -f(x) :: negative(-x) | |
26251 | @end example | |
26252 | ||
26253 | In the same way, the pattern @samp{x - y} will match the sum @samp{a + b} | |
26254 | by matching @samp{y} to @samp{-b}. | |
26255 | ||
26256 | The pattern @samp{a b} will also match the formula @samp{x/y} if | |
26257 | @samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x} | |
26258 | will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or | |
26259 | @samp{(a + 1:2) x}, depending on the current fraction mode). | |
26260 | ||
26261 | Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and | |
26262 | @samp{^}. For example, the pattern @samp{f(a b)} will not match | |
26263 | @samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even | |
26264 | though conceivably these patterns could match with @samp{a = b = x}. | |
26265 | Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a | |
26266 | constant, even though it could be considered to match with @samp{a = x} | |
26267 | and @samp{b = 1/y}. The reasons are partly for efficiency, and partly | |
26268 | because while few mathematical operations are substantively different | |
26269 | for addition and subtraction, often it is preferable to treat the cases | |
26270 | of multiplication, division, and integer powers separately. | |
26271 | ||
26272 | Even more subtle is the rule set | |
26273 | ||
26274 | @example | |
26275 | [ f(a) + f(b) := f(a + b), -f(a) := f(-a) ] | |
26276 | @end example | |
26277 | ||
26278 | @noindent | |
26279 | attempting to match @samp{f(x) - f(y)}. You might think that Calc | |
26280 | will view this subtraction as @samp{f(x) + (-f(y))} and then apply | |
26281 | the above two rules in turn, but actually this will not work because | |
26282 | Calc only does this when considering rules for @samp{+} (like the | |
26283 | first rule in this set). So it will see first that @samp{f(x) + (-f(y))} | |
26284 | does not match @samp{f(a) + f(b)} for any assignments of the | |
26285 | meta-variables, and then it will see that @samp{f(x) - f(y)} does | |
26286 | not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc | |
26287 | tries only one rule at a time, it will not be able to rewrite | |
26288 | @samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)} | |
26289 | rule will have to be added. | |
26290 | ||
26291 | Another thing patterns will @emph{not} do is break up complex numbers. | |
26292 | The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas | |
26293 | involving the special constant @samp{i} (such as @samp{3 - 4 i}), but | |
26294 | it will not match actual complex numbers like @samp{(3, -4)}. A version | |
26295 | of the above rule for complex numbers would be | |
26296 | ||
26297 | @example | |
26298 | myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0 | |
26299 | @end example | |
26300 | ||
26301 | @noindent | |
26302 | (Because the @code{re} and @code{im} functions understand the properties | |
26303 | of the special constant @samp{i}, this rule will also work for | |
26304 | @samp{3 - 4 i}. In fact, this particular rule would probably be better | |
26305 | without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the | |
26306 | righthand side of the rule will still give the correct answer for the | |
26307 | conjugate of a real number.) | |
26308 | ||
26309 | It is also possible to specify optional arguments in patterns. The rule | |
26310 | ||
26311 | @example | |
26312 | opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d) | |
26313 | @end example | |
26314 | ||
26315 | @noindent | |
26316 | will match the formula | |
26317 | ||
26318 | @example | |
26319 | 5 (x^2 - 4) + 3 x | |
26320 | @end example | |
26321 | ||
26322 | @noindent | |
26323 | in a fairly straightforward manner, but it will also match reduced | |
26324 | formulas like | |
26325 | ||
26326 | @example | |
26327 | x + x^2, 2(x + 1) - x, x + x | |
26328 | @end example | |
26329 | ||
26330 | @noindent | |
26331 | producing, respectively, | |
26332 | ||
26333 | @example | |
26334 | f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0) | |
26335 | @end example | |
26336 | ||
26337 | (The latter two formulas can be entered only if default simplifications | |
26338 | have been turned off with @kbd{m O}.) | |
26339 | ||
26340 | The default value for a term of a sum is zero. The default value | |
26341 | for a part of a product, for a power, or for the denominator of a | |
26342 | quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b} | |
26343 | with @samp{a = -1}. | |
26344 | ||
26345 | In particular, the distributive-law rule can be refined to | |
26346 | ||
26347 | @example | |
26348 | opt(a) x + opt(b) x := (a + b) x | |
26349 | @end example | |
26350 | ||
26351 | @noindent | |
26352 | so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}. | |
26353 | ||
26354 | The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which | |
26355 | are linear in @samp{x}. You can also use the @code{lin} and @code{islin} | |
26356 | functions with rewrite conditions to test for this; @pxref{Logical | |
26357 | Operations}. These functions are not as convenient to use in rewrite | |
26358 | rules, but they recognize more kinds of formulas as linear: | |
a4231b04 | 26359 | @samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin}, |
d7b8e6c6 EZ |
26360 | but it will not match the above pattern because that pattern calls |
26361 | for a multiplication, not a division. | |
26362 | ||
26363 | As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2} | |
26364 | by 1, | |
26365 | ||
26366 | @example | |
26367 | sin(x)^2 + cos(x)^2 := 1 | |
26368 | @end example | |
26369 | ||
26370 | @noindent | |
26371 | misses many cases because the sine and cosine may both be multiplied by | |
26372 | an equal factor. Here's a more successful rule: | |
26373 | ||
26374 | @example | |
26375 | opt(a) sin(x)^2 + opt(a) cos(x)^2 := a | |
26376 | @end example | |
26377 | ||
26378 | Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2} | |
a4231b04 | 26379 | because one @expr{a} would have ``matched'' 1 while the other matched 6. |
d7b8e6c6 EZ |
26380 | |
26381 | Calc automatically converts a rule like | |
26382 | ||
26383 | @example | |
26384 | f(x-1, x) := g(x) | |
26385 | @end example | |
26386 | ||
26387 | @noindent | |
26388 | into the form | |
26389 | ||
26390 | @example | |
26391 | f(temp, x) := g(x) :: temp = x-1 | |
26392 | @end example | |
26393 | ||
26394 | @noindent | |
26395 | (where @code{temp} stands for a new, invented meta-variable that | |
26396 | doesn't actually have a name). This modified rule will successfully | |
26397 | match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7, | |
26398 | respectively, then verifying that they differ by one even though | |
26399 | @samp{6} does not superficially look like @samp{x-1}. | |
26400 | ||
26401 | However, Calc does not solve equations to interpret a rule. The | |
26402 | following rule, | |
26403 | ||
26404 | @example | |
26405 | f(x-1, x+1) := g(x) | |
26406 | @end example | |
26407 | ||
26408 | @noindent | |
26409 | will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)} | |
26410 | but not @samp{f(6, 8)}. Calc always interprets at least one occurrence | |
26411 | of a variable by literal matching. If the variable appears ``isolated'' | |
26412 | then Calc is smart enough to use it for literal matching. But in this | |
26413 | last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp) | |
26414 | := g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an | |
26415 | actual ``something-minus-one'' in the target formula. | |
26416 | ||
26417 | A successful way to write this would be @samp{f(x, x+2) := g(x+1)}. | |
26418 | You could make this resemble the original form more closely by using | |
26419 | @code{let} notation, which is described in the next section: | |
26420 | ||
26421 | @example | |
26422 | f(xm1, x+1) := g(x) :: let(x := xm1+1) | |
26423 | @end example | |
26424 | ||
26425 | Calc does this rewriting or ``conditionalizing'' for any sub-pattern | |
26426 | which involves only the functions in the following list, operating | |
26427 | only on constants and meta-variables which have already been matched | |
26428 | elsewhere in the pattern. When matching a function call, Calc is | |
26429 | careful to match arguments which are plain variables before arguments | |
26430 | which are calls to any of the functions below, so that a pattern like | |
26431 | @samp{f(x-1, x)} can be conditionalized even though the isolated | |
26432 | @samp{x} comes after the @samp{x-1}. | |
26433 | ||
26434 | @smallexample | |
26435 | + - * / \ % ^ abs sign round rounde roundu trunc floor ceil | |
26436 | max min re im conj arg | |
26437 | @end smallexample | |
26438 | ||
26439 | You can suppress all of the special treatments described in this | |
26440 | section by surrounding a function call with a @code{plain} marker. | |
26441 | This marker causes the function call which is its argument to be | |
26442 | matched literally, without regard to commutativity, associativity, | |
26443 | negation, or conditionalization. When you use @code{plain}, the | |
26444 | ``deep structure'' of the formula being matched can show through. | |
26445 | For example, | |
26446 | ||
26447 | @example | |
26448 | plain(a - a b) := f(a, b) | |
26449 | @end example | |
26450 | ||
26451 | @noindent | |
26452 | will match only literal subtractions. However, the @code{plain} | |
26453 | marker does not affect its arguments' arguments. In this case, | |
26454 | commutativity and associativity is still considered while matching | |
26455 | the @w{@samp{a b}} sub-pattern, so the whole pattern will match | |
26456 | @samp{x - y x} as well as @samp{x - x y}. We could go still | |
26457 | further and use | |
26458 | ||
26459 | @example | |
26460 | plain(a - plain(a b)) := f(a, b) | |
26461 | @end example | |
26462 | ||
26463 | @noindent | |
26464 | which would do a completely strict match for the pattern. | |
26465 | ||
26466 | By contrast, the @code{quote} marker means that not only the | |
26467 | function name but also the arguments must be literally the same. | |
26468 | The above pattern will match @samp{x - x y} but | |
26469 | ||
26470 | @example | |
26471 | quote(a - a b) := f(a, b) | |
26472 | @end example | |
26473 | ||
26474 | @noindent | |
26475 | will match only the single formula @samp{a - a b}. Also, | |
26476 | ||
26477 | @example | |
26478 | quote(a - quote(a b)) := f(a, b) | |
26479 | @end example | |
26480 | ||
26481 | @noindent | |
26482 | will match only @samp{a - quote(a b)}---probably not the desired | |
26483 | effect! | |
26484 | ||
26485 | A certain amount of algebra is also done when substituting the | |
26486 | meta-variables on the righthand side of a rule. For example, | |
26487 | in the rule | |
26488 | ||
26489 | @example | |
26490 | a + f(b) := f(a + b) | |
26491 | @end example | |
26492 | ||
26493 | @noindent | |
26494 | matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if | |
26495 | taken literally, but the rewrite mechanism will simplify the | |
26496 | righthand side to @samp{f(x - y)} automatically. (Of course, | |
26497 | the default simplifications would do this anyway, so this | |
26498 | special simplification is only noticeable if you have turned the | |
26499 | default simplifications off.) This rewriting is done only when | |
26500 | a meta-variable expands to a ``negative-looking'' expression. | |
26501 | If this simplification is not desirable, you can use a @code{plain} | |
26502 | marker on the righthand side: | |
26503 | ||
26504 | @example | |
26505 | a + f(b) := f(plain(a + b)) | |
26506 | @end example | |
26507 | ||
26508 | @noindent | |
26509 | In this example, we are still allowing the pattern-matcher to | |
26510 | use all the algebra it can muster, but the righthand side will | |
26511 | always simplify to a literal addition like @samp{f((-y) + x)}. | |
26512 | ||
26513 | @node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules | |
26514 | @subsection Other Features of Rewrite Rules | |
26515 | ||
26516 | @noindent | |
26517 | Certain ``function names'' serve as markers in rewrite rules. | |
26518 | Here is a complete list of these markers. First are listed the | |
26519 | markers that work inside a pattern; then come the markers that | |
26520 | work in the righthand side of a rule. | |
26521 | ||
5d67986c RS |
26522 | @ignore |
26523 | @starindex | |
26524 | @end ignore | |
d7b8e6c6 EZ |
26525 | @tindex import |
26526 | One kind of marker, @samp{import(x)}, takes the place of a whole | |
a4231b04 | 26527 | rule. Here @expr{x} is the name of a variable containing another |
d7b8e6c6 EZ |
26528 | rule set; those rules are ``spliced into'' the rule set that |
26529 | imports them. For example, if @samp{[f(a+b) := f(a) + f(b), | |
26530 | f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF}, | |
26531 | then the rule set @samp{[f(0) := 0, import(linearF)]} will apply | |
26532 | all three rules. It is possible to modify the imported rules | |
26533 | slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports | |
a4231b04 | 26534 | the rule set @expr{x} with all occurrences of |
8e04863e | 26535 | @texline @math{v_1}, |
a4231b04 JB |
26536 | @infoline @expr{v1}, |
26537 | as either a variable name or a function name, replaced with | |
8e04863e | 26538 | @texline @math{x_1} |
a4231b04 JB |
26539 | @infoline @expr{x1} |
26540 | and so on. (If | |
8e04863e | 26541 | @texline @math{v_1} |
a4231b04 JB |
26542 | @infoline @expr{v1} |
26543 | is used as a function name, then | |
8e04863e | 26544 | @texline @math{x_1} |
a4231b04 | 26545 | @infoline @expr{x1} |
d7b8e6c6 EZ |
26546 | must be either a function name itself or a @w{@samp{< >}} nameless |
26547 | function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0, | |
26548 | import(linearF, f, g)]} applies the linearity rules to the function | |
26549 | @samp{g} instead of @samp{f}. Imports can be nested, but the | |
26550 | import-with-renaming feature may fail to rename sub-imports properly. | |
26551 | ||
26552 | The special functions allowed in patterns are: | |
26553 | ||
26554 | @table @samp | |
26555 | @item quote(x) | |
5d67986c RS |
26556 | @ignore |
26557 | @starindex | |
26558 | @end ignore | |
d7b8e6c6 | 26559 | @tindex quote |
a4231b04 | 26560 | This pattern matches exactly @expr{x}; variable names in @expr{x} are |
d7b8e6c6 EZ |
26561 | not interpreted as meta-variables. The only flexibility is that |
26562 | numbers are compared for numeric equality, so that the pattern | |
26563 | @samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}. | |
26564 | (Numbers are always treated this way by the rewrite mechanism: | |
26565 | The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}. | |
26566 | The rewrite may produce either @samp{g(12)} or @samp{g(12.0)} | |
26567 | as a result in this case.) | |
26568 | ||
26569 | @item plain(x) | |
5d67986c RS |
26570 | @ignore |
26571 | @starindex | |
26572 | @end ignore | |
d7b8e6c6 | 26573 | @tindex plain |
a4231b04 JB |
26574 | Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This |
26575 | pattern matches a call to function @expr{f} with the specified | |
d7b8e6c6 | 26576 | argument patterns. No special knowledge of the properties of the |
a4231b04 | 26577 | function @expr{f} is used in this case; @samp{+} is not commutative or |
d7b8e6c6 EZ |
26578 | associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}} |
26579 | are treated as patterns. If you wish them to be treated ``plainly'' | |
26580 | as well, you must enclose them with more @code{plain} markers: | |
26581 | @samp{plain(plain(@w{-a}) + plain(b c))}. | |
26582 | ||
26583 | @item opt(x,def) | |
5d67986c RS |
26584 | @ignore |
26585 | @starindex | |
26586 | @end ignore | |
d7b8e6c6 | 26587 | @tindex opt |
a4231b04 | 26588 | Here @expr{x} must be a variable name. This must appear as an |
d7b8e6c6 EZ |
26589 | argument to a function or an element of a vector; it specifies that |
26590 | the argument or element is optional. | |
26591 | As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||}, | |
26592 | or as the second argument to @samp{/} or @samp{^}, the value @var{def} | |
26593 | may be omitted. The pattern @samp{x + opt(y)} matches a sum by | |
a4231b04 JB |
26594 | binding one summand to @expr{x} and the other to @expr{y}, and it |
26595 | matches anything else by binding the whole expression to @expr{x} and | |
26596 | zero to @expr{y}. The other operators above work similarly. | |
d7b8e6c6 | 26597 | |
28665d46 | 26598 | For general miscellaneous functions, the default value @code{def} |
d7b8e6c6 EZ |
26599 | must be specified. Optional arguments are dropped starting with |
26600 | the rightmost one during matching. For example, the pattern | |
26601 | @samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)}, | |
a4231b04 | 26602 | or @samp{f(a,b,c)}. Default values of zero and @expr{b} are |
d7b8e6c6 | 26603 | supplied in this example for the omitted arguments. Note that |
a4231b04 JB |
26604 | the literal variable @expr{b} will be the default in the latter |
26605 | case, @emph{not} the value that matched the meta-variable @expr{b}. | |
d7b8e6c6 EZ |
26606 | In other words, the default @var{def} is effectively quoted. |
26607 | ||
26608 | @item condition(x,c) | |
5d67986c RS |
26609 | @ignore |
26610 | @starindex | |
26611 | @end ignore | |
d7b8e6c6 EZ |
26612 | @tindex condition |
26613 | @tindex :: | |
a4231b04 JB |
26614 | This matches the pattern @expr{x}, with the attached condition |
26615 | @expr{c}. It is the same as @samp{x :: c}. | |
d7b8e6c6 EZ |
26616 | |
26617 | @item pand(x,y) | |
5d67986c RS |
26618 | @ignore |
26619 | @starindex | |
26620 | @end ignore | |
d7b8e6c6 EZ |
26621 | @tindex pand |
26622 | @tindex &&& | |
a4231b04 JB |
26623 | This matches anything that matches both pattern @expr{x} and |
26624 | pattern @expr{y}. It is the same as @samp{x &&& y}. | |
d7b8e6c6 EZ |
26625 | @pxref{Composing Patterns in Rewrite Rules}. |
26626 | ||
26627 | @item por(x,y) | |
5d67986c RS |
26628 | @ignore |
26629 | @starindex | |
26630 | @end ignore | |
d7b8e6c6 EZ |
26631 | @tindex por |
26632 | @tindex ||| | |
a4231b04 JB |
26633 | This matches anything that matches either pattern @expr{x} or |
26634 | pattern @expr{y}. It is the same as @w{@samp{x ||| y}}. | |
d7b8e6c6 EZ |
26635 | |
26636 | @item pnot(x) | |
5d67986c RS |
26637 | @ignore |
26638 | @starindex | |
26639 | @end ignore | |
d7b8e6c6 EZ |
26640 | @tindex pnot |
26641 | @tindex !!! | |
a4231b04 | 26642 | This matches anything that does not match pattern @expr{x}. |
d7b8e6c6 EZ |
26643 | It is the same as @samp{!!! x}. |
26644 | ||
26645 | @item cons(h,t) | |
5d67986c RS |
26646 | @ignore |
26647 | @mindex cons | |
26648 | @end ignore | |
d7b8e6c6 EZ |
26649 | @tindex cons (rewrites) |
26650 | This matches any vector of one or more elements. The first | |
a4231b04 JB |
26651 | element is matched to @expr{h}; a vector of the remaining |
26652 | elements is matched to @expr{t}. Note that vectors of fixed | |
d7b8e6c6 EZ |
26653 | length can also be matched as actual vectors: The rule |
26654 | @samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent | |
26655 | to the rule @samp{[a,b] := [a+b]}. | |
26656 | ||
26657 | @item rcons(t,h) | |
5d67986c RS |
26658 | @ignore |
26659 | @mindex rcons | |
26660 | @end ignore | |
d7b8e6c6 EZ |
26661 | @tindex rcons (rewrites) |
26662 | This is like @code{cons}, except that the @emph{last} element | |
a4231b04 JB |
26663 | is matched to @expr{h}, with the remaining elements matched |
26664 | to @expr{t}. | |
d7b8e6c6 EZ |
26665 | |
26666 | @item apply(f,args) | |
5d67986c RS |
26667 | @ignore |
26668 | @mindex apply | |
26669 | @end ignore | |
d7b8e6c6 EZ |
26670 | @tindex apply (rewrites) |
26671 | This matches any function call. The name of the function, in | |
a4231b04 | 26672 | the form of a variable, is matched to @expr{f}. The arguments |
d7b8e6c6 EZ |
26673 | of the function, as a vector of zero or more objects, are |
26674 | matched to @samp{args}. Constants, variables, and vectors | |
26675 | do @emph{not} match an @code{apply} pattern. For example, | |
26676 | @samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)} | |
26677 | matches any call to the function @samp{f}, @samp{apply(f,[a,b])} | |
26678 | matches any function call with exactly two arguments, and | |
26679 | @samp{apply(quote(f), cons(a,cons(b,x)))} matches any call | |
26680 | to the function @samp{f} with two or more arguments. Another | |
26681 | way to implement the latter, if the rest of the rule does not | |
26682 | need to refer to the first two arguments of @samp{f} by name, | |
26683 | would be @samp{apply(quote(f), x :: vlen(x) >= 2)}. | |
26684 | Here's a more interesting sample use of @code{apply}: | |
26685 | ||
26686 | @example | |
26687 | apply(f,[x+n]) := n + apply(f,[x]) | |
26688 | :: in(f, [floor,ceil,round,trunc]) :: integer(n) | |
26689 | @end example | |
26690 | ||
26691 | Note, however, that this will be slower to match than a rule | |
26692 | set with four separate rules. The reason is that Calc sorts | |
26693 | the rules of a rule set according to top-level function name; | |
26694 | if the top-level function is @code{apply}, Calc must try the | |
26695 | rule for every single formula and sub-formula. If the top-level | |
26696 | function in the pattern is, say, @code{floor}, then Calc invokes | |
26697 | the rule only for sub-formulas which are calls to @code{floor}. | |
26698 | ||
26699 | Formulas normally written with operators like @code{+} are still | |
26700 | considered function calls: @code{apply(f,x)} matches @samp{a+b} | |
26701 | with @samp{f = add}, @samp{x = [a,b]}. | |
26702 | ||
26703 | You must use @code{apply} for meta-variables with function names | |
26704 | on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)} | |
26705 | is @emph{not} correct, because it rewrites @samp{spam(6)} into | |
26706 | @samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}. | |
07ce2eb3 JB |
26707 | Also note that you will have to use No-Simplify mode (@kbd{m O}) |
26708 | when entering this rule so that the @code{apply} isn't | |
d7b8e6c6 EZ |
26709 | evaluated immediately to get the new rule @samp{f(x) := f(x+1)}. |
26710 | Or, use @kbd{s e} to enter the rule without going through the stack, | |
26711 | or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}. | |
26712 | @xref{Conditional Rewrite Rules}. | |
26713 | ||
26714 | @item select(x) | |
5d67986c RS |
26715 | @ignore |
26716 | @starindex | |
26717 | @end ignore | |
d7b8e6c6 EZ |
26718 | @tindex select |
26719 | This is used for applying rules to formulas with selections; | |
26720 | @pxref{Selections with Rewrite Rules}. | |
26721 | @end table | |
26722 | ||
26723 | Special functions for the righthand sides of rules are: | |
26724 | ||
26725 | @table @samp | |
26726 | @item quote(x) | |
26727 | The notation @samp{quote(x)} is changed to @samp{x} when the | |
26728 | righthand side is used. As far as the rewrite rule is concerned, | |
26729 | @code{quote} is invisible. However, @code{quote} has the special | |
26730 | property in Calc that its argument is not evaluated. Thus, | |
26731 | while it will not work to put the rule @samp{t(a) := typeof(a)} | |
26732 | on the stack because @samp{typeof(a)} is evaluated immediately | |
26733 | to produce @samp{t(a) := 100}, you can use @code{quote} to | |
26734 | protect the righthand side: @samp{t(a) := quote(typeof(a))}. | |
26735 | (@xref{Conditional Rewrite Rules}, for another trick for | |
26736 | protecting rules from evaluation.) | |
26737 | ||
26738 | @item plain(x) | |
26739 | Special properties of and simplifications for the function call | |
a4231b04 | 26740 | @expr{x} are not used. One interesting case where @code{plain} |
d7b8e6c6 EZ |
26741 | is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a |
26742 | shorthand notation for the @code{quote} function. This rule will | |
26743 | not work as shown; instead of replacing @samp{q(foo)} with | |
26744 | @samp{quote(foo)}, it will replace it with @samp{foo}! The correct | |
26745 | rule would be @samp{q(x) := plain(quote(x))}. | |
26746 | ||
26747 | @item cons(h,t) | |
a4231b04 | 26748 | Where @expr{t} is a vector, this is converted into an expanded |
d7b8e6c6 EZ |
26749 | vector during rewrite processing. Note that @code{cons} is a regular |
26750 | Calc function which normally does this anyway; the only way @code{cons} | |
26751 | is treated specially by rewrites is that @code{cons} on the righthand | |
26752 | side of a rule will be evaluated even if default simplifications | |
26753 | have been turned off. | |
26754 | ||
26755 | @item rcons(t,h) | |
a4231b04 JB |
26756 | Analogous to @code{cons} except putting @expr{h} at the @emph{end} of |
26757 | the vector @expr{t}. | |
d7b8e6c6 EZ |
26758 | |
26759 | @item apply(f,args) | |
a4231b04 | 26760 | Where @expr{f} is a variable and @var{args} is a vector, this |
d7b8e6c6 EZ |
26761 | is converted to a function call. Once again, note that @code{apply} |
26762 | is also a regular Calc function. | |
26763 | ||
26764 | @item eval(x) | |
5d67986c RS |
26765 | @ignore |
26766 | @starindex | |
26767 | @end ignore | |
d7b8e6c6 | 26768 | @tindex eval |
a4231b04 | 26769 | The formula @expr{x} is handled in the usual way, then the |
d7b8e6c6 EZ |
26770 | default simplifications are applied to it even if they have |
26771 | been turned off normally. This allows you to treat any function | |
26772 | similarly to the way @code{cons} and @code{apply} are always | |
26773 | treated. However, there is a slight difference: @samp{cons(2+3, [])} | |
26774 | with default simplifications off will be converted to @samp{[2+3]}, | |
26775 | whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}. | |
26776 | ||
26777 | @item evalsimp(x) | |
5d67986c RS |
26778 | @ignore |
26779 | @starindex | |
26780 | @end ignore | |
d7b8e6c6 | 26781 | @tindex evalsimp |
a4231b04 | 26782 | The formula @expr{x} has meta-variables substituted in the usual |
d7b8e6c6 EZ |
26783 | way, then algebraically simplified as if by the @kbd{a s} command. |
26784 | ||
26785 | @item evalextsimp(x) | |
5d67986c RS |
26786 | @ignore |
26787 | @starindex | |
26788 | @end ignore | |
d7b8e6c6 | 26789 | @tindex evalextsimp |
a4231b04 | 26790 | The formula @expr{x} has meta-variables substituted in the normal |
d7b8e6c6 EZ |
26791 | way, then ``extendedly'' simplified as if by the @kbd{a e} command. |
26792 | ||
26793 | @item select(x) | |
26794 | @xref{Selections with Rewrite Rules}. | |
26795 | @end table | |
26796 | ||
26797 | There are also some special functions you can use in conditions. | |
26798 | ||
26799 | @table @samp | |
26800 | @item let(v := x) | |
5d67986c RS |
26801 | @ignore |
26802 | @starindex | |
26803 | @end ignore | |
d7b8e6c6 | 26804 | @tindex let |
a4231b04 | 26805 | The expression @expr{x} is evaluated with meta-variables substituted. |
d7b8e6c6 | 26806 | The @kbd{a s} command's simplifications are @emph{not} applied by |
a4231b04 | 26807 | default, but @expr{x} can include calls to @code{evalsimp} or |
d7b8e6c6 EZ |
26808 | @code{evalextsimp} as described above to invoke higher levels |
26809 | of simplification. The | |
a4231b04 | 26810 | result of @expr{x} is then bound to the meta-variable @expr{v}. As |
d7b8e6c6 EZ |
26811 | usual, if this meta-variable has already been matched to something |
26812 | else the two values must be equal; if the meta-variable is new then | |
26813 | it is bound to the result of the expression. This variable can then | |
26814 | appear in later conditions, and on the righthand side of the rule. | |
a4231b04 JB |
26815 | In fact, @expr{v} may be any pattern in which case the result of |
26816 | evaluating @expr{x} is matched to that pattern, binding any | |
d7b8e6c6 EZ |
26817 | meta-variables that appear in that pattern. Note that @code{let} |
26818 | can only appear by itself as a condition, or as one term of an | |
26819 | @samp{&&} which is a whole condition: It cannot be inside | |
a4231b04 | 26820 | an @samp{||} term or otherwise buried. |
d7b8e6c6 EZ |
26821 | |
26822 | The alternate, equivalent form @samp{let(v, x)} is also recognized. | |
26823 | Note that the use of @samp{:=} by @code{let}, while still being | |
26824 | assignment-like in character, is unrelated to the use of @samp{:=} | |
26825 | in the main part of a rewrite rule. | |
26826 | ||
26827 | As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)} | |
26828 | replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if | |
26829 | that inverse exists and is constant. For example, if @samp{a} is a | |
26830 | singular matrix the operation @samp{1/a} is left unsimplified and | |
26831 | @samp{constant(ia)} fails, but if @samp{a} is an invertible matrix | |
26832 | then the rule succeeds. Without @code{let} there would be no way | |
26833 | to express this rule that didn't have to invert the matrix twice. | |
26834 | Note that, because the meta-variable @samp{ia} is otherwise unbound | |
26835 | in this rule, the @code{let} condition itself always ``succeeds'' | |
26836 | because no matter what @samp{1/a} evaluates to, it can successfully | |
a4231b04 | 26837 | be bound to @code{ia}. |
d7b8e6c6 EZ |
26838 | |
26839 | Here's another example, for integrating cosines of linear | |
26840 | terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}. | |
26841 | The @code{lin} function returns a 3-vector if its argument is linear, | |
26842 | or leaves itself unevaluated if not. But an unevaluated @code{lin} | |
26843 | call will not match the 3-vector on the lefthand side of the @code{let}, | |
26844 | so this @code{let} both verifies that @code{y} is linear, and binds | |
26845 | the coefficients @code{a} and @code{b} for use elsewhere in the rule. | |
26846 | (It would have been possible to use @samp{sin(a x + b)/b} for the | |
26847 | righthand side instead, but using @samp{sin(y)/b} avoids gratuitous | |
a4231b04 | 26848 | rearrangement of the argument of the sine.) |
d7b8e6c6 | 26849 | |
5d67986c RS |
26850 | @ignore |
26851 | @starindex | |
26852 | @end ignore | |
d7b8e6c6 EZ |
26853 | @tindex ierf |
26854 | Similarly, here is a rule that implements an inverse-@code{erf} | |
26855 | function. It uses @code{root} to search for a solution. If | |
26856 | @code{root} succeeds, it will return a vector of two numbers | |
26857 | where the first number is the desired solution. If no solution | |
26858 | is found, @code{root} remains in symbolic form. So we use | |
26859 | @code{let} to check that the result was indeed a vector. | |
26860 | ||
26861 | @example | |
26862 | ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5)) | |
26863 | @end example | |
26864 | ||
26865 | @item matches(v,p) | |
26866 | The meta-variable @var{v}, which must already have been matched | |
26867 | to something elsewhere in the rule, is compared against pattern | |
26868 | @var{p}. Since @code{matches} is a standard Calc function, it | |
26869 | can appear anywhere in a condition. But if it appears alone or | |
26870 | as a term of a top-level @samp{&&}, then you get the special | |
26871 | extra feature that meta-variables which are bound to things | |
26872 | inside @var{p} can be used elsewhere in the surrounding rewrite | |
26873 | rule. | |
26874 | ||
26875 | The only real difference between @samp{let(p := v)} and | |
26876 | @samp{matches(v, p)} is that the former evaluates @samp{v} using | |
26877 | the default simplifications, while the latter does not. | |
26878 | ||
26879 | @item remember | |
26880 | @vindex remember | |
26881 | This is actually a variable, not a function. If @code{remember} | |
26882 | appears as a condition in a rule, then when that rule succeeds | |
26883 | the original expression and rewritten expression are added to the | |
26884 | front of the rule set that contained the rule. If the rule set | |
26885 | was not stored in a variable, @code{remember} is ignored. The | |
26886 | lefthand side is enclosed in @code{quote} in the added rule if it | |
26887 | contains any variables. | |
26888 | ||
26889 | For example, the rule @samp{f(n) := n f(n-1) :: remember} applied | |
26890 | to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front | |
26891 | of the rule set. The rule set @code{EvalRules} works slightly | |
26892 | differently: There, the evaluation of @samp{f(6)} will complete before | |
26893 | the result is added to the rule set, in this case as @samp{f(7) := 5040}. | |
26894 | Thus @code{remember} is most useful inside @code{EvalRules}. | |
26895 | ||
26896 | It is up to you to ensure that the optimization performed by | |
26897 | @code{remember} is safe. For example, the rule @samp{foo(n) := n | |
26898 | :: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is | |
26899 | the function equivalent of the @kbd{=} command); if the variable | |
26900 | @code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will | |
26901 | be added to the rule set and will continue to operate even if | |
26902 | @code{eatfoo} is later changed to 0. | |
26903 | ||
26904 | @item remember(c) | |
5d67986c RS |
26905 | @ignore |
26906 | @starindex | |
26907 | @end ignore | |
d7b8e6c6 | 26908 | @tindex remember |
a4231b04 | 26909 | Remember the match as described above, but only if condition @expr{c} |
d7b8e6c6 EZ |
26910 | is true. For example, @samp{remember(n % 4 = 0)} in the above factorial |
26911 | rule remembers only every fourth result. Note that @samp{remember(1)} | |
26912 | is equivalent to @samp{remember}, and @samp{remember(0)} has no effect. | |
26913 | @end table | |
26914 | ||
26915 | @node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules | |
26916 | @subsection Composing Patterns in Rewrite Rules | |
26917 | ||
26918 | @noindent | |
26919 | There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!}, | |
26920 | that combine rewrite patterns to make larger patterns. The | |
26921 | combinations are ``and,'' ``or,'' and ``not,'' respectively, and | |
26922 | these operators are the pattern equivalents of @samp{&&}, @samp{||} | |
26923 | and @samp{!} (which operate on zero-or-nonzero logical values). | |
26924 | ||
26925 | Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic | |
26926 | form by all regular Calc features; they have special meaning only in | |
26927 | the context of rewrite rule patterns. | |
26928 | ||
26929 | The pattern @samp{@var{p1} &&& @var{p2}} matches anything that | |
26930 | matches both @var{p1} and @var{p2}. One especially useful case is | |
26931 | when one of @var{p1} or @var{p2} is a meta-variable. For example, | |
26932 | here is a rule that operates on error forms: | |
26933 | ||
26934 | @example | |
26935 | f(x &&& a +/- b, x) := g(x) | |
26936 | @end example | |
26937 | ||
26938 | This does the same thing, but is arguably simpler than, the rule | |
26939 | ||
26940 | @example | |
26941 | f(a +/- b, a +/- b) := g(a +/- b) | |
26942 | @end example | |
26943 | ||
5d67986c RS |
26944 | @ignore |
26945 | @starindex | |
26946 | @end ignore | |
d7b8e6c6 EZ |
26947 | @tindex ends |
26948 | Here's another interesting example: | |
26949 | ||
26950 | @example | |
26951 | ends(cons(a, x) &&& rcons(y, b)) := [a, b] | |
26952 | @end example | |
26953 | ||
26954 | @noindent | |
26955 | which effectively clips out the middle of a vector leaving just | |
26956 | the first and last elements. This rule will change a one-element | |
26957 | vector @samp{[a]} to @samp{[a, a]}. The similar rule | |
26958 | ||
26959 | @example | |
26960 | ends(cons(a, rcons(y, b))) := [a, b] | |
26961 | @end example | |
26962 | ||
26963 | @noindent | |
26964 | would do the same thing except that it would fail to match a | |
26965 | one-element vector. | |
26966 | ||
26967 | @tex | |
26968 | \bigskip | |
26969 | @end tex | |
26970 | ||
26971 | The pattern @samp{@var{p1} ||| @var{p2}} matches anything that | |
26972 | matches either @var{p1} or @var{p2}. Calc first tries matching | |
26973 | against @var{p1}; if that fails, it goes on to try @var{p2}. | |
26974 | ||
5d67986c RS |
26975 | @ignore |
26976 | @starindex | |
26977 | @end ignore | |
d7b8e6c6 EZ |
26978 | @tindex curve |
26979 | A simple example of @samp{|||} is | |
26980 | ||
26981 | @example | |
26982 | curve(inf ||| -inf) := 0 | |
26983 | @end example | |
26984 | ||
26985 | @noindent | |
26986 | which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero. | |
26987 | ||
26988 | Here is a larger example: | |
26989 | ||
26990 | @example | |
26991 | log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b) | |
26992 | @end example | |
26993 | ||
26994 | This matches both generalized and natural logarithms in a single rule. | |
26995 | Note that the @samp{::} term must be enclosed in parentheses because | |
26996 | that operator has lower precedence than @samp{|||} or @samp{:=}. | |
26997 | ||
26998 | (In practice this rule would probably include a third alternative, | |
26999 | omitted here for brevity, to take care of @code{log10}.) | |
27000 | ||
27001 | While Calc generally treats interior conditions exactly the same as | |
27002 | conditions on the outside of a rule, it does guarantee that if all the | |
27003 | variables in the condition are special names like @code{e}, or already | |
27004 | bound in the pattern to which the condition is attached (say, if | |
27005 | @samp{a} had appeared in this condition), then Calc will process this | |
27006 | condition right after matching the pattern to the left of the @samp{::}. | |
27007 | Thus, we know that @samp{b} will be bound to @samp{e} only if the | |
27008 | @code{ln} branch of the @samp{|||} was taken. | |
27009 | ||
27010 | Note that this rule was careful to bind the same set of meta-variables | |
27011 | on both sides of the @samp{|||}. Calc does not check this, but if | |
27012 | you bind a certain meta-variable only in one branch and then use that | |
27013 | meta-variable elsewhere in the rule, results are unpredictable: | |
27014 | ||
27015 | @example | |
27016 | f(a,b) ||| g(b) := h(a,b) | |
27017 | @end example | |
27018 | ||
27019 | Here if the pattern matches @samp{g(17)}, Calc makes no promises about | |
27020 | the value that will be substituted for @samp{a} on the righthand side. | |
27021 | ||
27022 | @tex | |
27023 | \bigskip | |
27024 | @end tex | |
27025 | ||
27026 | The pattern @samp{!!! @var{pat}} matches anything that does not | |
27027 | match @var{pat}. Any meta-variables that are bound while matching | |
27028 | @var{pat} remain unbound outside of @var{pat}. | |
27029 | ||
27030 | For example, | |
27031 | ||
27032 | @example | |
27033 | f(x &&& !!! a +/- b, !!![]) := g(x) | |
27034 | @end example | |
27035 | ||
27036 | @noindent | |
27037 | converts @code{f} whose first argument is anything @emph{except} an | |
27038 | error form, and whose second argument is not the empty vector, into | |
27039 | a similar call to @code{g} (but without the second argument). | |
27040 | ||
27041 | If we know that the second argument will be a vector (empty or not), | |
27042 | then an equivalent rule would be: | |
27043 | ||
27044 | @example | |
27045 | f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0 | |
27046 | @end example | |
27047 | ||
27048 | @noindent | |
27049 | where of course 7 is the @code{typeof} code for error forms. | |
27050 | Another final condition, that works for any kind of @samp{y}, | |
27051 | would be @samp{!istrue(y == [])}. (The @code{istrue} function | |
27052 | returns an explicit 0 if its argument was left in symbolic form; | |
27053 | plain @samp{!(y == [])} or @samp{y != []} would not work to replace | |
27054 | @samp{!!![]} since these would be left unsimplified, and thus cause | |
27055 | the rule to fail, if @samp{y} was something like a variable name.) | |
27056 | ||
27057 | It is possible for a @samp{!!!} to refer to meta-variables bound | |
27058 | elsewhere in the pattern. For example, | |
27059 | ||
27060 | @example | |
27061 | f(a, !!!a) := g(a) | |
27062 | @end example | |
27063 | ||
27064 | @noindent | |
27065 | matches any call to @code{f} with different arguments, changing | |
27066 | this to @code{g} with only the first argument. | |
27067 | ||
27068 | If a function call is to be matched and one of the argument patterns | |
27069 | contains a @samp{!!!} somewhere inside it, that argument will be | |
27070 | matched last. Thus | |
27071 | ||
27072 | @example | |
27073 | f(!!!a, a) := g(a) | |
27074 | @end example | |
27075 | ||
27076 | @noindent | |
27077 | will be careful to bind @samp{a} to the second argument of @code{f} | |
27078 | before testing the first argument. If Calc had tried to match the | |
27079 | first argument of @code{f} first, the results would have been | |
28665d46 | 27080 | disastrous: since @code{a} was unbound so far, the pattern @samp{a} |
d7b8e6c6 EZ |
27081 | would have matched anything at all, and the pattern @samp{!!!a} |
27082 | therefore would @emph{not} have matched anything at all! | |
27083 | ||
27084 | @node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules | |
27085 | @subsection Nested Formulas with Rewrite Rules | |
27086 | ||
27087 | @noindent | |
27088 | When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from | |
27089 | the top of the stack and attempts to match any of the specified rules | |
27090 | to any part of the expression, starting with the whole expression | |
27091 | and then, if that fails, trying deeper and deeper sub-expressions. | |
27092 | For each part of the expression, the rules are tried in the order | |
27093 | they appear in the rules vector. The first rule to match the first | |
27094 | sub-expression wins; it replaces the matched sub-expression according | |
27095 | to the @var{new} part of the rule. | |
27096 | ||
27097 | Often, the rule set will match and change the formula several times. | |
27098 | The top-level formula is first matched and substituted repeatedly until | |
27099 | it no longer matches the pattern; then, sub-formulas are tried, and | |
27100 | so on. Once every part of the formula has gotten its chance, the | |
27101 | rewrite mechanism starts over again with the top-level formula | |
27102 | (in case a substitution of one of its arguments has caused it again | |
27103 | to match). This continues until no further matches can be made | |
27104 | anywhere in the formula. | |
27105 | ||
27106 | It is possible for a rule set to get into an infinite loop. The | |
27107 | most obvious case, replacing a formula with itself, is not a problem | |
27108 | because a rule is not considered to ``succeed'' unless the righthand | |
27109 | side actually comes out to something different than the original | |
27110 | formula or sub-formula that was matched. But if you accidentally | |
27111 | had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse | |
27112 | @samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would | |
27113 | run forever switching a formula back and forth between the two | |
27114 | forms. | |
27115 | ||
27116 | To avoid disaster, Calc normally stops after 100 changes have been | |
27117 | made to the formula. This will be enough for most multiple rewrites, | |
27118 | but it will keep an endless loop of rewrites from locking up the | |
27119 | computer forever. (On most systems, you can also type @kbd{C-g} to | |
27120 | halt any Emacs command prematurely.) | |
27121 | ||
27122 | To change this limit, give a positive numeric prefix argument. | |
27123 | In particular, @kbd{M-1 a r} applies only one rewrite at a time, | |
27124 | useful when you are first testing your rule (or just if repeated | |
27125 | rewriting is not what is called for by your application). | |
27126 | ||
5d67986c RS |
27127 | @ignore |
27128 | @starindex | |
27129 | @end ignore | |
27130 | @ignore | |
27131 | @mindex iter@idots | |
27132 | @end ignore | |
d7b8e6c6 EZ |
27133 | @tindex iterations |
27134 | You can also put a ``function call'' @samp{iterations(@var{n})} | |
27135 | in place of a rule anywhere in your rules vector (but usually at | |
27136 | the top). Then, @var{n} will be used instead of 100 as the default | |
27137 | number of iterations for this rule set. You can use | |
27138 | @samp{iterations(inf)} if you want no iteration limit by default. | |
27139 | A prefix argument will override the @code{iterations} limit in the | |
27140 | rule set. | |
27141 | ||
27142 | @example | |
27143 | [ iterations(1), | |
27144 | f(x) := f(x+1) ] | |
27145 | @end example | |
27146 | ||
27147 | More precisely, the limit controls the number of ``iterations,'' | |
27148 | where each iteration is a successful matching of a rule pattern whose | |
27149 | righthand side, after substituting meta-variables and applying the | |
27150 | default simplifications, is different from the original sub-formula | |
27151 | that was matched. | |
27152 | ||
27153 | A prefix argument of zero sets the limit to infinity. Use with caution! | |
27154 | ||
27155 | Given a negative numeric prefix argument, @kbd{a r} will match and | |
27156 | substitute the top-level expression up to that many times, but | |
27157 | will not attempt to match the rules to any sub-expressions. | |
27158 | ||
27159 | In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})} | |
27160 | does a rewriting operation. Here @var{expr} is the expression | |
27161 | being rewritten, @var{rules} is the rule, vector of rules, or | |
27162 | variable containing the rules, and @var{n} is the optional | |
27163 | iteration limit, which may be a positive integer, a negative | |
27164 | integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted | |
27165 | the @code{iterations} value from the rule set is used; if both | |
27166 | are omitted, 100 is used. | |
27167 | ||
27168 | @node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules | |
27169 | @subsection Multi-Phase Rewrite Rules | |
27170 | ||
27171 | @noindent | |
27172 | It is possible to separate a rewrite rule set into several @dfn{phases}. | |
27173 | During each phase, certain rules will be enabled while certain others | |
27174 | will be disabled. A @dfn{phase schedule} controls the order in which | |
27175 | phases occur during the rewriting process. | |
27176 | ||
5d67986c RS |
27177 | @ignore |
27178 | @starindex | |
27179 | @end ignore | |
d7b8e6c6 EZ |
27180 | @tindex phase |
27181 | @vindex all | |
27182 | If a call to the marker function @code{phase} appears in the rules | |
27183 | vector in place of a rule, all rules following that point will be | |
27184 | members of the phase(s) identified in the arguments to @code{phase}. | |
27185 | Phases are given integer numbers. The markers @samp{phase()} and | |
27186 | @samp{phase(all)} both mean the following rules belong to all phases; | |
27187 | this is the default at the start of the rule set. | |
27188 | ||
27189 | If you do not explicitly schedule the phases, Calc sorts all phase | |
27190 | numbers that appear in the rule set and executes the phases in | |
27191 | ascending order. For example, the rule set | |
27192 | ||
d7b8e6c6 | 27193 | @example |
5d67986c | 27194 | @group |
d7b8e6c6 EZ |
27195 | [ f0(x) := g0(x), |
27196 | phase(1), | |
27197 | f1(x) := g1(x), | |
27198 | phase(2), | |
27199 | f2(x) := g2(x), | |
27200 | phase(3), | |
27201 | f3(x) := g3(x), | |
27202 | phase(1,2), | |
27203 | f4(x) := g4(x) ] | |
d7b8e6c6 | 27204 | @end group |
5d67986c | 27205 | @end example |
d7b8e6c6 EZ |
27206 | |
27207 | @noindent | |
27208 | has three phases, 1 through 3. Phase 1 consists of the @code{f0}, | |
27209 | @code{f1}, and @code{f4} rules (in that order). Phase 2 consists of | |
27210 | @code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0} | |
27211 | and @code{f3}. | |
27212 | ||
27213 | When Calc rewrites a formula using this rule set, it first rewrites | |
27214 | the formula using only the phase 1 rules until no further changes are | |
27215 | possible. Then it switches to the phase 2 rule set and continues | |
27216 | until no further changes occur, then finally rewrites with phase 3. | |
27217 | When no more phase 3 rules apply, rewriting finishes. (This is | |
27218 | assuming @kbd{a r} with a large enough prefix argument to allow the | |
27219 | rewriting to run to completion; the sequence just described stops | |
27220 | early if the number of iterations specified in the prefix argument, | |
27221 | 100 by default, is reached.) | |
27222 | ||
27223 | During each phase, Calc descends through the nested levels of the | |
27224 | formula as described previously. (@xref{Nested Formulas with Rewrite | |
27225 | Rules}.) Rewriting starts at the top of the formula, then works its | |
27226 | way down to the parts, then goes back to the top and works down again. | |
27227 | The phase 2 rules do not begin until no phase 1 rules apply anywhere | |
27228 | in the formula. | |
27229 | ||
5d67986c RS |
27230 | @ignore |
27231 | @starindex | |
27232 | @end ignore | |
d7b8e6c6 EZ |
27233 | @tindex schedule |
27234 | A @code{schedule} marker appearing in the rule set (anywhere, but | |
27235 | conventionally at the top) changes the default schedule of phases. | |
27236 | In the simplest case, @code{schedule} has a sequence of phase numbers | |
27237 | for arguments; each phase number is invoked in turn until the | |
27238 | arguments to @code{schedule} are exhausted. Thus adding | |
27239 | @samp{schedule(3,2,1)} at the top of the above rule set would | |
27240 | reverse the order of the phases; @samp{schedule(1,2,3)} would have | |
27241 | no effect since this is the default schedule; and @samp{schedule(1,2,1,3)} | |
27242 | would give phase 1 a second chance after phase 2 has completed, before | |
27243 | moving on to phase 3. | |
27244 | ||
27245 | Any argument to @code{schedule} can instead be a vector of phase | |
27246 | numbers (or even of sub-vectors). Then the sub-sequence of phases | |
27247 | described by the vector are tried repeatedly until no change occurs | |
27248 | in any phase in the sequence. For example, @samp{schedule([1, 2], 3)} | |
27249 | tries phase 1, then phase 2, then, if either phase made any changes | |
27250 | to the formula, repeats these two phases until they can make no | |
27251 | further progress. Finally, it goes on to phase 3 for finishing | |
27252 | touches. | |
27253 | ||
27254 | Also, items in @code{schedule} can be variable names as well as | |
27255 | numbers. A variable name is interpreted as the name of a function | |
27256 | to call on the whole formula. For example, @samp{schedule(1, simplify)} | |
27257 | says to apply the phase-1 rules (presumably, all of them), then to | |
27258 | call @code{simplify} which is the function name equivalent of @kbd{a s}. | |
27259 | Likewise, @samp{schedule([1, simplify])} says to alternate between | |
27260 | phase 1 and @kbd{a s} until no further changes occur. | |
27261 | ||
27262 | Phases can be used purely to improve efficiency; if it is known that | |
27263 | a certain group of rules will apply only at the beginning of rewriting, | |
27264 | and a certain other group will apply only at the end, then rewriting | |
27265 | will be faster if these groups are identified as separate phases. | |
27266 | Once the phase 1 rules are done, Calc can put them aside and no longer | |
27267 | spend any time on them while it works on phase 2. | |
27268 | ||
27269 | There are also some problems that can only be solved with several | |
27270 | rewrite phases. For a real-world example of a multi-phase rule set, | |
27271 | examine the set @code{FitRules}, which is used by the curve-fitting | |
27272 | command to convert a model expression to linear form. | |
27273 | @xref{Curve Fitting Details}. This set is divided into four phases. | |
27274 | The first phase rewrites certain kinds of expressions to be more | |
27275 | easily linearizable, but less computationally efficient. After the | |
27276 | linear components have been picked out, the final phase includes the | |
27277 | opposite rewrites to put each component back into an efficient form. | |
27278 | If both sets of rules were included in one big phase, Calc could get | |
27279 | into an infinite loop going back and forth between the two forms. | |
27280 | ||
27281 | Elsewhere in @code{FitRules}, the components are first isolated, | |
27282 | then recombined where possible to reduce the complexity of the linear | |
27283 | fit, then finally packaged one component at a time into vectors. | |
27284 | If the packaging rules were allowed to begin before the recombining | |
27285 | rules were finished, some components might be put away into vectors | |
27286 | before they had a chance to recombine. By putting these rules in | |
27287 | two separate phases, this problem is neatly avoided. | |
27288 | ||
27289 | @node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules | |
27290 | @subsection Selections with Rewrite Rules | |
27291 | ||
27292 | @noindent | |
27293 | If a sub-formula of the current formula is selected (as by @kbd{j s}; | |
27294 | @pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite}) | |
27295 | command applies only to that sub-formula. Together with a negative | |
27296 | prefix argument, you can use this fact to apply a rewrite to one | |
27297 | specific part of a formula without affecting any other parts. | |
27298 | ||
27299 | @kindex j r | |
27300 | @pindex calc-rewrite-selection | |
27301 | The @kbd{j r} (@code{calc-rewrite-selection}) command allows more | |
27302 | sophisticated operations on selections. This command prompts for | |
27303 | the rules in the same way as @kbd{a r}, but it then applies those | |
27304 | rules to the whole formula in question even though a sub-formula | |
27305 | of it has been selected. However, the selected sub-formula will | |
27306 | first have been surrounded by a @samp{select( )} function call. | |
27307 | (Calc's evaluator does not understand the function name @code{select}; | |
27308 | this is only a tag used by the @kbd{j r} command.) | |
27309 | ||
27310 | For example, suppose the formula on the stack is @samp{2 (a + b)^2} | |
27311 | and the sub-formula @samp{a + b} is selected. This formula will | |
27312 | be rewritten to @samp{2 select(a + b)^2} and then the rewrite | |
27313 | rules will be applied in the usual way. The rewrite rules can | |
27314 | include references to @code{select} to tell where in the pattern | |
27315 | the selected sub-formula should appear. | |
27316 | ||
27317 | If there is still exactly one @samp{select( )} function call in | |
27318 | the formula after rewriting is done, it indicates which part of | |
27319 | the formula should be selected afterwards. Otherwise, the | |
27320 | formula will be unselected. | |
27321 | ||
27322 | You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts | |
27323 | of the rewrite rule with @samp{select()}. However, @kbd{j r} | |
27324 | allows you to use the current selection in more flexible ways. | |
27325 | Suppose you wished to make a rule which removed the exponent from | |
27326 | the selected term; the rule @samp{select(a)^x := select(a)} would | |
27327 | work. In the above example, it would rewrite @samp{2 select(a + b)^2} | |
27328 | to @samp{2 select(a + b)}. This would then be returned to the | |
27329 | stack as @samp{2 (a + b)} with the @samp{a + b} selected. | |
27330 | ||
27331 | The @kbd{j r} command uses one iteration by default, unlike | |
27332 | @kbd{a r} which defaults to 100 iterations. A numeric prefix | |
27333 | argument affects @kbd{j r} in the same way as @kbd{a r}. | |
27334 | @xref{Nested Formulas with Rewrite Rules}. | |
27335 | ||
27336 | As with other selection commands, @kbd{j r} operates on the stack | |
27337 | entry that contains the cursor. (If the cursor is on the top-of-stack | |
27338 | @samp{.} marker, it works as if the cursor were on the formula | |
27339 | at stack level 1.) | |
27340 | ||
27341 | If you don't specify a set of rules, the rules are taken from the | |
27342 | top of the stack, just as with @kbd{a r}. In this case, the | |
27343 | cursor must indicate stack entry 2 or above as the formula to be | |
27344 | rewritten (otherwise the same formula would be used as both the | |
27345 | target and the rewrite rules). | |
27346 | ||
27347 | If the indicated formula has no selection, the cursor position within | |
27348 | the formula temporarily selects a sub-formula for the purposes of this | |
27349 | command. If the cursor is not on any sub-formula (e.g., it is in | |
27350 | the line-number area to the left of the formula), the @samp{select( )} | |
27351 | markers are ignored by the rewrite mechanism and the rules are allowed | |
27352 | to apply anywhere in the formula. | |
27353 | ||
27354 | As a special feature, the normal @kbd{a r} command also ignores | |
27355 | @samp{select( )} calls in rewrite rules. For example, if you used the | |
27356 | above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply | |
27357 | the rule as if it were @samp{a^x := a}. Thus, you can write general | |
27358 | purpose rules with @samp{select( )} hints inside them so that they | |
27359 | will ``do the right thing'' in both @kbd{a r} and @kbd{j r}, | |
27360 | both with and without selections. | |
27361 | ||
27362 | @node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules | |
27363 | @subsection Matching Commands | |
27364 | ||
27365 | @noindent | |
27366 | @kindex a m | |
27367 | @pindex calc-match | |
27368 | @tindex match | |
27369 | The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a | |
27370 | vector of formulas and a rewrite-rule-style pattern, and produces | |
27371 | a vector of all formulas which match the pattern. The command | |
27372 | prompts you to enter the pattern; as for @kbd{a r}, you can enter | |
27373 | a single pattern (i.e., a formula with meta-variables), or a | |
27374 | vector of patterns, or a variable which contains patterns, or | |
27375 | you can give a blank response in which case the patterns are taken | |
27376 | from the top of the stack. The pattern set will be compiled once | |
27377 | and saved if it is stored in a variable. If there are several | |
27378 | patterns in the set, vector elements are kept if they match any | |
27379 | of the patterns. | |
27380 | ||
27381 | For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])} | |
27382 | will return @samp{[x+y, x-y, x+y+z]}. | |
27383 | ||
27384 | The @code{import} mechanism is not available for pattern sets. | |
27385 | ||
27386 | The @kbd{a m} command can also be used to extract all vector elements | |
27387 | which satisfy any condition: The pattern @samp{x :: x>0} will select | |
27388 | all the positive vector elements. | |
27389 | ||
27390 | @kindex I a m | |
27391 | @tindex matchnot | |
27392 | With the Inverse flag [@code{matchnot}], this command extracts all | |
27393 | vector elements which do @emph{not} match the given pattern. | |
27394 | ||
5d67986c RS |
27395 | @ignore |
27396 | @starindex | |
27397 | @end ignore | |
d7b8e6c6 EZ |
27398 | @tindex matches |
27399 | There is also a function @samp{matches(@var{x}, @var{p})} which | |
27400 | evaluates to 1 if expression @var{x} matches pattern @var{p}, or | |
27401 | to 0 otherwise. This is sometimes useful for including into the | |
27402 | conditional clauses of other rewrite rules. | |
27403 | ||
5d67986c RS |
27404 | @ignore |
27405 | @starindex | |
27406 | @end ignore | |
d7b8e6c6 EZ |
27407 | @tindex vmatches |
27408 | The function @code{vmatches} is just like @code{matches}, except | |
27409 | that if the match succeeds it returns a vector of assignments to | |
27410 | the meta-variables instead of the number 1. For example, | |
27411 | @samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}. | |
27412 | If the match fails, the function returns the number 0. | |
27413 | ||
27414 | @node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules | |
27415 | @subsection Automatic Rewrites | |
27416 | ||
27417 | @noindent | |
27418 | @cindex @code{EvalRules} variable | |
27419 | @vindex EvalRules | |
27420 | It is possible to get Calc to apply a set of rewrite rules on all | |
27421 | results, effectively adding to the built-in set of default | |
27422 | simplifications. To do this, simply store your rule set in the | |
27423 | variable @code{EvalRules}. There is a convenient @kbd{s E} command | |
27424 | for editing @code{EvalRules}; @pxref{Operations on Variables}. | |
27425 | ||
27426 | For example, suppose you want @samp{sin(a + b)} to be expanded out | |
27427 | to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and | |
27428 | similarly for @samp{cos(a + b)}. The corresponding rewrite rule | |
27429 | set would be, | |
27430 | ||
d7b8e6c6 | 27431 | @smallexample |
5d67986c | 27432 | @group |
d7b8e6c6 EZ |
27433 | [ sin(a + b) := cos(a) sin(b) + sin(a) cos(b), |
27434 | cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ] | |
d7b8e6c6 | 27435 | @end group |
5d67986c | 27436 | @end smallexample |
d7b8e6c6 EZ |
27437 | |
27438 | To apply these manually, you could put them in a variable called | |
27439 | @code{trigexp} and then use @kbd{a r trigexp} every time you wanted | |
27440 | to expand trig functions. But if instead you store them in the | |
27441 | variable @code{EvalRules}, they will automatically be applied to all | |
27442 | sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on | |
07ce2eb3 | 27443 | the stack, typing @kbd{+ S} will (assuming Degrees mode) result in |
d7b8e6c6 EZ |
27444 | @samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically. |
27445 | ||
27446 | As each level of a formula is evaluated, the rules from | |
27447 | @code{EvalRules} are applied before the default simplifications. | |
27448 | Rewriting continues until no further @code{EvalRules} apply. | |
27449 | Note that this is different from the usual order of application of | |
27450 | rewrite rules: @code{EvalRules} works from the bottom up, simplifying | |
27451 | the arguments to a function before the function itself, while @kbd{a r} | |
27452 | applies rules from the top down. | |
27453 | ||
27454 | Because the @code{EvalRules} are tried first, you can use them to | |
27455 | override the normal behavior of any built-in Calc function. | |
27456 | ||
27457 | It is important not to write a rule that will get into an infinite | |
27458 | loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]} | |
27459 | appears to be a good definition of a factorial function, but it is | |
27460 | unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc | |
27461 | will continue to subtract 1 from this argument forever without reaching | |
27462 | zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}. | |
27463 | Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting | |
27464 | @samp{g(2, 4)}, this would bounce back and forth between that and | |
27465 | @samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules} | |
27466 | occurs, Emacs will eventually stop with a ``Computation got stuck | |
27467 | or ran too long'' message. | |
27468 | ||
27469 | Another subtle difference between @code{EvalRules} and regular rewrites | |
27470 | concerns rules that rewrite a formula into an identical formula. For | |
a4231b04 | 27471 | example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is |
d7b8e6c6 EZ |
27472 | already an integer. But in @code{EvalRules} this case is detected only |
27473 | if the righthand side literally becomes the original formula before any | |
27474 | further simplification. This means that @samp{f(n) := f(floor(n))} will | |
27475 | get into an infinite loop if it occurs in @code{EvalRules}. Calc will | |
27476 | replace @samp{f(6)} with @samp{f(floor(6))}, which is different from | |
27477 | @samp{f(6)}, so it will consider the rule to have matched and will | |
27478 | continue simplifying that formula; first the argument is simplified | |
27479 | to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))} | |
27480 | again, ad infinitum. A much safer rule would check its argument first, | |
27481 | say, with @samp{f(n) := f(floor(n)) :: !dint(n)}. | |
27482 | ||
27483 | (What really happens is that the rewrite mechanism substitutes the | |
27484 | meta-variables in the righthand side of a rule, compares to see if the | |
27485 | result is the same as the original formula and fails if so, then uses | |
27486 | the default simplifications to simplify the result and compares again | |
27487 | (and again fails if the formula has simplified back to its original | |
27488 | form). The only special wrinkle for the @code{EvalRules} is that the | |
27489 | same rules will come back into play when the default simplifications | |
27490 | are used. What Calc wants to do is build @samp{f(floor(6))}, see that | |
27491 | this is different from the original formula, simplify to @samp{f(6)}, | |
27492 | see that this is the same as the original formula, and thus halt the | |
27493 | rewriting. But while simplifying, @samp{f(6)} will again trigger | |
27494 | the same @code{EvalRules} rule and Calc will get into a loop inside | |
27495 | the rewrite mechanism itself.) | |
27496 | ||
27497 | The @code{phase}, @code{schedule}, and @code{iterations} markers do | |
27498 | not work in @code{EvalRules}. If the rule set is divided into phases, | |
27499 | only the phase 1 rules are applied, and the schedule is ignored. | |
27500 | The rules are always repeated as many times as possible. | |
27501 | ||
27502 | The @code{EvalRules} are applied to all function calls in a formula, | |
27503 | but not to numbers (and other number-like objects like error forms), | |
27504 | nor to vectors or individual variable names. (Though they will apply | |
27505 | to @emph{components} of vectors and error forms when appropriate.) You | |
27506 | might try to make a variable @code{phihat} which automatically expands | |
27507 | to its definition without the need to press @kbd{=} by writing the | |
27508 | rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule | |
27509 | will not work as part of @code{EvalRules}. | |
27510 | ||
27511 | Finally, another limitation is that Calc sometimes calls its built-in | |
27512 | functions directly rather than going through the default simplifications. | |
27513 | When it does this, @code{EvalRules} will not be able to override those | |
27514 | functions. For example, when you take the absolute value of the complex | |
a4231b04 | 27515 | number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling |
d7b8e6c6 EZ |
27516 | the multiplication, addition, and square root functions directly rather |
27517 | than applying the default simplifications to this formula. So an | |
27518 | @code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6} | |
07ce2eb3 | 27519 | would not apply. (However, if you put Calc into Symbolic mode so that |
d7b8e6c6 EZ |
27520 | @samp{sqrt(13)} will be left in symbolic form by the built-in square |
27521 | root function, your rule will be able to apply. But if the complex | |
a4231b04 | 27522 | number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated, |
07ce2eb3 | 27523 | then Symbolic mode will not help because @samp{sqrt(25)} can be |
d7b8e6c6 EZ |
27524 | evaluated exactly to 5.) |
27525 | ||
27526 | One subtle restriction that normally only manifests itself with | |
27527 | @code{EvalRules} is that while a given rewrite rule is in the process | |
27528 | of being checked, that same rule cannot be recursively applied. Calc | |
27529 | effectively removes the rule from its rule set while checking the rule, | |
27530 | then puts it back once the match succeeds or fails. (The technical | |
27531 | reason for this is that compiled pattern programs are not reentrant.) | |
27532 | For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0} | |
27533 | attempting to match @samp{foo(8)}. This rule will be inactive while | |
27534 | the condition @samp{foo(4) > 0} is checked, even though it might be | |
27535 | an integral part of evaluating that condition. Note that this is not | |
27536 | a problem for the more usual recursive type of rule, such as | |
27537 | @samp{foo(x) := foo(x/2)}, because there the rule has succeeded and | |
27538 | been reactivated by the time the righthand side is evaluated. | |
27539 | ||
27540 | If @code{EvalRules} has no stored value (its default state), or if | |
27541 | anything but a vector is stored in it, then it is ignored. | |
27542 | ||
27543 | Even though Calc's rewrite mechanism is designed to compare rewrite | |
27544 | rules to formulas as quickly as possible, storing rules in | |
27545 | @code{EvalRules} may make Calc run substantially slower. This is | |
27546 | particularly true of rules where the top-level call is a commonly used | |
27547 | function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will | |
27548 | only activate the rewrite mechanism for calls to the function @code{f}, | |
27549 | but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator. | |
5d67986c RS |
27550 | |
27551 | @smallexample | |
27552 | apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10]) | |
27553 | @end smallexample | |
27554 | ||
27555 | @noindent | |
27556 | may seem more ``efficient'' than two separate rules for @code{ln} and | |
27557 | @code{log10}, but actually it is vastly less efficient because rules | |
27558 | with @code{apply} as the top-level pattern must be tested against | |
27559 | @emph{every} function call that is simplified. | |
d7b8e6c6 EZ |
27560 | |
27561 | @cindex @code{AlgSimpRules} variable | |
27562 | @vindex AlgSimpRules | |
27563 | Suppose you want @samp{sin(a + b)} to be expanded out not all the time, | |
27564 | but only when @kbd{a s} is used to simplify the formula. The variable | |
27565 | @code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command | |
27566 | will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as | |
27567 | well as all of its built-in simplifications. | |
27568 | ||
27569 | Most of the special limitations for @code{EvalRules} don't apply to | |
27570 | @code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules} | |
27571 | command with an infinite repeat count as the first step of @kbd{a s}. | |
27572 | It then applies its own built-in simplifications throughout the | |
27573 | formula, and then repeats these two steps (along with applying the | |
27574 | default simplifications) until no further changes are possible. | |
27575 | ||
27576 | @cindex @code{ExtSimpRules} variable | |
27577 | @cindex @code{UnitSimpRules} variable | |
27578 | @vindex ExtSimpRules | |
27579 | @vindex UnitSimpRules | |
27580 | There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables | |
27581 | that are used by @kbd{a e} and @kbd{u s}, respectively; these commands | |
27582 | also apply @code{EvalRules} and @code{AlgSimpRules}. The variable | |
27583 | @code{IntegSimpRules} contains simplification rules that are used | |
27584 | only during integration by @kbd{a i}. | |
27585 | ||
27586 | @node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules | |
27587 | @subsection Debugging Rewrites | |
27588 | ||
27589 | @noindent | |
27590 | If a buffer named @samp{*Trace*} exists, the rewrite mechanism will | |
27591 | record some useful information there as it operates. The original | |
27592 | formula is written there, as is the result of each successful rewrite, | |
27593 | and the final result of the rewriting. All phase changes are also | |
27594 | noted. | |
27595 | ||
27596 | Calc always appends to @samp{*Trace*}. You must empty this buffer | |
27597 | yourself periodically if it is in danger of growing unwieldy. | |
27598 | ||
27599 | Note that the rewriting mechanism is substantially slower when the | |
27600 | @samp{*Trace*} buffer exists, even if the buffer is not visible on | |
27601 | the screen. Once you are done, you will probably want to kill this | |
27602 | buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in | |
27603 | existence and forget about it, all your future rewrite commands will | |
27604 | be needlessly slow. | |
27605 | ||
27606 | @node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules | |
27607 | @subsection Examples of Rewrite Rules | |
27608 | ||
27609 | @noindent | |
27610 | Returning to the example of substituting the pattern | |
27611 | @samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule | |
27612 | @samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of | |
27613 | finding suitable cases. Another solution would be to use the rule | |
27614 | @samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification | |
27615 | if necessary. This rule will be the most effective way to do the job, | |
a4231b04 | 27616 | but at the expense of making some changes that you might not desire. |
d7b8e6c6 EZ |
27617 | |
27618 | Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}. | |
27619 | To make this work with the @w{@kbd{j r}} command so that it can be | |
27620 | easily targeted to a particular exponential in a large formula, | |
27621 | you might wish to write the rule as @samp{select(exp(x+y)) := | |
27622 | select(exp(x) exp(y))}. The @samp{select} markers will be | |
27623 | ignored by the regular @kbd{a r} command | |
a4231b04 | 27624 | (@pxref{Selections with Rewrite Rules}). |
d7b8e6c6 EZ |
27625 | |
27626 | A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}. | |
a4231b04 | 27627 | This will simplify the formula whenever @expr{b} and/or @expr{c} can |
d7b8e6c6 EZ |
27628 | be made simpler by squaring. For example, applying this rule to |
27629 | @samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming | |
07ce2eb3 | 27630 | Symbolic mode has been enabled to keep the square root from being |
28665d46 | 27631 | evaluated to a floating-point approximation). This rule is also |
d7b8e6c6 EZ |
27632 | useful when working with symbolic complex numbers, e.g., |
27633 | @samp{(a + b i) / (c + d i)}. | |
27634 | ||
27635 | As another example, we could define our own ``triangular numbers'' function | |
27636 | with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter | |
27637 | this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given | |
27638 | a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules} | |
27639 | to apply these rules repeatedly. After six applications, @kbd{a r} will | |
27640 | stop with 15 on the stack. Once these rules are debugged, it would probably | |
27641 | be most useful to add them to @code{EvalRules} so that Calc will evaluate | |
27642 | the new @code{tri} function automatically. We could then use @kbd{Z K} on | |
5d67986c | 27643 | the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies |
d7b8e6c6 EZ |
27644 | @code{tri} to the value on the top of the stack. @xref{Programming}. |
27645 | ||
27646 | @cindex Quaternions | |
a4231b04 JB |
27647 | The following rule set, contributed by |
27648 | @texline Fran\c cois | |
27649 | @infoline Francois | |
27650 | Pinard, implements @dfn{quaternions}, a generalization of the concept of | |
27651 | complex numbers. Quaternions have four components, and are here | |
27652 | represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y}, | |
27653 | @var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts | |
27654 | collected into a vector. Various arithmetical operations on quaternions | |
27655 | are supported. To use these rules, either add them to @code{EvalRules}, | |
27656 | or create a command based on @kbd{a r} for simplifying quaternion | |
27657 | formulas. A convenient way to enter quaternions would be a command | |
27658 | defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $]) | |
27659 | @key{RET}}. | |
d7b8e6c6 EZ |
27660 | |
27661 | @smallexample | |
27662 | [ quat(w, x, y, z) := quat(w, [x, y, z]), | |
27663 | quat(w, [0, 0, 0]) := w, | |
27664 | abs(quat(w, v)) := hypot(w, v), | |
27665 | -quat(w, v) := quat(-w, -v), | |
27666 | r + quat(w, v) := quat(r + w, v) :: real(r), | |
27667 | r - quat(w, v) := quat(r - w, -v) :: real(r), | |
27668 | quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2), | |
27669 | r * quat(w, v) := quat(r * w, r * v) :: real(r), | |
27670 | plain(quat(w1, v1) * quat(w2, v2)) | |
27671 | := quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)), | |
27672 | quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r), | |
27673 | z / quat(w, v) := z * quatinv(quat(w, v)), | |
27674 | quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2), | |
27675 | quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v), | |
27676 | quat(w, v)^k := quatsqr(quat(w, v)^(k / 2)) | |
27677 | :: integer(k) :: k > 0 :: k % 2 = 0, | |
27678 | quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v) | |
27679 | :: integer(k) :: k > 2, | |
27680 | quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ] | |
27681 | @end smallexample | |
27682 | ||
27683 | Quaternions, like matrices, have non-commutative multiplication. | |
a4231b04 JB |
27684 | In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if |
27685 | @expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat} | |
d7b8e6c6 EZ |
27686 | rule above uses @code{plain} to prevent Calc from rearranging the |
27687 | product. It may also be wise to add the line @samp{[quat(), matrix]} | |
27688 | to the @code{Decls} matrix, to ensure that Calc's other algebraic | |
27689 | operations will not rearrange a quaternion product. @xref{Declarations}. | |
27690 | ||
27691 | These rules also accept a four-argument @code{quat} form, converting | |
27692 | it to the preferred form in the first rule. If you would rather see | |
27693 | results in the four-argument form, just append the two items | |
27694 | @samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end | |
27695 | of the rule set. (But remember that multi-phase rule sets don't work | |
27696 | in @code{EvalRules}.) | |
27697 | ||
27698 | @node Units, Store and Recall, Algebra, Top | |
27699 | @chapter Operating on Units | |
27700 | ||
27701 | @noindent | |
27702 | One special interpretation of algebraic formulas is as numbers with units. | |
27703 | For example, the formula @samp{5 m / s^2} can be read ``five meters | |
27704 | per second squared.'' The commands in this chapter help you | |
27705 | manipulate units expressions in this form. Units-related commands | |
27706 | begin with the @kbd{u} prefix key. | |
27707 | ||
27708 | @menu | |
27709 | * Basic Operations on Units:: | |
27710 | * The Units Table:: | |
27711 | * Predefined Units:: | |
27712 | * User-Defined Units:: | |
27713 | @end menu | |
27714 | ||
27715 | @node Basic Operations on Units, The Units Table, Units, Units | |
27716 | @section Basic Operations on Units | |
27717 | ||
27718 | @noindent | |
27719 | A @dfn{units expression} is a formula which is basically a number | |
27720 | multiplied and/or divided by one or more @dfn{unit names}, which may | |
27721 | optionally be raised to integer powers. Actually, the value part need not | |
27722 | be a number; any product or quotient involving unit names is a units | |
27723 | expression. Many of the units commands will also accept any formula, | |
27724 | where the command applies to all units expressions which appear in the | |
27725 | formula. | |
27726 | ||
27727 | A unit name is a variable whose name appears in the @dfn{unit table}, | |
27728 | or a variable whose name is a prefix character like @samp{k} (for ``kilo'') | |
27729 | or @samp{u} (for ``micro'') followed by a name in the unit table. | |
27730 | A substantial table of built-in units is provided with Calc; | |
27731 | @pxref{Predefined Units}. You can also define your own unit names; | |
a4231b04 | 27732 | @pxref{User-Defined Units}. |
d7b8e6c6 EZ |
27733 | |
27734 | Note that if the value part of a units expression is exactly @samp{1}, | |
27735 | it will be removed by the Calculator's automatic algebra routines: The | |
27736 | formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a | |
27737 | display anomaly, however; @samp{mm} will work just fine as a | |
a4231b04 | 27738 | representation of one millimeter. |
d7b8e6c6 | 27739 | |
07ce2eb3 | 27740 | You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working |
d7b8e6c6 EZ |
27741 | with units expressions easier. Otherwise, you will have to remember |
27742 | to hit the apostrophe key every time you wish to enter units. | |
27743 | ||
27744 | @kindex u s | |
27745 | @pindex calc-simplify-units | |
5d67986c RS |
27746 | @ignore |
27747 | @mindex usimpl@idots | |
27748 | @end ignore | |
d7b8e6c6 EZ |
27749 | @tindex usimplify |
27750 | The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command | |
27751 | simplifies a units | |
27752 | expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the | |
27753 | expression first as a regular algebraic formula; it then looks for | |
27754 | features that can be further simplified by converting one object's units | |
27755 | to be compatible with another's. For example, @samp{5 m + 23 mm} will | |
27756 | simplify to @samp{5.023 m}. When different but compatible units are | |
27757 | added, the righthand term's units are converted to match those of the | |
27758 | lefthand term. @xref{Simplification Modes}, for a way to have this done | |
a4231b04 | 27759 | automatically at all times. |
d7b8e6c6 EZ |
27760 | |
27761 | Units simplification also handles quotients of two units with the same | |
27762 | dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional | |
27763 | powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and | |
27764 | @samp{sqrt(9 acre)} to a quantity in meters; and @code{floor}, | |
27765 | @code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc}, | |
27766 | @code{float}, @code{frac}, @code{abs}, and @code{clean} | |
27767 | applied to units expressions, in which case | |
27768 | the operation in question is applied only to the numeric part of the | |
27769 | expression. Finally, trigonometric functions of quantities with units | |
a4231b04 | 27770 | of angle are evaluated, regardless of the current angular mode. |
d7b8e6c6 EZ |
27771 | |
27772 | @kindex u c | |
27773 | @pindex calc-convert-units | |
27774 | The @kbd{u c} (@code{calc-convert-units}) command converts a units | |
27775 | expression to new, compatible units. For example, given the units | |
27776 | expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces | |
27777 | @samp{24.5872 m/s}. If the units you request are inconsistent with | |
27778 | the original units, the number will be converted into your units | |
27779 | times whatever ``remainder'' units are left over. For example, | |
27780 | converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}. | |
27781 | (Recall that multiplication binds more strongly than division in Calc | |
27782 | formulas, so the units here are acres per meter-second.) Remainder | |
27783 | units are expressed in terms of ``fundamental'' units like @samp{m} and | |
27784 | @samp{s}, regardless of the input units. | |
27785 | ||
27786 | One special exception is that if you specify a single unit name, and | |
27787 | a compatible unit appears somewhere in the units expression, then | |
27788 | that compatible unit will be converted to the new unit and the | |
27789 | remaining units in the expression will be left alone. For example, | |
27790 | given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will | |
27791 | change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}. | |
27792 | The ``remainder unit'' @samp{cm} is left alone rather than being | |
27793 | changed to the base unit @samp{m}. | |
27794 | ||
27795 | You can use explicit unit conversion instead of the @kbd{u s} command | |
27796 | to gain more control over the units of the result of an expression. | |
27797 | For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or | |
27798 | @kbd{u c mm} to express the result in either meters or millimeters. | |
27799 | (For that matter, you could type @kbd{u c fath} to express the result | |
27800 | in fathoms, if you preferred!) | |
27801 | ||
27802 | In place of a specific set of units, you can also enter one of the | |
27803 | units system names @code{si}, @code{mks} (equivalent), or @code{cgs}. | |
27804 | For example, @kbd{u c si @key{RET}} converts the expression into | |
27805 | International System of Units (SI) base units. Also, @kbd{u c base} | |
27806 | converts to Calc's base units, which are the same as @code{si} units | |
27807 | except that @code{base} uses @samp{g} as the fundamental unit of mass | |
27808 | whereas @code{si} uses @samp{kg}. | |
27809 | ||
27810 | @cindex Composite units | |
27811 | The @kbd{u c} command also accepts @dfn{composite units}, which | |
27812 | are expressed as the sum of several compatible unit names. For | |
27813 | example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles, | |
27814 | feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first | |
27815 | sorts the unit names into order of decreasing relative size. | |
27816 | It then accounts for as much of the input quantity as it can | |
27817 | using an integer number times the largest unit, then moves on | |
27818 | to the next smaller unit, and so on. Only the smallest unit | |
27819 | may have a non-integer amount attached in the result. A few | |
27820 | standard unit names exist for common combinations, such as | |
27821 | @code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}. | |
27822 | Composite units are expanded as if by @kbd{a x}, so that | |
27823 | @samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}. | |
27824 | ||
27825 | If the value on the stack does not contain any units, @kbd{u c} will | |
27826 | prompt first for the old units which this value should be considered | |
27827 | to have, then for the new units. Assuming the old and new units you | |
27828 | give are consistent with each other, the result also will not contain | |
5d67986c | 27829 | any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number |
d7b8e6c6 EZ |
27830 | 2 on the stack to 5.08. |
27831 | ||
27832 | @kindex u b | |
27833 | @pindex calc-base-units | |
27834 | The @kbd{u b} (@code{calc-base-units}) command is shorthand for | |
27835 | @kbd{u c base}; it converts the units expression on the top of the | |
27836 | stack into @code{base} units. If @kbd{u s} does not simplify a | |
27837 | units expression as far as you would like, try @kbd{u b}. | |
27838 | ||
27839 | The @kbd{u c} and @kbd{u b} commands treat temperature units (like | |
27840 | @samp{degC} and @samp{K}) as relative temperatures. For example, | |
27841 | @kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10 | |
27842 | degrees Celsius corresponds to a change of 18 degrees Fahrenheit. | |
27843 | ||
27844 | @kindex u t | |
27845 | @pindex calc-convert-temperature | |
27846 | @cindex Temperature conversion | |
27847 | The @kbd{u t} (@code{calc-convert-temperature}) command converts | |
27848 | absolute temperatures. The value on the stack must be a simple units | |
27849 | expression with units of temperature only. This command would convert | |
27850 | @samp{10 degC} to @samp{50 degF}, the equivalent temperature on the | |
a4231b04 | 27851 | Fahrenheit scale. |
d7b8e6c6 EZ |
27852 | |
27853 | @kindex u r | |
27854 | @pindex calc-remove-units | |
27855 | @kindex u x | |
27856 | @pindex calc-extract-units | |
27857 | The @kbd{u r} (@code{calc-remove-units}) command removes units from the | |
27858 | formula at the top of the stack. The @kbd{u x} | |
27859 | (@code{calc-extract-units}) command extracts only the units portion of a | |
27860 | formula. These commands essentially replace every term of the formula | |
27861 | that does or doesn't (respectively) look like a unit name by the | |
a4231b04 | 27862 | constant 1, then resimplify the formula. |
d7b8e6c6 EZ |
27863 | |
27864 | @kindex u a | |
27865 | @pindex calc-autorange-units | |
27866 | The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a | |
27867 | mode in which unit prefixes like @code{k} (``kilo'') are automatically | |
27868 | applied to keep the numeric part of a units expression in a reasonable | |
27869 | range. This mode affects @kbd{u s} and all units conversion commands | |
27870 | except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz} | |
27871 | will be simplified to @samp{12.345 kHz}. Autoranging is useful for | |
27872 | some kinds of units (like @code{Hz} and @code{m}), but is probably | |
27873 | undesirable for non-metric units like @code{ft} and @code{tbsp}. | |
27874 | (Composite units are more appropriate for those; see above.) | |
27875 | ||
27876 | Autoranging always applies the prefix to the leftmost unit name. | |
27877 | Calc chooses the largest prefix that causes the number to be greater | |
27878 | than or equal to 1.0. Thus an increasing sequence of adjusted times | |
27879 | would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}. | |
27880 | Generally the rule of thumb is that the number will be adjusted | |
27881 | to be in the interval @samp{[1 .. 1000)}, although there are several | |
27882 | exceptions to this rule. First, if the unit has a power then this | |
27883 | is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}. | |
27884 | Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters), | |
27885 | but will not apply to other units. The ``deci-,'' ``deka-,'' and | |
27886 | ``hecto-'' prefixes are never used. Thus the allowable interval is | |
27887 | @samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters. | |
27888 | Finally, a prefix will not be added to a unit if the resulting name | |
27889 | is also the actual name of another unit; @samp{1e-15 t} would normally | |
27890 | be considered a ``femto-ton,'' but it is written as @samp{1000 at} | |
27891 | (1000 atto-tons) instead because @code{ft} would be confused with feet. | |
27892 | ||
27893 | @node The Units Table, Predefined Units, Basic Operations on Units, Units | |
27894 | @section The Units Table | |
27895 | ||
27896 | @noindent | |
27897 | @kindex u v | |
27898 | @pindex calc-enter-units-table | |
27899 | The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table | |
27900 | in another buffer called @code{*Units Table*}. Each entry in this table | |
27901 | gives the unit name as it would appear in an expression, the definition | |
27902 | of the unit in terms of simpler units, and a full name or description of | |
27903 | the unit. Fundamental units are defined as themselves; these are the | |
27904 | units produced by the @kbd{u b} command. The fundamental units are | |
27905 | meters, seconds, grams, kelvins, amperes, candelas, moles, radians, | |
27906 | and steradians. | |
27907 | ||
27908 | The Units Table buffer also displays the Unit Prefix Table. Note that | |
27909 | two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case | |
27910 | prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M} | |
27911 | prefix. Whenever a unit name can be interpreted as either a built-in name | |
27912 | or a prefix followed by another built-in name, the former interpretation | |
27913 | wins. For example, @samp{2 pt} means two pints, not two pico-tons. | |
27914 | ||
27915 | The Units Table buffer, once created, is not rebuilt unless you define | |
27916 | new units. To force the buffer to be rebuilt, give any numeric prefix | |
27917 | argument to @kbd{u v}. | |
27918 | ||
27919 | @kindex u V | |
27920 | @pindex calc-view-units-table | |
27921 | The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except | |
27922 | that the cursor is not moved into the Units Table buffer. You can | |
27923 | type @kbd{u V} again to remove the Units Table from the display. To | |
58547c3e | 27924 | return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c} |
d7b8e6c6 EZ |
27925 | again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window}) |
27926 | command. You can also kill the buffer with @kbd{C-x k} if you wish; | |
27927 | the actual units table is safely stored inside the Calculator. | |
27928 | ||
27929 | @kindex u g | |
27930 | @pindex calc-get-unit-definition | |
27931 | The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's | |
27932 | defining expression and pushes it onto the Calculator stack. For example, | |
27933 | @kbd{u g in} will produce the expression @samp{2.54 cm}. This is the | |
27934 | same definition for the unit that would appear in the Units Table buffer. | |
27935 | Note that this command works only for actual unit names; @kbd{u g km} | |
27936 | will report that no such unit exists, for example, because @code{km} is | |
27937 | really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a | |
27938 | definition of a unit in terms of base units, it is easier to push the | |
27939 | unit name on the stack and then reduce it to base units with @kbd{u b}. | |
27940 | ||
27941 | @kindex u e | |
27942 | @pindex calc-explain-units | |
27943 | The @kbd{u e} (@code{calc-explain-units}) command displays an English | |
27944 | description of the units of the expression on the stack. For example, | |
27945 | for the expression @samp{62 km^2 g / s^2 mol K}, the description is | |
27946 | ``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This | |
27947 | command uses the English descriptions that appear in the righthand | |
27948 | column of the Units Table. | |
27949 | ||
27950 | @node Predefined Units, User-Defined Units, The Units Table, Units | |
27951 | @section Predefined Units | |
27952 | ||
27953 | @noindent | |
27954 | Since the exact definitions of many kinds of units have evolved over the | |
27955 | years, and since certain countries sometimes have local differences in | |
27956 | their definitions, it is a good idea to examine Calc's definition of a | |
27957 | unit before depending on its exact value. For example, there are three | |
27958 | different units for gallons, corresponding to the US (@code{gal}), | |
27959 | Canadian (@code{galC}), and British (@code{galUK}) definitions. Also, | |
27960 | note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy | |
27961 | ounce, and @code{ozfl} is a fluid ounce. | |
27962 | ||
27963 | The temperature units corresponding to degrees Kelvin and Centigrade | |
27964 | (Celsius) are the same in this table, since most units commands treat | |
27965 | temperatures as being relative. The @code{calc-convert-temperature} | |
27966 | command has special rules for handling the different absolute magnitudes | |
27967 | of the various temperature scales. | |
27968 | ||
27969 | The unit of volume ``liters'' can be referred to by either the lower-case | |
27970 | @code{l} or the upper-case @code{L}. | |
27971 | ||
27972 | The unit @code{A} stands for Amperes; the name @code{Ang} is used | |
27973 | @tex | |
27974 | for \AA ngstroms. | |
27975 | @end tex | |
27976 | @ifinfo | |
27977 | for Angstroms. | |
27978 | @end ifinfo | |
27979 | ||
27980 | The unit @code{pt} stands for pints; the name @code{point} stands for | |
5dee9246 JB |
27981 | a typographical point, defined by @samp{72 point = 1 in}. This is |
27982 | slightly different than the point defined by the American Typefounder's | |
27983 | Association in 1886, but the point used by Calc has become standard | |
27984 | largely due to its use by the PostScript page description language. | |
27985 | There is also @code{texpt}, which stands for a printer's point as | |
27986 | defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}. | |
27987 | Other units used by @TeX{} are available; they are @code{texpc} (a pica), | |
27988 | @code{texbp} (a ``big point'', equal to a standard point which is larger | |
27989 | than the point used by @TeX{}), @code{texdd} (a Didot point), | |
27990 | @code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point, | |
27991 | all dimensions representable in @TeX{} are multiples of this value). | |
d7b8e6c6 EZ |
27992 | |
27993 | The unit @code{e} stands for the elementary (electron) unit of charge; | |
27994 | because algebra command could mistake this for the special constant | |
a4231b04 | 27995 | @expr{e}, Calc provides the alternate unit name @code{ech} which is |
d7b8e6c6 EZ |
27996 | preferable to @code{e}. |
27997 | ||
27998 | The name @code{g} stands for one gram of mass; there is also @code{gf}, | |
27999 | one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.) | |
a4231b04 | 28000 | Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}. |
d7b8e6c6 EZ |
28001 | |
28002 | The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is | |
28003 | a metric ton of @samp{1000 kg}. | |
28004 | ||
28005 | The names @code{s} (or @code{sec}) and @code{min} refer to units of | |
28006 | time; @code{arcsec} and @code{arcmin} are units of angle. | |
28007 | ||
28008 | Some ``units'' are really physical constants; for example, @code{c} | |
28009 | represents the speed of light, and @code{h} represents Planck's | |
28010 | constant. You can use these just like other units: converting | |
28011 | @samp{.5 c} to @samp{m/s} expresses one-half the speed of light in | |
28012 | meters per second. You can also use this merely as a handy reference; | |
28013 | the @kbd{u g} command gets the definition of one of these constants | |
28014 | in its normal terms, and @kbd{u b} expresses the definition in base | |
28015 | units. | |
28016 | ||
bd4244cb | 28017 | Two units, @code{pi} and @code{alpha} (the fine structure constant, |
8e04863e | 28018 | approximately @mathit{1/137}) are dimensionless. The units simplification |
d7b8e6c6 EZ |
28019 | commands simply treat these names as equivalent to their corresponding |
28020 | values. However you can, for example, use @kbd{u c} to convert a pure | |
28021 | number into multiples of the fine structure constant, or @kbd{u b} to | |
28022 | convert this back into a pure number. (When @kbd{u c} prompts for the | |
28023 | ``old units,'' just enter a blank line to signify that the value | |
28024 | really is unitless.) | |
28025 | ||
28026 | @c Describe angular units, luminosity vs. steradians problem. | |
28027 | ||
28028 | @node User-Defined Units, , Predefined Units, Units | |
28029 | @section User-Defined Units | |
28030 | ||
28031 | @noindent | |
28032 | Calc provides ways to get quick access to your selected ``favorite'' | |
28033 | units, as well as ways to define your own new units. | |
28034 | ||
28035 | @kindex u 0-9 | |
28036 | @pindex calc-quick-units | |
28037 | @vindex Units | |
28038 | @cindex @code{Units} variable | |
28039 | @cindex Quick units | |
28040 | To select your favorite units, store a vector of unit names or | |
28041 | expressions in the Calc variable @code{Units}. The @kbd{u 1} | |
28042 | through @kbd{u 9} commands (@code{calc-quick-units}) provide access | |
28043 | to these units. If the value on the top of the stack is a plain | |
28044 | number (with no units attached), then @kbd{u 1} gives it the | |
28045 | specified units. (Basically, it multiplies the number by the | |
28046 | first item in the @code{Units} vector.) If the number on the | |
28047 | stack @emph{does} have units, then @kbd{u 1} converts that number | |
28048 | to the new units. For example, suppose the vector @samp{[in, ft]} | |
28049 | is stored in @code{Units}. Then @kbd{30 u 1} will create the | |
28050 | expression @samp{30 in}, and @kbd{u 2} will convert that expression | |
28051 | to @samp{2.5 ft}. | |
28052 | ||
28053 | The @kbd{u 0} command accesses the tenth element of @code{Units}. | |
28054 | Only ten quick units may be defined at a time. If the @code{Units} | |
28055 | variable has no stored value (the default), or if its value is not | |
28056 | a vector, then the quick-units commands will not function. The | |
28057 | @kbd{s U} command is a convenient way to edit the @code{Units} | |
28058 | variable; @pxref{Operations on Variables}. | |
28059 | ||
28060 | @kindex u d | |
28061 | @pindex calc-define-unit | |
28062 | @cindex User-defined units | |
28063 | The @kbd{u d} (@code{calc-define-unit}) command records the units | |
28064 | expression on the top of the stack as the definition for a new, | |
28065 | user-defined unit. For example, putting @samp{16.5 ft} on the stack and | |
28066 | typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to | |
28067 | 16.5 feet. The unit conversion and simplification commands will now | |
28068 | treat @code{rod} just like any other unit of length. You will also be | |
28069 | prompted for an optional English description of the unit, which will | |
28070 | appear in the Units Table. | |
28071 | ||
28072 | @kindex u u | |
28073 | @pindex calc-undefine-unit | |
28074 | The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined | |
28075 | unit. It is not possible to remove one of the predefined units, | |
28076 | however. | |
28077 | ||
28078 | If you define a unit with an existing unit name, your new definition | |
28079 | will replace the original definition of that unit. If the unit was a | |
28080 | predefined unit, the old definition will not be replaced, only | |
28081 | ``shadowed.'' The built-in definition will reappear if you later use | |
28082 | @kbd{u u} to remove the shadowing definition. | |
28083 | ||
28084 | To create a new fundamental unit, use either 1 or the unit name itself | |
28085 | as the defining expression. Otherwise the expression can involve any | |
28086 | other units that you like (except for composite units like @samp{mfi}). | |
28087 | You can create a new composite unit with a sum of other units as the | |
28088 | defining expression. The next unit operation like @kbd{u c} or @kbd{u v} | |
28089 | will rebuild the internal unit table incorporating your modifications. | |
28090 | Note that erroneous definitions (such as two units defined in terms of | |
28091 | each other) will not be detected until the unit table is next rebuilt; | |
28092 | @kbd{u v} is a convenient way to force this to happen. | |
28093 | ||
28094 | Temperature units are treated specially inside the Calculator; it is not | |
28095 | possible to create user-defined temperature units. | |
28096 | ||
28097 | @kindex u p | |
28098 | @pindex calc-permanent-units | |
3b846359 | 28099 | @cindex Calc init file, user-defined units |
d7b8e6c6 | 28100 | The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined |
3b846359 JB |
28101 | units in your Calc init file (the file given by the variable |
28102 | @code{calc-settings-file}, typically @file{~/.calc.el}), so that the | |
28103 | units will still be available in subsequent Emacs sessions. If there | |
28104 | was already a set of user-defined units in your Calc init file, it | |
28105 | is replaced by the new set. (@xref{General Mode Commands}, for a way to | |
28106 | tell Calc to use a different file for the Calc init file.) | |
d7b8e6c6 EZ |
28107 | |
28108 | @node Store and Recall, Graphics, Units, Top | |
28109 | @chapter Storing and Recalling | |
28110 | ||
28111 | @noindent | |
28112 | Calculator variables are really just Lisp variables that contain numbers | |
28113 | or formulas in a form that Calc can understand. The commands in this | |
28114 | section allow you to manipulate variables conveniently. Commands related | |
28115 | to variables use the @kbd{s} prefix key. | |
28116 | ||
28117 | @menu | |
28118 | * Storing Variables:: | |
28119 | * Recalling Variables:: | |
28120 | * Operations on Variables:: | |
28121 | * Let Command:: | |
28122 | * Evaluates-To Operator:: | |
28123 | @end menu | |
28124 | ||
28125 | @node Storing Variables, Recalling Variables, Store and Recall, Store and Recall | |
28126 | @section Storing Variables | |
28127 | ||
28128 | @noindent | |
28129 | @kindex s s | |
28130 | @pindex calc-store | |
28131 | @cindex Storing variables | |
28132 | @cindex Quick variables | |
28133 | @vindex q0 | |
28134 | @vindex q9 | |
28135 | The @kbd{s s} (@code{calc-store}) command stores the value at the top of | |
28136 | the stack into a specified variable. It prompts you to enter the | |
28137 | name of the variable. If you press a single digit, the value is stored | |
4f38ed98 JB |
28138 | immediately in one of the ``quick'' variables @code{q0} through |
28139 | @code{q9}. Or you can enter any variable name. | |
d7b8e6c6 EZ |
28140 | |
28141 | @kindex s t | |
28142 | @pindex calc-store-into | |
28143 | The @kbd{s s} command leaves the stored value on the stack. There is | |
28144 | also an @kbd{s t} (@code{calc-store-into}) command, which removes a | |
28145 | value from the stack and stores it in a variable. | |
28146 | ||
28147 | If the top of stack value is an equation @samp{a = 7} or assignment | |
28148 | @samp{a := 7} with a variable on the lefthand side, then Calc will | |
28149 | assign that variable with that value by default, i.e., if you type | |
28150 | @kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the | |
28151 | value 7 would be stored in the variable @samp{a}. (If you do type | |
28152 | a variable name at the prompt, the top-of-stack value is stored in | |
28153 | its entirety, even if it is an equation: @samp{s s b @key{RET}} | |
28154 | with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.) | |
28155 | ||
28156 | In fact, the top of stack value can be a vector of equations or | |
28157 | assignments with different variables on their lefthand sides; the | |
28158 | default will be to store all the variables with their corresponding | |
28159 | righthand sides simultaneously. | |
28160 | ||
28161 | It is also possible to type an equation or assignment directly at | |
28162 | the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}. | |
28163 | In this case the expression to the right of the @kbd{=} or @kbd{:=} | |
28164 | symbol is evaluated as if by the @kbd{=} command, and that value is | |
28165 | stored in the variable. No value is taken from the stack; @kbd{s s} | |
28166 | and @kbd{s t} are equivalent when used in this way. | |
28167 | ||
28168 | @kindex s 0-9 | |
28169 | @kindex t 0-9 | |
28170 | The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a | |
28171 | digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is | |
28172 | equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used | |
28173 | for trail and time/date commands.) | |
28174 | ||
28175 | @kindex s + | |
28176 | @kindex s - | |
5d67986c RS |
28177 | @ignore |
28178 | @mindex @idots | |
28179 | @end ignore | |
d7b8e6c6 | 28180 | @kindex s * |
5d67986c RS |
28181 | @ignore |
28182 | @mindex @null | |
28183 | @end ignore | |
d7b8e6c6 | 28184 | @kindex s / |
5d67986c RS |
28185 | @ignore |
28186 | @mindex @null | |
28187 | @end ignore | |
d7b8e6c6 | 28188 | @kindex s ^ |
5d67986c RS |
28189 | @ignore |
28190 | @mindex @null | |
28191 | @end ignore | |
d7b8e6c6 | 28192 | @kindex s | |
5d67986c RS |
28193 | @ignore |
28194 | @mindex @null | |
28195 | @end ignore | |
d7b8e6c6 | 28196 | @kindex s n |
5d67986c RS |
28197 | @ignore |
28198 | @mindex @null | |
28199 | @end ignore | |
d7b8e6c6 | 28200 | @kindex s & |
5d67986c RS |
28201 | @ignore |
28202 | @mindex @null | |
28203 | @end ignore | |
d7b8e6c6 | 28204 | @kindex s [ |
5d67986c RS |
28205 | @ignore |
28206 | @mindex @null | |
28207 | @end ignore | |
d7b8e6c6 EZ |
28208 | @kindex s ] |
28209 | @pindex calc-store-plus | |
28210 | @pindex calc-store-minus | |
28211 | @pindex calc-store-times | |
28212 | @pindex calc-store-div | |
28213 | @pindex calc-store-power | |
28214 | @pindex calc-store-concat | |
28215 | @pindex calc-store-neg | |
28216 | @pindex calc-store-inv | |
28217 | @pindex calc-store-decr | |
28218 | @pindex calc-store-incr | |
28219 | There are also several ``arithmetic store'' commands. For example, | |
28220 | @kbd{s +} removes a value from the stack and adds it to the specified | |
28221 | variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /}, | |
28222 | @kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and | |
28223 | @kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}} | |
28224 | and @kbd{s ]} which decrease or increase a variable by one. | |
28225 | ||
28226 | All the arithmetic stores accept the Inverse prefix to reverse the | |
a4231b04 JB |
28227 | order of the operands. If @expr{v} represents the contents of the |
28228 | variable, and @expr{a} is the value drawn from the stack, then regular | |
28229 | @w{@kbd{s -}} assigns | |
8e04863e | 28230 | @texline @math{v \coloneq v - a}, |
a4231b04 JB |
28231 | @infoline @expr{v := v - a}, |
28232 | but @kbd{I s -} assigns | |
8e04863e | 28233 | @texline @math{v \coloneq a - v}. |
a4231b04 JB |
28234 | @infoline @expr{v := a - v}. |
28235 | While @kbd{I s *} might seem pointless, it is | |
d7b8e6c6 EZ |
28236 | useful if matrix multiplication is involved. Actually, all the |
28237 | arithmetic stores use formulas designed to behave usefully both | |
28238 | forwards and backwards: | |
28239 | ||
d7b8e6c6 | 28240 | @example |
5d67986c | 28241 | @group |
d7b8e6c6 EZ |
28242 | s + v := v + a v := a + v |
28243 | s - v := v - a v := a - v | |
28244 | s * v := v * a v := a * v | |
28245 | s / v := v / a v := a / v | |
28246 | s ^ v := v ^ a v := a ^ v | |
28247 | s | v := v | a v := a | v | |
28248 | s n v := v / (-1) v := (-1) / v | |
28249 | s & v := v ^ (-1) v := (-1) ^ v | |
28250 | s [ v := v - 1 v := 1 - v | |
28251 | s ] v := v - (-1) v := (-1) - v | |
d7b8e6c6 | 28252 | @end group |
5d67986c | 28253 | @end example |
d7b8e6c6 EZ |
28254 | |
28255 | In the last four cases, a numeric prefix argument will be used in | |
28256 | place of the number one. (For example, @kbd{M-2 s ]} increases | |
28257 | a variable by 2, and @kbd{M-2 I s ]} replaces a variable by | |
28258 | minus-two minus the variable. | |
28259 | ||
28260 | The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -}, | |
28261 | etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous | |
a4231b04 | 28262 | arithmetic stores that don't remove the value @expr{a} from the stack. |
d7b8e6c6 EZ |
28263 | |
28264 | All arithmetic stores report the new value of the variable in the | |
28265 | Trail for your information. They signal an error if the variable | |
28266 | previously had no stored value. If default simplifications have been | |
28267 | turned off, the arithmetic stores temporarily turn them on for numeric | |
28268 | arguments only (i.e., they temporarily do an @kbd{m N} command). | |
28269 | @xref{Simplification Modes}. Large vectors put in the trail by | |
28270 | these commands always use abbreviated (@kbd{t .}) mode. | |
28271 | ||
28272 | @kindex s m | |
28273 | @pindex calc-store-map | |
28274 | The @kbd{s m} command is a general way to adjust a variable's value | |
28275 | using any Calc function. It is a ``mapping'' command analogous to | |
28276 | @kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see | |
28277 | how to specify a function for a mapping command. Basically, | |
28278 | all you do is type the Calc command key that would invoke that | |
28279 | function normally. For example, @kbd{s m n} applies the @kbd{n} | |
28280 | key to negate the contents of the variable, so @kbd{s m n} is | |
28281 | equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root | |
28282 | of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to | |
28283 | reverse the vector stored in the variable, and @kbd{s m H I S} | |
28284 | takes the hyperbolic arcsine of the variable contents. | |
28285 | ||
28286 | If the mapping function takes two or more arguments, the additional | |
28287 | arguments are taken from the stack; the old value of the variable | |
a4231b04 JB |
28288 | is provided as the first argument. Thus @kbd{s m -} with @expr{a} |
28289 | on the stack computes @expr{v - a}, just like @kbd{s -}. With the | |
d7b8e6c6 EZ |
28290 | Inverse prefix, the variable's original value becomes the @emph{last} |
28291 | argument instead of the first. Thus @kbd{I s m -} is also | |
28292 | equivalent to @kbd{I s -}. | |
28293 | ||
28294 | @kindex s x | |
28295 | @pindex calc-store-exchange | |
28296 | The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value | |
28297 | of a variable with the value on the top of the stack. Naturally, the | |
28298 | variable must already have a stored value for this to work. | |
28299 | ||
28300 | You can type an equation or assignment at the @kbd{s x} prompt. The | |
28301 | command @kbd{s x a=6} takes no values from the stack; instead, it | |
28302 | pushes the old value of @samp{a} on the stack and stores @samp{a = 6}. | |
28303 | ||
28304 | @kindex s u | |
28305 | @pindex calc-unstore | |
28306 | @cindex Void variables | |
28307 | @cindex Un-storing variables | |
c7bb1c63 JB |
28308 | Until you store something in them, most variables are ``void,'' that is, |
28309 | they contain no value at all. If they appear in an algebraic formula | |
28310 | they will be left alone even if you press @kbd{=} (@code{calc-evaluate}). | |
d7b8e6c6 | 28311 | The @kbd{s u} (@code{calc-unstore}) command returns a variable to the |
a4231b04 | 28312 | void state. |
d7b8e6c6 | 28313 | |
6188800e JB |
28314 | @kindex s c |
28315 | @pindex calc-copy-variable | |
28316 | The @kbd{s c} (@code{calc-copy-variable}) command copies the stored | |
28317 | value of one variable to another. One way it differs from a simple | |
28318 | @kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is | |
28319 | that the value never goes on the stack and thus is never rounded, | |
28320 | evaluated, or simplified in any way; it is not even rounded down to the | |
28321 | current precision. | |
28322 | ||
d7b8e6c6 EZ |
28323 | The only variables with predefined values are the ``special constants'' |
28324 | @code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free | |
28325 | to unstore these variables or to store new values into them if you like, | |
28326 | although some of the algebraic-manipulation functions may assume these | |
28327 | variables represent their standard values. Calc displays a warning if | |
28328 | you change the value of one of these variables, or of one of the other | |
28329 | special variables @code{inf}, @code{uinf}, and @code{nan} (which are | |
28330 | normally void). | |
28331 | ||
6188800e JB |
28332 | Note that @code{pi} doesn't actually have 3.14159265359 stored in it, |
28333 | but rather a special magic value that evaluates to @cpi{} at the current | |
28334 | precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate | |
28335 | according to the current precision or polar mode. If you recall a value | |
28336 | from @code{pi} and store it back, this magic property will be lost. The | |
28337 | magic property is preserved, however, when a variable is copied with | |
28338 | @kbd{s c}. | |
28339 | ||
28340 | @kindex s k | |
28341 | @pindex calc-copy-special-constant | |
28342 | If one of the ``special constants'' is redefined (or undefined) so that | |
28343 | it no longer has its magic property, the property can be restored with | |
28344 | @kbd{s k} (@code{calc-copy-special-constant}). This command will prompt | |
28345 | for a special constant and a variable to store it in, and so a special | |
28346 | constant can be stored in any variable. Here, the special constant that | |
28347 | you enter doesn't depend on the value of the corresponding variable; | |
28348 | @code{pi} will represent 3.14159@dots{} regardless of what is currently | |
28349 | stored in the Calc variable @code{pi}. If one of the other special | |
28350 | variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its | |
28351 | original behavior can be restored by voiding it with @kbd{s u}. | |
d7b8e6c6 EZ |
28352 | |
28353 | @node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall | |
28354 | @section Recalling Variables | |
28355 | ||
28356 | @noindent | |
28357 | @kindex s r | |
28358 | @pindex calc-recall | |
28359 | @cindex Recalling variables | |
28360 | The most straightforward way to extract the stored value from a variable | |
28361 | is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts | |
28362 | for a variable name (similarly to @code{calc-store}), looks up the value | |
28363 | of the specified variable, and pushes that value onto the stack. It is | |
28364 | an error to try to recall a void variable. | |
28365 | ||
28366 | It is also possible to recall the value from a variable by evaluating a | |
28367 | formula containing that variable. For example, @kbd{' a @key{RET} =} is | |
28368 | the same as @kbd{s r a @key{RET}} except that if the variable is void, the | |
28369 | former will simply leave the formula @samp{a} on the stack whereas the | |
28370 | latter will produce an error message. | |
28371 | ||
28372 | @kindex r 0-9 | |
28373 | The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is | |
28374 | equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused | |
28375 | in the current version of Calc.) | |
28376 | ||
28377 | @node Operations on Variables, Let Command, Recalling Variables, Store and Recall | |
28378 | @section Other Operations on Variables | |
28379 | ||
28380 | @noindent | |
28381 | @kindex s e | |
28382 | @pindex calc-edit-variable | |
28383 | The @kbd{s e} (@code{calc-edit-variable}) command edits the stored | |
28384 | value of a variable without ever putting that value on the stack | |
28385 | or simplifying or evaluating the value. It prompts for the name of | |
28386 | the variable to edit. If the variable has no stored value, the | |
28387 | editing buffer will start out empty. If the editing buffer is | |
33108698 | 28388 | empty when you press @kbd{C-c C-c} to finish, the variable will |
d7b8e6c6 EZ |
28389 | be made void. @xref{Editing Stack Entries}, for a general |
28390 | description of editing. | |
28391 | ||
28392 | The @kbd{s e} command is especially useful for creating and editing | |
28393 | rewrite rules which are stored in variables. Sometimes these rules | |
28394 | contain formulas which must not be evaluated until the rules are | |
28395 | actually used. (For example, they may refer to @samp{deriv(x,y)}, | |
28396 | where @code{x} will someday become some expression involving @code{y}; | |
28397 | if you let Calc evaluate the rule while you are defining it, Calc will | |
28398 | replace @samp{deriv(x,y)} with 0 because the formula @code{x} does | |
28399 | not itself refer to @code{y}.) By contrast, recalling the variable, | |
28400 | editing with @kbd{`}, and storing will evaluate the variable's value | |
28401 | as a side effect of putting the value on the stack. | |
28402 | ||
28403 | @kindex s A | |
28404 | @kindex s D | |
5d67986c RS |
28405 | @ignore |
28406 | @mindex @idots | |
28407 | @end ignore | |
d7b8e6c6 | 28408 | @kindex s E |
5d67986c RS |
28409 | @ignore |
28410 | @mindex @null | |
28411 | @end ignore | |
d7b8e6c6 | 28412 | @kindex s F |
5d67986c RS |
28413 | @ignore |
28414 | @mindex @null | |
28415 | @end ignore | |
d7b8e6c6 | 28416 | @kindex s G |
5d67986c RS |
28417 | @ignore |
28418 | @mindex @null | |
28419 | @end ignore | |
d7b8e6c6 | 28420 | @kindex s H |
5d67986c RS |
28421 | @ignore |
28422 | @mindex @null | |
28423 | @end ignore | |
d7b8e6c6 | 28424 | @kindex s I |
5d67986c RS |
28425 | @ignore |
28426 | @mindex @null | |
28427 | @end ignore | |
d7b8e6c6 | 28428 | @kindex s L |
5d67986c RS |
28429 | @ignore |
28430 | @mindex @null | |
28431 | @end ignore | |
d7b8e6c6 | 28432 | @kindex s P |
5d67986c RS |
28433 | @ignore |
28434 | @mindex @null | |
28435 | @end ignore | |
d7b8e6c6 | 28436 | @kindex s R |
5d67986c RS |
28437 | @ignore |
28438 | @mindex @null | |
28439 | @end ignore | |
d7b8e6c6 | 28440 | @kindex s T |
5d67986c RS |
28441 | @ignore |
28442 | @mindex @null | |
28443 | @end ignore | |
d7b8e6c6 | 28444 | @kindex s U |
5d67986c RS |
28445 | @ignore |
28446 | @mindex @null | |
28447 | @end ignore | |
d7b8e6c6 EZ |
28448 | @kindex s X |
28449 | @pindex calc-store-AlgSimpRules | |
28450 | @pindex calc-store-Decls | |
28451 | @pindex calc-store-EvalRules | |
28452 | @pindex calc-store-FitRules | |
28453 | @pindex calc-store-GenCount | |
28454 | @pindex calc-store-Holidays | |
28455 | @pindex calc-store-IntegLimit | |
28456 | @pindex calc-store-LineStyles | |
28457 | @pindex calc-store-PointStyles | |
28458 | @pindex calc-store-PlotRejects | |
28459 | @pindex calc-store-TimeZone | |
28460 | @pindex calc-store-Units | |
28461 | @pindex calc-store-ExtSimpRules | |
28462 | There are several special-purpose variable-editing commands that | |
28463 | use the @kbd{s} prefix followed by a shifted letter: | |
28464 | ||
28465 | @table @kbd | |
28466 | @item s A | |
28467 | Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}. | |
28468 | @item s D | |
28469 | Edit @code{Decls}. @xref{Declarations}. | |
28470 | @item s E | |
28471 | Edit @code{EvalRules}. @xref{Default Simplifications}. | |
28472 | @item s F | |
28473 | Edit @code{FitRules}. @xref{Curve Fitting}. | |
28474 | @item s G | |
28475 | Edit @code{GenCount}. @xref{Solving Equations}. | |
28476 | @item s H | |
28477 | Edit @code{Holidays}. @xref{Business Days}. | |
28478 | @item s I | |
28479 | Edit @code{IntegLimit}. @xref{Calculus}. | |
28480 | @item s L | |
28481 | Edit @code{LineStyles}. @xref{Graphics}. | |
28482 | @item s P | |
28483 | Edit @code{PointStyles}. @xref{Graphics}. | |
28484 | @item s R | |
28485 | Edit @code{PlotRejects}. @xref{Graphics}. | |
28486 | @item s T | |
28487 | Edit @code{TimeZone}. @xref{Time Zones}. | |
28488 | @item s U | |
28489 | Edit @code{Units}. @xref{User-Defined Units}. | |
28490 | @item s X | |
28491 | Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}. | |
28492 | @end table | |
28493 | ||
28494 | These commands are just versions of @kbd{s e} that use fixed variable | |
28495 | names rather than prompting for the variable name. | |
28496 | ||
28497 | @kindex s p | |
28498 | @pindex calc-permanent-variable | |
28499 | @cindex Storing variables | |
28500 | @cindex Permanent variables | |
3b846359 | 28501 | @cindex Calc init file, variables |
d7b8e6c6 | 28502 | The @kbd{s p} (@code{calc-permanent-variable}) command saves a |
3b846359 JB |
28503 | variable's value permanently in your Calc init file (the file given by |
28504 | the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so | |
28505 | that its value will still be available in future Emacs sessions. You | |
28506 | can re-execute @w{@kbd{s p}} later on to update the saved value, but the | |
28507 | only way to remove a saved variable is to edit your calc init file | |
d7b8e6c6 | 28508 | by hand. (@xref{General Mode Commands}, for a way to tell Calc to |
3b846359 | 28509 | use a different file for the Calc init file.) |
d7b8e6c6 EZ |
28510 | |
28511 | If you do not specify the name of a variable to save (i.e., | |
4f38ed98 | 28512 | @kbd{s p @key{RET}}), all Calc variables with defined values |
d7b8e6c6 EZ |
28513 | are saved except for the special constants @code{pi}, @code{e}, |
28514 | @code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone} | |
28515 | and @code{PlotRejects}; | |
28516 | @code{FitRules}, @code{DistribRules}, and other built-in rewrite | |
28517 | rules; and @code{PlotData@var{n}} variables generated | |
28518 | by the graphics commands. (You can still save these variables by | |
a4231b04 | 28519 | explicitly naming them in an @kbd{s p} command.) |
d7b8e6c6 EZ |
28520 | |
28521 | @kindex s i | |
28522 | @pindex calc-insert-variables | |
28523 | The @kbd{s i} (@code{calc-insert-variables}) command writes | |
4f38ed98 JB |
28524 | the values of all Calc variables into a specified buffer. |
28525 | The variables are written with the prefix @code{var-} in the form of | |
28526 | Lisp @code{setq} commands | |
d7b8e6c6 | 28527 | which store the values in string form. You can place these commands |
3b846359 | 28528 | in your Calc init file (or @file{.emacs}) if you wish, though in this case it |
d7b8e6c6 EZ |
28529 | would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i} |
28530 | omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference | |
28531 | is that @kbd{s i} will store the variables in any buffer, and it also | |
28532 | stores in a more human-readable format.) | |
28533 | ||
28534 | @node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall | |
28535 | @section The Let Command | |
28536 | ||
28537 | @noindent | |
28538 | @kindex s l | |
28539 | @pindex calc-let | |
28540 | @cindex Variables, temporary assignment | |
28541 | @cindex Temporary assignment to variables | |
28542 | If you have an expression like @samp{a+b^2} on the stack and you wish to | |
a4231b04 | 28543 | compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and |
d7b8e6c6 | 28544 | then press @kbd{=} to reevaluate the formula. This has the side-effect |
a4231b04 | 28545 | of leaving the stored value of 3 in @expr{b} for future operations. |
d7b8e6c6 EZ |
28546 | |
28547 | The @kbd{s l} (@code{calc-let}) command evaluates a formula under a | |
28548 | @emph{temporary} assignment of a variable. It stores the value on the | |
28549 | top of the stack into the specified variable, then evaluates the | |
28550 | second-to-top stack entry, then restores the original value (or lack of one) | |
28551 | in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}}, | |
28552 | the stack will contain the formula @samp{a + 9}. The subsequent command | |
28553 | @kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14. | |
28554 | The variables @samp{a} and @samp{b} are not permanently affected in any way | |
28555 | by these commands. | |
28556 | ||
28557 | The value on the top of the stack may be an equation or assignment, or | |
28558 | a vector of equations or assignments, in which case the default will be | |
28559 | analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}. | |
28560 | ||
28561 | Also, you can answer the variable-name prompt with an equation or | |
5d67986c RS |
28562 | assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack |
28563 | and typing @kbd{s l b @key{RET}}. | |
d7b8e6c6 EZ |
28564 | |
28565 | The @kbd{a b} (@code{calc-substitute}) command is another way to substitute | |
28566 | a variable with a value in a formula. It does an actual substitution | |
28567 | rather than temporarily assigning the variable and evaluating. For | |
a4231b04 | 28568 | example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will |
d7b8e6c6 EZ |
28569 | produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)} |
28570 | since the evaluation step will also evaluate @code{pi}. | |
28571 | ||
28572 | @node Evaluates-To Operator, , Let Command, Store and Recall | |
28573 | @section The Evaluates-To Operator | |
28574 | ||
28575 | @noindent | |
28576 | @tindex evalto | |
28577 | @tindex => | |
28578 | @cindex Evaluates-to operator | |
28579 | @cindex @samp{=>} operator | |
28580 | The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to | |
28581 | operator}. (It will show up as an @code{evalto} function call in | |
053bc283 | 28582 | other language modes like Pascal and La@TeX{}.) This is a binary |
d7b8e6c6 EZ |
28583 | operator, that is, it has a lefthand and a righthand argument, |
28584 | although it can be entered with the righthand argument omitted. | |
28585 | ||
28586 | A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as | |
28587 | follows: First, @var{a} is not simplified or modified in any | |
28588 | way. The previous value of argument @var{b} is thrown away; the | |
28589 | formula @var{a} is then copied and evaluated as if by the @kbd{=} | |
28590 | command according to all current modes and stored variable values, | |
28591 | and the result is installed as the new value of @var{b}. | |
28592 | ||
28593 | For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}. | |
28594 | The number 17 is ignored, and the lefthand argument is left in its | |
28595 | unevaluated form; the result is the formula @samp{2 + 3 => 5}. | |
28596 | ||
28597 | @kindex s = | |
28598 | @pindex calc-evalto | |
28599 | You can enter an @samp{=>} formula either directly using algebraic | |
28600 | entry (in which case the righthand side may be omitted since it is | |
28601 | going to be replaced right away anyhow), or by using the @kbd{s =} | |
28602 | (@code{calc-evalto}) command, which takes @var{a} from the stack | |
28603 | and replaces it with @samp{@var{a} => @var{b}}. | |
28604 | ||
28605 | Calc keeps track of all @samp{=>} operators on the stack, and | |
28606 | recomputes them whenever anything changes that might affect their | |
28607 | values, i.e., a mode setting or variable value. This occurs only | |
28608 | if the @samp{=>} operator is at the top level of the formula, or | |
28609 | if it is part of a top-level vector. In other words, pushing | |
28610 | @samp{2 + (a => 17)} will change the 17 to the actual value of | |
28611 | @samp{a} when you enter the formula, but the result will not be | |
28612 | dynamically updated when @samp{a} is changed later because the | |
28613 | @samp{=>} operator is buried inside a sum. However, a vector | |
28614 | of @samp{=>} operators will be recomputed, since it is convenient | |
28615 | to push a vector like @samp{[a =>, b =>, c =>]} on the stack to | |
28616 | make a concise display of all the variables in your problem. | |
28617 | (Another way to do this would be to use @samp{[a, b, c] =>}, | |
28618 | which provides a slightly different format of display. You | |
28619 | can use whichever you find easiest to read.) | |
28620 | ||
28621 | @kindex m C | |
28622 | @pindex calc-auto-recompute | |
28623 | The @kbd{m C} (@code{calc-auto-recompute}) command allows you to | |
28624 | turn this automatic recomputation on or off. If you turn | |
28625 | recomputation off, you must explicitly recompute an @samp{=>} | |
28626 | operator on the stack in one of the usual ways, such as by | |
28627 | pressing @kbd{=}. Turning recomputation off temporarily can save | |
28628 | a lot of time if you will be changing several modes or variables | |
28629 | before you look at the @samp{=>} entries again. | |
28630 | ||
28631 | Most commands are not especially useful with @samp{=>} operators | |
28632 | as arguments. For example, given @samp{x + 2 => 17}, it won't | |
28633 | work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want | |
28634 | to operate on the lefthand side of the @samp{=>} operator on | |
28635 | the top of the stack, type @kbd{j 1} (that's the digit ``one'') | |
28636 | to select the lefthand side, execute your commands, then type | |
28637 | @kbd{j u} to unselect. | |
28638 | ||
28639 | All current modes apply when an @samp{=>} operator is computed, | |
28640 | including the current simplification mode. Recall that the | |
28641 | formula @samp{x + y + x} is not handled by Calc's default | |
28642 | simplifications, but the @kbd{a s} command will reduce it to | |
28643 | the simpler form @samp{y + 2 x}. You can also type @kbd{m A} | |
07ce2eb3 | 28644 | to enable an Algebraic Simplification mode in which the |
d7b8e6c6 EZ |
28645 | equivalent of @kbd{a s} is used on all of Calc's results. |
28646 | If you enter @samp{x + y + x =>} normally, the result will | |
28647 | be @samp{x + y + x => x + y + x}. If you change to | |
07ce2eb3 | 28648 | Algebraic Simplification mode, the result will be |
d7b8e6c6 EZ |
28649 | @samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s} |
28650 | once will have no effect on @samp{x + y + x => x + y + x}, | |
28651 | because the righthand side depends only on the lefthand side | |
28652 | and the current mode settings, and the lefthand side is not | |
28653 | affected by commands like @kbd{a s}. | |
28654 | ||
28655 | The ``let'' command (@kbd{s l}) has an interesting interaction | |
28656 | with the @samp{=>} operator. The @kbd{s l} command evaluates the | |
28657 | second-to-top stack entry with the top stack entry supplying | |
28658 | a temporary value for a given variable. As you might expect, | |
28659 | if that stack entry is an @samp{=>} operator its righthand | |
28660 | side will temporarily show this value for the variable. In | |
28661 | fact, all @samp{=>}s on the stack will be updated if they refer | |
28662 | to that variable. But this change is temporary in the sense | |
28663 | that the next command that causes Calc to look at those stack | |
28664 | entries will make them revert to the old variable value. | |
28665 | ||
d7b8e6c6 | 28666 | @smallexample |
5d67986c | 28667 | @group |
d7b8e6c6 EZ |
28668 | 2: a => a 2: a => 17 2: a => a |
28669 | 1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1 | |
28670 | . . . | |
28671 | ||
5d67986c | 28672 | 17 s l a @key{RET} p 8 @key{RET} |
d7b8e6c6 | 28673 | @end group |
5d67986c | 28674 | @end smallexample |
d7b8e6c6 EZ |
28675 | |
28676 | Here the @kbd{p 8} command changes the current precision, | |
28677 | thus causing the @samp{=>} forms to be recomputed after the | |
5d67986c | 28678 | influence of the ``let'' is gone. The @kbd{d @key{SPC}} command |
d7b8e6c6 EZ |
28679 | (@code{calc-refresh}) is a handy way to force the @samp{=>} |
28680 | operators on the stack to be recomputed without any other | |
28681 | side effects. | |
28682 | ||
28683 | @kindex s : | |
28684 | @pindex calc-assign | |
28685 | @tindex assign | |
28686 | @tindex := | |
07ce2eb3 | 28687 | Embedded mode also uses @samp{=>} operators. In Embedded mode, |
d7b8e6c6 EZ |
28688 | the lefthand side of an @samp{=>} operator can refer to variables |
28689 | assigned elsewhere in the file by @samp{:=} operators. The | |
28690 | assignment operator @samp{a := 17} does not actually do anything | |
07ce2eb3 | 28691 | by itself. But Embedded mode recognizes it and marks it as a sort |
d7b8e6c6 | 28692 | of file-local definition of the variable. You can enter @samp{:=} |
07ce2eb3 | 28693 | operators in Algebraic mode, or by using the @kbd{s :} |
d7b8e6c6 EZ |
28694 | (@code{calc-assign}) [@code{assign}] command which takes a variable |
28695 | and value from the stack and replaces them with an assignment. | |
28696 | ||
8ed713c6 | 28697 | @xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in |
d7b8e6c6 EZ |
28698 | @TeX{} language output. The @dfn{eqn} mode gives similar |
28699 | treatment to @samp{=>}. | |
28700 | ||
28701 | @node Graphics, Kill and Yank, Store and Recall, Top | |
28702 | @chapter Graphics | |
28703 | ||
28704 | @noindent | |
28705 | The commands for graphing data begin with the @kbd{g} prefix key. Calc | |
5127c216 | 28706 | uses GNUPLOT 2.0 or later to do graphics. These commands will only work |
d7b8e6c6 EZ |
28707 | if GNUPLOT is available on your system. (While GNUPLOT sounds like |
28708 | a relative of GNU Emacs, it is actually completely unrelated. | |
5127c216 JB |
28709 | However, it is free software. It can be obtained from |
28710 | @samp{http://www.gnuplot.info}.) | |
d7b8e6c6 EZ |
28711 | |
28712 | @vindex calc-gnuplot-name | |
28713 | If you have GNUPLOT installed on your system but Calc is unable to | |
28714 | find it, you may need to set the @code{calc-gnuplot-name} variable | |
3b846359 | 28715 | in your Calc init file or @file{.emacs}. You may also need to set some Lisp |
d7b8e6c6 EZ |
28716 | variables to show Calc how to run GNUPLOT on your system; these |
28717 | are described under @kbd{g D} and @kbd{g O} below. If you are | |
28718 | using the X window system, Calc will configure GNUPLOT for you | |
5127c216 | 28719 | automatically. If you have GNUPLOT 3.0 or later and you are not using X, |
d7b8e6c6 EZ |
28720 | Calc will configure GNUPLOT to display graphs using simple character |
28721 | graphics that will work on any terminal. | |
28722 | ||
28723 | @menu | |
28724 | * Basic Graphics:: | |
28725 | * Three Dimensional Graphics:: | |
28726 | * Managing Curves:: | |
28727 | * Graphics Options:: | |
28728 | * Devices:: | |
28729 | @end menu | |
28730 | ||
28731 | @node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics | |
28732 | @section Basic Graphics | |
28733 | ||
28734 | @noindent | |
28735 | @kindex g f | |
28736 | @pindex calc-graph-fast | |
28737 | The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}). | |
28738 | This command takes two vectors of equal length from the stack. | |
28739 | The vector at the top of the stack represents the ``y'' values of | |
28740 | the various data points. The vector in the second-to-top position | |
28741 | represents the corresponding ``x'' values. This command runs | |
28742 | GNUPLOT (if it has not already been started by previous graphing | |
28743 | commands) and displays the set of data points. The points will | |
28744 | be connected by lines, and there will also be some kind of symbol | |
28745 | to indicate the points themselves. | |
28746 | ||
28747 | The ``x'' entry may instead be an interval form, in which case suitable | |
28748 | ``x'' values are interpolated between the minimum and maximum values of | |
28749 | the interval (whether the interval is open or closed is ignored). | |
28750 | ||
28751 | The ``x'' entry may also be a number, in which case Calc uses the | |
a4231b04 JB |
28752 | sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc. |
28753 | (Generally the number 0 or 1 would be used for @expr{x} in this case.) | |
d7b8e6c6 EZ |
28754 | |
28755 | The ``y'' entry may be any formula instead of a vector. Calc effectively | |
28756 | uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula; | |
28757 | the result of this must be a formula in a single (unassigned) variable. | |
28758 | The formula is plotted with this variable taking on the various ``x'' | |
28759 | values. Graphs of formulas by default use lines without symbols at the | |
28760 | computed data points. Note that if neither ``x'' nor ``y'' is a vector, | |
28761 | Calc guesses at a reasonable number of data points to use. See the | |
28762 | @kbd{g N} command below. (The ``x'' values must be either a vector | |
28763 | or an interval if ``y'' is a formula.) | |
28764 | ||
5d67986c RS |
28765 | @ignore |
28766 | @starindex | |
28767 | @end ignore | |
d7b8e6c6 EZ |
28768 | @tindex xy |
28769 | If ``y'' is (or evaluates to) a formula of the form | |
28770 | @samp{xy(@var{x}, @var{y})} then the result is a | |
28771 | parametric plot. The two arguments of the fictitious @code{xy} function | |
28772 | are used as the ``x'' and ``y'' coordinates of the curve, respectively. | |
28773 | In this case the ``x'' vector or interval you specified is not directly | |
28774 | visible in the graph. For example, if ``x'' is the interval @samp{[0..360]} | |
28775 | and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph | |
a4231b04 | 28776 | will be a circle. |
d7b8e6c6 EZ |
28777 | |
28778 | Also, ``x'' and ``y'' may each be variable names, in which case Calc | |
28779 | looks for suitable vectors, intervals, or formulas stored in those | |
28780 | variables. | |
28781 | ||
28782 | The ``x'' and ``y'' values for the data points (as pulled from the vectors, | |
28783 | calculated from the formulas, or interpolated from the intervals) should | |
28784 | be real numbers (integers, fractions, or floats). If either the ``x'' | |
28785 | value or the ``y'' value of a given data point is not a real number, that | |
28786 | data point will be omitted from the graph. The points on either side | |
28787 | of the invalid point will @emph{not} be connected by a line. | |
28788 | ||
28789 | See the documentation for @kbd{g a} below for a description of the way | |
28790 | numeric prefix arguments affect @kbd{g f}. | |
28791 | ||
28792 | @cindex @code{PlotRejects} variable | |
28793 | @vindex PlotRejects | |
28794 | If you store an empty vector in the variable @code{PlotRejects} | |
28795 | (i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to | |
28796 | this vector for every data point which was rejected because its | |
28797 | ``x'' or ``y'' values were not real numbers. The result will be | |
28798 | a matrix where each row holds the curve number, data point number, | |
28799 | ``x'' value, and ``y'' value for a rejected data point. | |
28800 | @xref{Evaluates-To Operator}, for a handy way to keep tabs on the | |
28801 | current value of @code{PlotRejects}. @xref{Operations on Variables}, | |
28802 | for the @kbd{s R} command which is another easy way to examine | |
28803 | @code{PlotRejects}. | |
28804 | ||
28805 | @kindex g c | |
28806 | @pindex calc-graph-clear | |
28807 | To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}). | |
28808 | If the GNUPLOT output device is an X window, the window will go away. | |
28809 | Effects on other kinds of output devices will vary. You don't need | |
28810 | to use @kbd{g c} if you don't want to---if you give another @kbd{g f} | |
28811 | or @kbd{g p} command later on, it will reuse the existing graphics | |
28812 | window if there is one. | |
28813 | ||
28814 | @node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics | |
28815 | @section Three-Dimensional Graphics | |
28816 | ||
28817 | @kindex g F | |
28818 | @pindex calc-graph-fast-3d | |
28819 | The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional | |
28820 | graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0, | |
28821 | you will see a GNUPLOT error message if you try this command. | |
28822 | ||
28823 | The @kbd{g F} command takes three values from the stack, called ``x'', | |
28824 | ``y'', and ``z'', respectively. As was the case for 2D graphs, there | |
28825 | are several options for these values. | |
28826 | ||
28827 | In the first case, ``x'' and ``y'' are each vectors (not necessarily of | |
28828 | the same length); either or both may instead be interval forms. The | |
28829 | ``z'' value must be a matrix with the same number of rows as elements | |
28830 | in ``x'', and the same number of columns as elements in ``y''. The | |
a4231b04 | 28831 | result is a surface plot where |
8e04863e | 28832 | @texline @math{z_{ij}} |
a4231b04 JB |
28833 | @infoline @expr{z_ij} |
28834 | is the height of the point | |
28835 | at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will | |
d7b8e6c6 EZ |
28836 | be displayed from a certain default viewpoint; you can change this |
28837 | viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*} | |
5127c216 | 28838 | buffer as described later. See the GNUPLOT documentation for a |
d7b8e6c6 EZ |
28839 | description of the @samp{set view} command. |
28840 | ||
28841 | Each point in the matrix will be displayed as a dot in the graph, | |
28842 | and these points will be connected by a grid of lines (@dfn{isolines}). | |
28843 | ||
28844 | In the second case, ``x'', ``y'', and ``z'' are all vectors of equal | |
28845 | length. The resulting graph displays a 3D line instead of a surface, | |
28846 | where the coordinates of points along the line are successive triplets | |
28847 | of values from the input vectors. | |
28848 | ||
28849 | In the third case, ``x'' and ``y'' are vectors or interval forms, and | |
28850 | ``z'' is any formula involving two variables (not counting variables | |
28851 | with assigned values). These variables are sorted into alphabetical | |
28852 | order; the first takes on values from ``x'' and the second takes on | |
28853 | values from ``y'' to form a matrix of results that are graphed as a | |
28854 | 3D surface. | |
28855 | ||
5d67986c RS |
28856 | @ignore |
28857 | @starindex | |
28858 | @end ignore | |
d7b8e6c6 EZ |
28859 | @tindex xyz |
28860 | If the ``z'' formula evaluates to a call to the fictitious function | |
28861 | @samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a | |
28862 | ``parametric surface.'' In this case, the axes of the graph are | |
28863 | taken from the @var{x} and @var{y} values in these calls, and the | |
28864 | ``x'' and ``y'' values from the input vectors or intervals are used only | |
28865 | to specify the range of inputs to the formula. For example, plotting | |
28866 | @samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))} | |
28867 | will draw a sphere. (Since the default resolution for 3D plots is | |
28868 | 5 steps in each of ``x'' and ``y'', this will draw a very crude | |
28869 | sphere. You could use the @kbd{g N} command, described below, to | |
28870 | increase this resolution, or specify the ``x'' and ``y'' values as | |
28871 | vectors with more than 5 elements. | |
28872 | ||
28873 | It is also possible to have a function in a regular @kbd{g f} plot | |
28874 | evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not | |
28875 | a surface, the result will be a 3D parametric line. For example, | |
28876 | @samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a | |
28877 | helix (a three-dimensional spiral). | |
28878 | ||
28879 | As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be | |
28880 | variables containing the relevant data. | |
28881 | ||
28882 | @node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics | |
28883 | @section Managing Curves | |
28884 | ||
28885 | @noindent | |
28886 | The @kbd{g f} command is really shorthand for the following commands: | |
28887 | @kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for | |
28888 | @kbd{C-u g d g A g p}. You can gain more control over your graph | |
28889 | by using these commands directly. | |
28890 | ||
28891 | @kindex g a | |
28892 | @pindex calc-graph-add | |
28893 | The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve'' | |
28894 | represented by the two values on the top of the stack to the current | |
28895 | graph. You can have any number of curves in the same graph. When | |
28896 | you give the @kbd{g p} command, all the curves will be drawn superimposed | |
28897 | on the same axes. | |
28898 | ||
28899 | The @kbd{g a} command (and many others that affect the current graph) | |
28900 | will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed | |
28901 | in another window. This buffer is a template of the commands that will | |
28902 | be sent to GNUPLOT when it is time to draw the graph. The first | |
28903 | @kbd{g a} command adds a @code{plot} command to this buffer. Succeeding | |
28904 | @kbd{g a} commands add extra curves onto that @code{plot} command. | |
28905 | Other graph-related commands put other GNUPLOT commands into this | |
28906 | buffer. In normal usage you never need to work with this buffer | |
28907 | directly, but you can if you wish. The only constraint is that there | |
28908 | must be only one @code{plot} command, and it must be the last command | |
28909 | in the buffer. If you want to save and later restore a complete graph | |
28910 | configuration, you can use regular Emacs commands to save and restore | |
28911 | the contents of the @samp{*Gnuplot Commands*} buffer. | |
28912 | ||
28913 | @vindex PlotData1 | |
28914 | @vindex PlotData2 | |
28915 | If the values on the stack are not variable names, @kbd{g a} will invent | |
28916 | variable names for them (of the form @samp{PlotData@var{n}}) and store | |
28917 | the values in those variables. The ``x'' and ``y'' variables are what | |
28918 | go into the @code{plot} command in the template. If you add a curve | |
28919 | that uses a certain variable and then later change that variable, you | |
28920 | can replot the graph without having to delete and re-add the curve. | |
28921 | That's because the variable name, not the vector, interval or formula | |
28922 | itself, is what was added by @kbd{g a}. | |
28923 | ||
28924 | A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way | |
28925 | stack entries are interpreted as curves. With a positive prefix | |
a4231b04 JB |
28926 | argument @expr{n}, the top @expr{n} stack entries are ``y'' values |
28927 | for @expr{n} different curves which share a common ``x'' value in | |
28928 | the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix | |
d7b8e6c6 EZ |
28929 | argument is equivalent to @kbd{C-u 1 g a}.) |
28930 | ||
28931 | A prefix of zero or plain @kbd{C-u} means to take two stack entries, | |
28932 | ``x'' and ``y'' as usual, but to interpret ``y'' as a vector of | |
28933 | ``y'' values for several curves that share a common ``x''. | |
28934 | ||
a4231b04 JB |
28935 | A negative prefix argument tells Calc to read @expr{n} vectors from |
28936 | the stack; each vector @expr{[x, y]} describes an independent curve. | |
d7b8e6c6 EZ |
28937 | This is the only form of @kbd{g a} that creates several curves at once |
28938 | that don't have common ``x'' values. (Of course, the range of ``x'' | |
28939 | values covered by all the curves ought to be roughly the same if | |
28940 | they are to look nice on the same graph.) | |
28941 | ||
a4231b04 | 28942 | For example, to plot |
8e04863e | 28943 | @texline @math{\sin n x} |
a4231b04 JB |
28944 | @infoline @expr{sin(n x)} |
28945 | for integers @expr{n} | |
d7b8e6c6 | 28946 | from 1 to 5, you could use @kbd{v x} to create a vector of integers |
a4231b04 | 28947 | (@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)} |
d7b8e6c6 EZ |
28948 | across this vector. The resulting vector of formulas is suitable |
28949 | for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f} | |
28950 | command. | |
28951 | ||
28952 | @kindex g A | |
28953 | @pindex calc-graph-add-3d | |
28954 | The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve | |
2cbd16b9 | 28955 | to the graph. It is not valid to intermix 2D and 3D curves in a |
d7b8e6c6 | 28956 | single graph. This command takes three arguments, ``x'', ``y'', |
a4231b04 JB |
28957 | and ``z'', from the stack. With a positive prefix @expr{n}, it |
28958 | takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n} | |
d7b8e6c6 EZ |
28959 | separate ``z''s). With a zero prefix, it takes three stack entries |
28960 | but the ``z'' entry is a vector of curve values. With a negative | |
a4231b04 | 28961 | prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}. |
d7b8e6c6 EZ |
28962 | The @kbd{g A} command works by adding a @code{splot} (surface-plot) |
28963 | command to the @samp{*Gnuplot Commands*} buffer. | |
28964 | ||
28965 | (Although @kbd{g a} adds a 2D @code{plot} command to the | |
28966 | @samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot} | |
28967 | before sending it to GNUPLOT if it notices that the data points are | |
28968 | evaluating to @code{xyz} calls. It will not work to mix 2D and 3D | |
28969 | @kbd{g a} curves in a single graph, although Calc does not currently | |
28970 | check for this.) | |
28971 | ||
28972 | @kindex g d | |
28973 | @pindex calc-graph-delete | |
28974 | The @kbd{g d} (@code{calc-graph-delete}) command deletes the most | |
28975 | recently added curve from the graph. It has no effect if there are | |
28976 | no curves in the graph. With a numeric prefix argument of any kind, | |
28977 | it deletes all of the curves from the graph. | |
28978 | ||
28979 | @kindex g H | |
28980 | @pindex calc-graph-hide | |
28981 | The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides'' | |
28982 | the most recently added curve. A hidden curve will not appear in | |
28983 | the actual plot, but information about it such as its name and line and | |
28984 | point styles will be retained. | |
28985 | ||
28986 | @kindex g j | |
28987 | @pindex calc-graph-juggle | |
28988 | The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve | |
28989 | at the end of the list (the ``most recently added curve'') to the | |
28990 | front of the list. The next-most-recent curve is thus exposed for | |
28991 | @w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work | |
28992 | with any curve in the graph even though curve-related commands only | |
28993 | affect the last curve in the list. | |
28994 | ||
28995 | @kindex g p | |
28996 | @pindex calc-graph-plot | |
28997 | The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw | |
28998 | the graph described in the @samp{*Gnuplot Commands*} buffer. Any | |
28999 | GNUPLOT parameters which are not defined by commands in this buffer | |
29000 | are reset to their default values. The variables named in the @code{plot} | |
29001 | command are written to a temporary data file and the variable names | |
29002 | are then replaced by the file name in the template. The resulting | |
29003 | plotting commands are fed to the GNUPLOT program. See the documentation | |
29004 | for the GNUPLOT program for more specific information. All temporary | |
29005 | files are removed when Emacs or GNUPLOT exits. | |
29006 | ||
29007 | If you give a formula for ``y'', Calc will remember all the values that | |
29008 | it calculates for the formula so that later plots can reuse these values. | |
29009 | Calc throws out these saved values when you change any circumstances | |
29010 | that may affect the data, such as switching from Degrees to Radians | |
29011 | mode, or changing the value of a parameter in the formula. You can | |
29012 | force Calc to recompute the data from scratch by giving a negative | |
29013 | numeric prefix argument to @kbd{g p}. | |
29014 | ||
29015 | Calc uses a fairly rough step size when graphing formulas over intervals. | |
29016 | This is to ensure quick response. You can ``refine'' a plot by giving | |
29017 | a positive numeric prefix argument to @kbd{g p}. Calc goes through | |
29018 | the data points it has computed and saved from previous plots of the | |
29019 | function, and computes and inserts a new data point midway between | |
29020 | each of the existing points. You can refine a plot any number of times, | |
29021 | but beware that the amount of calculation involved doubles each time. | |
29022 | ||
29023 | Calc does not remember computed values for 3D graphs. This means the | |
29024 | numerix prefix argument, if any, to @kbd{g p} is effectively ignored if | |
29025 | the current graph is three-dimensional. | |
29026 | ||
29027 | @kindex g P | |
29028 | @pindex calc-graph-print | |
29029 | The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p}, | |
29030 | except that it sends the output to a printer instead of to the | |
29031 | screen. More precisely, @kbd{g p} looks for @samp{set terminal} | |
29032 | or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer; | |
29033 | lacking these it uses the default settings. However, @kbd{g P} | |
29034 | ignores @samp{set terminal} and @samp{set output} commands and | |
29035 | uses a different set of default values. All of these values are | |
29036 | controlled by the @kbd{g D} and @kbd{g O} commands discussed below. | |
29037 | Provided everything is set up properly, @kbd{g p} will plot to | |
29038 | the screen unless you have specified otherwise and @kbd{g P} will | |
29039 | always plot to the printer. | |
29040 | ||
29041 | @node Graphics Options, Devices, Managing Curves, Graphics | |
29042 | @section Graphics Options | |
29043 | ||
29044 | @noindent | |
29045 | @kindex g g | |
29046 | @pindex calc-graph-grid | |
29047 | The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid'' | |
29048 | on and off. It is off by default; tick marks appear only at the | |
29049 | edges of the graph. With the grid turned on, dotted lines appear | |
29050 | across the graph at each tick mark. Note that this command only | |
29051 | changes the setting in @samp{*Gnuplot Commands*}; to see the effects | |
29052 | of the change you must give another @kbd{g p} command. | |
29053 | ||
29054 | @kindex g b | |
29055 | @pindex calc-graph-border | |
29056 | The @kbd{g b} (@code{calc-graph-border}) command turns the border | |
29057 | (the box that surrounds the graph) on and off. It is on by default. | |
29058 | This command will only work with GNUPLOT 3.0 and later versions. | |
29059 | ||
29060 | @kindex g k | |
29061 | @pindex calc-graph-key | |
29062 | The @kbd{g k} (@code{calc-graph-key}) command turns the ``key'' | |
29063 | on and off. The key is a chart in the corner of the graph that | |
29064 | shows the correspondence between curves and line styles. It is | |
29065 | off by default, and is only really useful if you have several | |
29066 | curves on the same graph. | |
29067 | ||
29068 | @kindex g N | |
29069 | @pindex calc-graph-num-points | |
29070 | The @kbd{g N} (@code{calc-graph-num-points}) command allows you | |
29071 | to select the number of data points in the graph. This only affects | |
29072 | curves where neither ``x'' nor ``y'' is specified as a vector. | |
29073 | Enter a blank line to revert to the default value (initially 15). | |
29074 | With no prefix argument, this command affects only the current graph. | |
29075 | With a positive prefix argument this command changes or, if you enter | |
29076 | a blank line, displays the default number of points used for all | |
29077 | graphs created by @kbd{g a} that don't specify the resolution explicitly. | |
29078 | With a negative prefix argument, this command changes or displays | |
29079 | the default value (initially 5) used for 3D graphs created by @kbd{g A}. | |
a4231b04 | 29080 | Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points |
d7b8e6c6 EZ |
29081 | will be computed for the surface. |
29082 | ||
29083 | Data values in the graph of a function are normally computed to a | |
29084 | precision of five digits, regardless of the current precision at the | |
29085 | time. This is usually more than adequate, but there are cases where | |
a4231b04 | 29086 | it will not be. For example, plotting @expr{1 + x} with @expr{x} in the |
d7b8e6c6 EZ |
29087 | interval @samp{[0 ..@: 1e-6]} will round all the data points down |
29088 | to 1.0! Putting the command @samp{set precision @var{n}} in the | |
29089 | @samp{*Gnuplot Commands*} buffer will cause the data to be computed | |
29090 | at precision @var{n} instead of 5. Since this is such a rare case, | |
29091 | there is no keystroke-based command to set the precision. | |
29092 | ||
29093 | @kindex g h | |
29094 | @pindex calc-graph-header | |
29095 | The @kbd{g h} (@code{calc-graph-header}) command sets the title | |
29096 | for the graph. This will show up centered above the graph. | |
29097 | The default title is blank (no title). | |
29098 | ||
29099 | @kindex g n | |
29100 | @pindex calc-graph-name | |
29101 | The @kbd{g n} (@code{calc-graph-name}) command sets the title of an | |
29102 | individual curve. Like the other curve-manipulating commands, it | |
29103 | affects the most recently added curve, i.e., the last curve on the | |
29104 | list in the @samp{*Gnuplot Commands*} buffer. To set the title of | |
29105 | the other curves you must first juggle them to the end of the list | |
29106 | with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand. | |
29107 | Curve titles appear in the key; if the key is turned off they are | |
29108 | not used. | |
29109 | ||
29110 | @kindex g t | |
29111 | @kindex g T | |
29112 | @pindex calc-graph-title-x | |
29113 | @pindex calc-graph-title-y | |
29114 | The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T} | |
29115 | (@code{calc-graph-title-y}) commands set the titles on the ``x'' | |
29116 | and ``y'' axes, respectively. These titles appear next to the | |
29117 | tick marks on the left and bottom edges of the graph, respectively. | |
29118 | Calc does not have commands to control the tick marks themselves, | |
29119 | but you can edit them into the @samp{*Gnuplot Commands*} buffer if | |
29120 | you wish. See the GNUPLOT documentation for details. | |
29121 | ||
29122 | @kindex g r | |
29123 | @kindex g R | |
29124 | @pindex calc-graph-range-x | |
29125 | @pindex calc-graph-range-y | |
29126 | The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R} | |
29127 | (@code{calc-graph-range-y}) commands set the range of values on the | |
29128 | ``x'' and ``y'' axes, respectively. You are prompted to enter a | |
29129 | suitable range. This should be either a pair of numbers of the | |
29130 | form, @samp{@var{min}:@var{max}}, or a blank line to revert to the | |
29131 | default behavior of setting the range based on the range of values | |
29132 | in the data, or @samp{$} to take the range from the top of the stack. | |
29133 | Ranges on the stack can be represented as either interval forms or | |
29134 | vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}. | |
29135 | ||
29136 | @kindex g l | |
29137 | @kindex g L | |
29138 | @pindex calc-graph-log-x | |
29139 | @pindex calc-graph-log-y | |
29140 | The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y}) | |
29141 | commands allow you to set either or both of the axes of the graph to | |
29142 | be logarithmic instead of linear. | |
29143 | ||
29144 | @kindex g C-l | |
29145 | @kindex g C-r | |
29146 | @kindex g C-t | |
29147 | @pindex calc-graph-log-z | |
29148 | @pindex calc-graph-range-z | |
29149 | @pindex calc-graph-title-z | |
29150 | For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are | |
29151 | letters with the Control key held down) are the corresponding commands | |
29152 | for the ``z'' axis. | |
29153 | ||
29154 | @kindex g z | |
29155 | @kindex g Z | |
29156 | @pindex calc-graph-zero-x | |
29157 | @pindex calc-graph-zero-y | |
29158 | The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z} | |
29159 | (@code{calc-graph-zero-y}) commands control whether a dotted line is | |
29160 | drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same | |
29161 | dotted lines that would be drawn there anyway if you used @kbd{g g} to | |
29162 | turn the ``grid'' feature on.) Zero-axis lines are on by default, and | |
29163 | may be turned off only in GNUPLOT 3.0 and later versions. They are | |
29164 | not available for 3D plots. | |
29165 | ||
29166 | @kindex g s | |
29167 | @pindex calc-graph-line-style | |
29168 | The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting | |
29169 | lines on or off for the most recently added curve, and optionally selects | |
29170 | the style of lines to be used for that curve. Plain @kbd{g s} simply | |
29171 | toggles the lines on and off. With a numeric prefix argument, @kbd{g s} | |
29172 | turns lines on and sets a particular line style. Line style numbers | |
29173 | start at one and their meanings vary depending on the output device. | |
29174 | GNUPLOT guarantees that there will be at least six different line styles | |
29175 | available for any device. | |
29176 | ||
29177 | @kindex g S | |
29178 | @pindex calc-graph-point-style | |
29179 | The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns | |
29180 | the symbols at the data points on or off, or sets the point style. | |
29181 | If you turn both lines and points off, the data points will show as | |
29182 | tiny dots. | |
29183 | ||
29184 | @cindex @code{LineStyles} variable | |
29185 | @cindex @code{PointStyles} variable | |
29186 | @vindex LineStyles | |
29187 | @vindex PointStyles | |
29188 | Another way to specify curve styles is with the @code{LineStyles} and | |
29189 | @code{PointStyles} variables. These variables initially have no stored | |
29190 | values, but if you store a vector of integers in one of these variables, | |
29191 | the @kbd{g a} and @kbd{g f} commands will use those style numbers | |
29192 | instead of the defaults for new curves that are added to the graph. | |
29193 | An entry should be a positive integer for a specific style, or 0 to let | |
8e04863e | 29194 | the style be chosen automatically, or @mathit{-1} to turn off lines or points |
d7b8e6c6 EZ |
29195 | altogether. If there are more curves than elements in the vector, the |
29196 | last few curves will continue to have the default styles. Of course, | |
29197 | you can later use @kbd{g s} and @kbd{g S} to change any of these styles. | |
29198 | ||
5d67986c | 29199 | For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve |
d7b8e6c6 EZ |
29200 | to have lines in style number 2, the second curve to have no connecting |
29201 | lines, and the third curve to have lines in style 3. Point styles will | |
29202 | still be assigned automatically, but you could store another vector in | |
29203 | @code{PointStyles} to define them, too. | |
29204 | ||
29205 | @node Devices, , Graphics Options, Graphics | |
29206 | @section Graphical Devices | |
29207 | ||
29208 | @noindent | |
29209 | @kindex g D | |
29210 | @pindex calc-graph-device | |
29211 | The @kbd{g D} (@code{calc-graph-device}) command sets the device name | |
29212 | (or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands | |
29213 | on this graph. It does not affect the permanent default device name. | |
29214 | If you enter a blank name, the device name reverts to the default. | |
29215 | Enter @samp{?} to see a list of supported devices. | |
29216 | ||
29217 | With a positive numeric prefix argument, @kbd{g D} instead sets | |
29218 | the default device name, used by all plots in the future which do | |
29219 | not override it with a plain @kbd{g D} command. If you enter a | |
29220 | blank line this command shows you the current default. The special | |
29221 | name @code{default} signifies that Calc should choose @code{x11} if | |
29222 | the X window system is in use (as indicated by the presence of a | |
29223 | @code{DISPLAY} environment variable), or otherwise @code{dumb} under | |
29224 | GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0. | |
29225 | This is the initial default value. | |
29226 | ||
29227 | The @code{dumb} device is an interface to ``dumb terminals,'' i.e., | |
29228 | terminals with no special graphics facilities. It writes a crude | |
29229 | picture of the graph composed of characters like @code{-} and @code{|} | |
29230 | to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays. | |
29231 | The graph is made the same size as the Emacs screen, which on most | |
a4231b04 | 29232 | dumb terminals will be |
8e04863e | 29233 | @texline @math{80\times24} |
a4231b04 JB |
29234 | @infoline 80x24 |
29235 | characters. The graph is displayed in | |
33108698 | 29236 | an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit |
d7b8e6c6 EZ |
29237 | the recursive edit and return to Calc. Note that the @code{dumb} |
29238 | device is present only in GNUPLOT 3.0 and later versions. | |
29239 | ||
29240 | The word @code{dumb} may be followed by two numbers separated by | |
29241 | spaces. These are the desired width and height of the graph in | |
29242 | characters. Also, the device name @code{big} is like @code{dumb} | |
29243 | but creates a graph four times the width and height of the Emacs | |
29244 | screen. You will then have to scroll around to view the entire | |
29245 | graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL}, | |
29246 | @kbd{<}, and @kbd{>} are defined to scroll by one screenful in each | |
29247 | of the four directions. | |
29248 | ||
29249 | With a negative numeric prefix argument, @kbd{g D} sets or displays | |
29250 | the device name used by @kbd{g P} (@code{calc-graph-print}). This | |
29251 | is initially @code{postscript}. If you don't have a PostScript | |
29252 | printer, you may decide once again to use @code{dumb} to create a | |
29253 | plot on any text-only printer. | |
29254 | ||
29255 | @kindex g O | |
29256 | @pindex calc-graph-output | |
29257 | The @kbd{g O} (@code{calc-graph-output}) command sets the name of | |
29258 | the output file used by GNUPLOT. For some devices, notably @code{x11}, | |
29259 | there is no output file and this information is not used. Many other | |
29260 | ``devices'' are really file formats like @code{postscript}; in these | |
29261 | cases the output in the desired format goes into the file you name | |
5d67986c | 29262 | with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write |
d7b8e6c6 EZ |
29263 | to its standard output stream, i.e., to @samp{*Gnuplot Trail*}. |
29264 | This is the default setting. | |
29265 | ||
29266 | Another special output name is @code{tty}, which means that GNUPLOT | |
29267 | is going to write graphics commands directly to its standard output, | |
29268 | which you wish Emacs to pass through to your terminal. Tektronix | |
29269 | graphics terminals, among other devices, operate this way. Calc does | |
29270 | this by telling GNUPLOT to write to a temporary file, then running a | |
29271 | sub-shell executing the command @samp{cat tempfile >/dev/tty}. On | |
29272 | typical Unix systems, this will copy the temporary file directly to | |
29273 | the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l} | |
29274 | to Emacs afterwards to refresh the screen. | |
29275 | ||
29276 | Once again, @kbd{g O} with a positive or negative prefix argument | |
29277 | sets the default or printer output file names, respectively. In each | |
29278 | case you can specify @code{auto}, which causes Calc to invent a temporary | |
29279 | file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file | |
29280 | will be deleted once it has been displayed or printed. If the output file | |
29281 | name is not @code{auto}, the file is not automatically deleted. | |
29282 | ||
29283 | The default and printer devices and output files can be saved | |
29284 | permanently by the @kbd{m m} (@code{calc-save-modes}) command. The | |
29285 | default number of data points (see @kbd{g N}) and the X geometry | |
29286 | (see @kbd{g X}) are also saved. Other graph information is @emph{not} | |
29287 | saved; you can save a graph's configuration simply by saving the contents | |
29288 | of the @samp{*Gnuplot Commands*} buffer. | |
29289 | ||
29290 | @vindex calc-gnuplot-plot-command | |
29291 | @vindex calc-gnuplot-default-device | |
29292 | @vindex calc-gnuplot-default-output | |
29293 | @vindex calc-gnuplot-print-command | |
29294 | @vindex calc-gnuplot-print-device | |
29295 | @vindex calc-gnuplot-print-output | |
b154df16 | 29296 | You may wish to configure the default and |
d7b8e6c6 EZ |
29297 | printer devices and output files for the whole system. The relevant |
29298 | Lisp variables are @code{calc-gnuplot-default-device} and @code{-output}, | |
29299 | and @code{calc-gnuplot-print-device} and @code{-output}. The output | |
29300 | file names must be either strings as described above, or Lisp | |
29301 | expressions which are evaluated on the fly to get the output file names. | |
29302 | ||
29303 | Other important Lisp variables are @code{calc-gnuplot-plot-command} and | |
29304 | @code{calc-gnuplot-print-command}, which give the system commands to | |
29305 | display or print the output of GNUPLOT, respectively. These may be | |
29306 | @code{nil} if no command is necessary, or strings which can include | |
29307 | @samp{%s} to signify the name of the file to be displayed or printed. | |
29308 | Or, these variables may contain Lisp expressions which are evaluated | |
b154df16 | 29309 | to display or print the output. These variables are customizable |
58547c3e | 29310 | (@pxref{Customizing Calc}). |
d7b8e6c6 EZ |
29311 | |
29312 | @kindex g x | |
29313 | @pindex calc-graph-display | |
29314 | The @kbd{g x} (@code{calc-graph-display}) command lets you specify | |
29315 | on which X window system display your graphs should be drawn. Enter | |
29316 | a blank line to see the current display name. This command has no | |
29317 | effect unless the current device is @code{x11}. | |
29318 | ||
29319 | @kindex g X | |
29320 | @pindex calc-graph-geometry | |
29321 | The @kbd{g X} (@code{calc-graph-geometry}) command is a similar | |
29322 | command for specifying the position and size of the X window. | |
29323 | The normal value is @code{default}, which generally means your | |
29324 | window manager will let you place the window interactively. | |
29325 | Entering @samp{800x500+0+0} would create an 800-by-500 pixel | |
29326 | window in the upper-left corner of the screen. | |
29327 | ||
29328 | The buffer called @samp{*Gnuplot Trail*} holds a transcript of the | |
29329 | session with GNUPLOT. This shows the commands Calc has ``typed'' to | |
29330 | GNUPLOT and the responses it has received. Calc tries to notice when an | |
29331 | error message has appeared here and display the buffer for you when | |
29332 | this happens. You can check this buffer yourself if you suspect | |
29333 | something has gone wrong. | |
29334 | ||
29335 | @kindex g C | |
29336 | @pindex calc-graph-command | |
29337 | The @kbd{g C} (@code{calc-graph-command}) command prompts you to | |
29338 | enter any line of text, then simply sends that line to the current | |
29339 | GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively | |
29340 | like a Shell buffer but you can't type commands in it yourself. | |
29341 | Instead, you must use @kbd{g C} for this purpose. | |
29342 | ||
29343 | @kindex g v | |
29344 | @kindex g V | |
29345 | @pindex calc-graph-view-commands | |
29346 | @pindex calc-graph-view-trail | |
29347 | The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V} | |
29348 | (@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*} | |
29349 | and @samp{*Gnuplot Trail*} buffers, respectively, in another window. | |
29350 | This happens automatically when Calc thinks there is something you | |
29351 | will want to see in either of these buffers. If you type @kbd{g v} | |
29352 | or @kbd{g V} when the relevant buffer is already displayed, the | |
29353 | buffer is hidden again. | |
29354 | ||
29355 | One reason to use @kbd{g v} is to add your own commands to the | |
29356 | @samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use | |
29357 | @kbd{C-x o} to switch into that window. For example, GNUPLOT has | |
29358 | @samp{set label} and @samp{set arrow} commands that allow you to | |
29359 | annotate your plots. Since Calc doesn't understand these commands, | |
29360 | you have to add them to the @samp{*Gnuplot Commands*} buffer | |
29361 | yourself, then use @w{@kbd{g p}} to replot using these new commands. Note | |
29362 | that your commands must appear @emph{before} the @code{plot} command. | |
29363 | To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}. | |
5d67986c | 29364 | You may have to type @kbd{g C @key{RET}} a few times to clear the |
d7b8e6c6 EZ |
29365 | ``press return for more'' or ``subtopic of @dots{}'' requests. |
29366 | Note that Calc always sends commands (like @samp{set nolabel}) to | |
29367 | reset all plotting parameters to the defaults before each plot, so | |
29368 | to delete a label all you need to do is delete the @samp{set label} | |
29369 | line you added (or comment it out with @samp{#}) and then replot | |
29370 | with @kbd{g p}. | |
29371 | ||
29372 | @kindex g q | |
29373 | @pindex calc-graph-quit | |
29374 | You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT | |
29375 | process that is running. The next graphing command you give will | |
29376 | start a fresh GNUPLOT process. The word @samp{Graph} appears in | |
29377 | the Calc window's mode line whenever a GNUPLOT process is currently | |
29378 | running. The GNUPLOT process is automatically killed when you | |
29379 | exit Emacs if you haven't killed it manually by then. | |
29380 | ||
29381 | @kindex g K | |
29382 | @pindex calc-graph-kill | |
29383 | The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q} | |
29384 | except that it also views the @samp{*Gnuplot Trail*} buffer so that | |
29385 | you can see the process being killed. This is better if you are | |
29386 | killing GNUPLOT because you think it has gotten stuck. | |
29387 | ||
29388 | @node Kill and Yank, Keypad Mode, Graphics, Top | |
29389 | @chapter Kill and Yank Functions | |
29390 | ||
29391 | @noindent | |
29392 | The commands in this chapter move information between the Calculator and | |
29393 | other Emacs editing buffers. | |
29394 | ||
07ce2eb3 | 29395 | In many cases Embedded mode is an easier and more natural way to |
d7b8e6c6 EZ |
29396 | work with Calc from a regular editing buffer. @xref{Embedded Mode}. |
29397 | ||
29398 | @menu | |
29399 | * Killing From Stack:: | |
29400 | * Yanking Into Stack:: | |
29401 | * Grabbing From Buffers:: | |
29402 | * Yanking Into Buffers:: | |
29403 | * X Cut and Paste:: | |
29404 | @end menu | |
29405 | ||
29406 | @node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank | |
29407 | @section Killing from the Stack | |
29408 | ||
29409 | @noindent | |
29410 | @kindex C-k | |
29411 | @pindex calc-kill | |
29412 | @kindex M-k | |
29413 | @pindex calc-copy-as-kill | |
29414 | @kindex C-w | |
29415 | @pindex calc-kill-region | |
29416 | @kindex M-w | |
29417 | @pindex calc-copy-region-as-kill | |
29418 | @cindex Kill ring | |
29419 | @dfn{Kill} commands are Emacs commands that insert text into the | |
29420 | ``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y} | |
29421 | command. Three common kill commands in normal Emacs are @kbd{C-k}, which | |
29422 | kills one line, @kbd{C-w}, which kills the region between mark and point, | |
29423 | and @kbd{M-w}, which puts the region into the kill ring without actually | |
29424 | deleting it. All of these commands work in the Calculator, too. Also, | |
29425 | @kbd{M-k} has been provided to complete the set; it puts the current line | |
29426 | into the kill ring without deleting anything. | |
29427 | ||
29428 | The kill commands are unusual in that they pay attention to the location | |
29429 | of the cursor in the Calculator buffer. If the cursor is on or below the | |
29430 | bottom line, the kill commands operate on the top of the stack. Otherwise, | |
29431 | they operate on whatever stack element the cursor is on. Calc's kill | |
29432 | commands always operate on whole stack entries. (They act the same as their | |
29433 | standard Emacs cousins except they ``round up'' the specified region to | |
29434 | encompass full lines.) The text is copied into the kill ring exactly as | |
29435 | it appears on the screen, including line numbers if they are enabled. | |
29436 | ||
29437 | A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number | |
a4231b04 JB |
29438 | of lines killed. A positive argument kills the current line and @expr{n-1} |
29439 | lines below it. A negative argument kills the @expr{-n} lines above the | |
d7b8e6c6 EZ |
29440 | current line. Again this mirrors the behavior of the standard Emacs |
29441 | @kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k} | |
29442 | with no argument copies only the number itself into the kill ring, whereas | |
29443 | @kbd{C-k} with a prefix argument of 1 copies the number with its trailing | |
29444 | newline. | |
29445 | ||
29446 | @node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank | |
29447 | @section Yanking into the Stack | |
29448 | ||
29449 | @noindent | |
29450 | @kindex C-y | |
29451 | @pindex calc-yank | |
29452 | The @kbd{C-y} command yanks the most recently killed text back into the | |
29453 | Calculator. It pushes this value onto the top of the stack regardless of | |
29454 | the cursor position. In general it re-parses the killed text as a number | |
29455 | or formula (or a list of these separated by commas or newlines). However if | |
29456 | the thing being yanked is something that was just killed from the Calculator | |
29457 | itself, its full internal structure is yanked. For example, if you have | |
29458 | set the floating-point display mode to show only four significant digits, | |
29459 | then killing and re-yanking 3.14159 (which displays as 3.142) will yank the | |
29460 | full 3.14159, even though yanking it into any other buffer would yank the | |
29461 | number in its displayed form, 3.142. (Since the default display modes | |
29462 | show all objects to their full precision, this feature normally makes no | |
29463 | difference.) | |
29464 | ||
29465 | @node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank | |
29466 | @section Grabbing from Other Buffers | |
29467 | ||
29468 | @noindent | |
58547c3e | 29469 | @kindex C-x * g |
d7b8e6c6 | 29470 | @pindex calc-grab-region |
58547c3e | 29471 | The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between |
d7b8e6c6 EZ |
29472 | point and mark in the current buffer and attempts to parse it as a |
29473 | vector of values. Basically, it wraps the text in vector brackets | |
29474 | @samp{[ ]} unless the text already is enclosed in vector brackets, | |
29475 | then reads the text as if it were an algebraic entry. The contents | |
29476 | of the vector may be numbers, formulas, or any other Calc objects. | |
58547c3e JB |
29477 | If the @kbd{C-x * g} command works successfully, it does an automatic |
29478 | @kbd{C-x * c} to enter the Calculator buffer. | |
d7b8e6c6 EZ |
29479 | |
29480 | A numeric prefix argument grabs the specified number of lines around | |
29481 | point, ignoring the mark. A positive prefix grabs from point to the | |
58547c3e | 29482 | @expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point |
d7b8e6c6 | 29483 | to the end of the current line); a negative prefix grabs from point |
a4231b04 | 29484 | back to the @expr{n+1}st preceding newline. In these cases the text |
d7b8e6c6 EZ |
29485 | that is grabbed is exactly the same as the text that @kbd{C-k} would |
29486 | delete given that prefix argument. | |
29487 | ||
29488 | A prefix of zero grabs the current line; point may be anywhere on the | |
29489 | line. | |
29490 | ||
29491 | A plain @kbd{C-u} prefix interprets the region between point and mark | |
29492 | as a single number or formula rather than a vector. For example, | |
58547c3e JB |
29493 | @kbd{C-x * g} on the text @samp{2 a b} produces the vector of three |
29494 | values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region | |
d7b8e6c6 EZ |
29495 | reads a formula which is a product of three things: @samp{2 a b}. |
29496 | (The text @samp{a + b}, on the other hand, will be grabbed as a | |
58547c3e | 29497 | vector of one element by plain @kbd{C-x * g} because the interpretation |
d7b8e6c6 EZ |
29498 | @samp{[a, +, b]} would be a syntax error.) |
29499 | ||
29500 | If a different language has been specified (@pxref{Language Modes}), | |
29501 | the grabbed text will be interpreted according to that language. | |
29502 | ||
58547c3e | 29503 | @kindex C-x * r |
d7b8e6c6 | 29504 | @pindex calc-grab-rectangle |
58547c3e | 29505 | The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between |
d7b8e6c6 EZ |
29506 | point and mark and attempts to parse it as a matrix. If point and mark |
29507 | are both in the leftmost column, the lines in between are parsed in their | |
29508 | entirety. Otherwise, point and mark define the corners of a rectangle | |
29509 | whose contents are parsed. | |
29510 | ||
29511 | Each line of the grabbed area becomes a row of the matrix. The result | |
29512 | will actually be a vector of vectors, which Calc will treat as a matrix | |
29513 | only if every row contains the same number of values. | |
29514 | ||
29515 | If a line contains a portion surrounded by square brackets (or curly | |
29516 | braces), that portion is interpreted as a vector which becomes a row | |
29517 | of the matrix. Any text surrounding the bracketed portion on the line | |
29518 | is ignored. | |
29519 | ||
29520 | Otherwise, the entire line is interpreted as a row vector as if it | |
29521 | were surrounded by square brackets. Leading line numbers (in the | |
29522 | format used in the Calc stack buffer) are ignored. If you wish to | |
29523 | force this interpretation (even if the line contains bracketed | |
29524 | portions), give a negative numeric prefix argument to the | |
58547c3e | 29525 | @kbd{C-x * r} command. |
d7b8e6c6 EZ |
29526 | |
29527 | If you give a numeric prefix argument of zero or plain @kbd{C-u}, each | |
29528 | line is instead interpreted as a single formula which is converted into | |
58547c3e | 29529 | a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a |
d7b8e6c6 | 29530 | one-column matrix. For example, suppose one line of the data is the |
58547c3e | 29531 | expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as |
d7b8e6c6 | 29532 | @samp{[2 a]}, which in turn is read as a two-element vector that forms |
58547c3e | 29533 | one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row |
d7b8e6c6 EZ |
29534 | as @samp{[2*a]}. |
29535 | ||
29536 | If you give a positive numeric prefix argument @var{n}, then each line | |
29537 | will be split up into columns of width @var{n}; each column is parsed | |
29538 | separately as a matrix element. If a line contained | |
29539 | @w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8 | |
a4231b04 | 29540 | would correctly split the line into two error forms. |
d7b8e6c6 EZ |
29541 | |
29542 | @xref{Matrix Functions}, to see how to pull the matrix apart into its | |
a4231b04 | 29543 | constituent rows and columns. (If it is a |
8e04863e | 29544 | @texline @math{1\times1} |
a4231b04 JB |
29545 | @infoline 1x1 |
29546 | matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.) | |
d7b8e6c6 | 29547 | |
58547c3e JB |
29548 | @kindex C-x * : |
29549 | @kindex C-x * _ | |
d7b8e6c6 EZ |
29550 | @pindex calc-grab-sum-across |
29551 | @pindex calc-grab-sum-down | |
29552 | @cindex Summing rows and columns of data | |
58547c3e | 29553 | The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to |
d7b8e6c6 | 29554 | grab a rectangle of data and sum its columns. It is equivalent to |
58547c3e | 29555 | typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction |
d7b8e6c6 EZ |
29556 | command that sums the columns of a matrix; @pxref{Reducing}). The |
29557 | result of the command will be a vector of numbers, one for each column | |
58547c3e | 29558 | in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command |
d7b8e6c6 EZ |
29559 | similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}. |
29560 | ||
58547c3e | 29561 | As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also |
d7b8e6c6 | 29562 | much faster because they don't actually place the grabbed vector on |
58547c3e | 29563 | the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector |
d7b8e6c6 EZ |
29564 | for display on the stack takes a large fraction of the total time |
29565 | (unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes). | |
29566 | ||
29567 | For example, suppose we have a column of numbers in a file which we | |
29568 | wish to sum. Go to one corner of the column and press @kbd{C-@@} to | |
58547c3e | 29569 | set the mark; go to the other corner and type @kbd{C-x * :}. Since there |
d7b8e6c6 EZ |
29570 | is only one column, the result will be a vector of one number, the sum. |
29571 | (You can type @kbd{v u} to unpack this vector into a plain number if | |
29572 | you want to do further arithmetic with it.) | |
29573 | ||
29574 | To compute the product of the column of numbers, we would have to do | |
29575 | it ``by hand'' since there's no special grab-and-multiply command. | |
58547c3e | 29576 | Use @kbd{C-x * r} to grab the column of numbers into the calculator in |
d7b8e6c6 EZ |
29577 | the form of a column matrix. The statistics command @kbd{u *} is a |
29578 | handy way to find the product of a vector or matrix of numbers. | |
29579 | @xref{Statistical Operations}. Another approach would be to use | |
29580 | an explicit column reduction command, @kbd{V R : *}. | |
29581 | ||
29582 | @node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank | |
29583 | @section Yanking into Other Buffers | |
29584 | ||
29585 | @noindent | |
29586 | @kindex y | |
29587 | @pindex calc-copy-to-buffer | |
29588 | The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number | |
29589 | at the top of the stack into the most recently used normal editing buffer. | |
29590 | (More specifically, this is the most recently used buffer which is displayed | |
29591 | in a window and whose name does not begin with @samp{*}. If there is no | |
29592 | such buffer, this is the most recently used buffer except for Calculator | |
29593 | and Calc Trail buffers.) The number is inserted exactly as it appears and | |
29594 | without a newline. (If line-numbering is enabled, the line number is | |
29595 | normally not included.) The number is @emph{not} removed from the stack. | |
29596 | ||
29597 | With a prefix argument, @kbd{y} inserts several numbers, one per line. | |
29598 | A positive argument inserts the specified number of values from the top | |
a4231b04 | 29599 | of the stack. A negative argument inserts the @expr{n}th value from the |
d7b8e6c6 EZ |
29600 | top of the stack. An argument of zero inserts the entire stack. Note |
29601 | that @kbd{y} with an argument of 1 is slightly different from @kbd{y} | |
29602 | with no argument; the former always copies full lines, whereas the | |
29603 | latter strips off the trailing newline. | |
29604 | ||
29605 | With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the | |
29606 | region in the other buffer with the yanked text, then quits the | |
29607 | Calculator, leaving you in that buffer. A typical use would be to use | |
58547c3e | 29608 | @kbd{C-x * g} to read a region of data into the Calculator, operate on the |
d7b8e6c6 EZ |
29609 | data to produce a new matrix, then type @kbd{C-u y} to replace the |
29610 | original data with the new data. One might wish to alter the matrix | |
29611 | display style (@pxref{Vector and Matrix Formats}) or change the current | |
29612 | display language (@pxref{Language Modes}) before doing this. Also, note | |
29613 | that this command replaces a linear region of text (as grabbed by | |
58547c3e | 29614 | @kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}). |
d7b8e6c6 EZ |
29615 | |
29616 | If the editing buffer is in overwrite (as opposed to insert) mode, | |
29617 | and the @kbd{C-u} prefix was not used, then the yanked number will | |
29618 | overwrite the characters following point rather than being inserted | |
29619 | before those characters. The usual conventions of overwrite mode | |
29620 | are observed; for example, characters will be inserted at the end of | |
29621 | a line rather than overflowing onto the next line. Yanking a multi-line | |
29622 | object such as a matrix in overwrite mode overwrites the next @var{n} | |
29623 | lines in the buffer, lengthening or shortening each line as necessary. | |
29624 | Finally, if the thing being yanked is a simple integer or floating-point | |
29625 | number (like @samp{-1.2345e-3}) and the characters following point also | |
29626 | make up such a number, then Calc will replace that number with the new | |
29627 | number, lengthening or shortening as necessary. The concept of | |
29628 | ``overwrite mode'' has thus been generalized from overwriting characters | |
29629 | to overwriting one complete number with another. | |
29630 | ||
58547c3e JB |
29631 | @kindex C-x * y |
29632 | The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that | |
d7b8e6c6 EZ |
29633 | it can be typed anywhere, not just in Calc. This provides an easy |
29634 | way to guarantee that Calc knows which editing buffer you want to use! | |
29635 | ||
29636 | @node X Cut and Paste, , Yanking Into Buffers, Kill and Yank | |
29637 | @section X Cut and Paste | |
29638 | ||
29639 | @noindent | |
29640 | If you are using Emacs with the X window system, there is an easier | |
29641 | way to move small amounts of data into and out of the calculator: | |
29642 | Use the mouse-oriented cut and paste facilities of X. | |
29643 | ||
29644 | The default bindings for a three-button mouse cause the left button | |
29645 | to move the Emacs cursor to the given place, the right button to | |
29646 | select the text between the cursor and the clicked location, and | |
29647 | the middle button to yank the selection into the buffer at the | |
29648 | clicked location. So, if you have a Calc window and an editing | |
29649 | window on your Emacs screen, you can use left-click/right-click | |
29650 | to select a number, vector, or formula from one window, then | |
29651 | middle-click to paste that value into the other window. When you | |
29652 | paste text into the Calc window, Calc interprets it as an algebraic | |
29653 | entry. It doesn't matter where you click in the Calc window; the | |
29654 | new value is always pushed onto the top of the stack. | |
29655 | ||
29656 | The @code{xterm} program that is typically used for general-purpose | |
29657 | shell windows in X interprets the mouse buttons in the same way. | |
29658 | So you can use the mouse to move data between Calc and any other | |
29659 | Unix program. One nice feature of @code{xterm} is that a double | |
29660 | left-click selects one word, and a triple left-click selects a | |
29661 | whole line. So you can usually transfer a single number into Calc | |
29662 | just by double-clicking on it in the shell, then middle-clicking | |
29663 | in the Calc window. | |
29664 | ||
17c5c219 | 29665 | @node Keypad Mode, Embedded Mode, Kill and Yank, Top |
07ce2eb3 | 29666 | @chapter Keypad Mode |
d7b8e6c6 EZ |
29667 | |
29668 | @noindent | |
58547c3e | 29669 | @kindex C-x * k |
d7b8e6c6 | 29670 | @pindex calc-keypad |
58547c3e | 29671 | The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator |
d7b8e6c6 EZ |
29672 | and displays a picture of a calculator-style keypad. If you are using |
29673 | the X window system, you can click on any of the ``keys'' in the | |
29674 | keypad using the left mouse button to operate the calculator. | |
07ce2eb3 | 29675 | The original window remains the selected window; in Keypad mode |
d7b8e6c6 EZ |
29676 | you can type in your file while simultaneously performing |
29677 | calculations with the mouse. | |
29678 | ||
29679 | @pindex full-calc-keypad | |
58547c3e | 29680 | If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes |
d7b8e6c6 EZ |
29681 | the @code{full-calc-keypad} command, which takes over the whole |
29682 | Emacs screen and displays the keypad, the Calc stack, and the Calc | |
29683 | trail all at once. This mode would normally be used when running | |
29684 | Calc standalone (@pxref{Standalone Operation}). | |
29685 | ||
29686 | If you aren't using the X window system, you must switch into | |
29687 | the @samp{*Calc Keypad*} window, place the cursor on the desired | |
29688 | ``key,'' and type @key{SPC} or @key{RET}. If you think this | |
29689 | is easier than using Calc normally, go right ahead. | |
29690 | ||
07ce2eb3 | 29691 | Calc commands are more or less the same in Keypad mode. Certain |
d7b8e6c6 EZ |
29692 | keypad keys differ slightly from the corresponding normal Calc |
29693 | keystrokes; all such deviations are described below. | |
29694 | ||
07ce2eb3 | 29695 | Keypad mode includes many more commands than will fit on the keypad |
d7b8e6c6 EZ |
29696 | at once. Click the right mouse button [@code{calc-keypad-menu}] |
29697 | to switch to the next menu. The bottom five rows of the keypad | |
29698 | stay the same; the top three rows change to a new set of commands. | |
29699 | To return to earlier menus, click the middle mouse button | |
29700 | [@code{calc-keypad-menu-back}] or simply advance through the menus | |
29701 | until you wrap around. Typing @key{TAB} inside the keypad window | |
29702 | is equivalent to clicking the right mouse button there. | |
29703 | ||
29704 | You can always click the @key{EXEC} button and type any normal | |
29705 | Calc key sequence. This is equivalent to switching into the | |
29706 | Calc buffer, typing the keys, then switching back to your | |
29707 | original buffer. | |
29708 | ||
29709 | @menu | |
29710 | * Keypad Main Menu:: | |
29711 | * Keypad Functions Menu:: | |
29712 | * Keypad Binary Menu:: | |
29713 | * Keypad Vectors Menu:: | |
29714 | * Keypad Modes Menu:: | |
29715 | @end menu | |
29716 | ||
29717 | @node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode | |
29718 | @section Main Menu | |
29719 | ||
d7b8e6c6 | 29720 | @smallexample |
5d67986c | 29721 | @group |
17c5c219 | 29722 | |----+-----Calc 2.1------+----1 |
d7b8e6c6 EZ |
29723 | |FLR |CEIL|RND |TRNC|CLN2|FLT | |
29724 | |----+----+----+----+----+----| | |
29725 | | LN |EXP | |ABS |IDIV|MOD | | |
29726 | |----+----+----+----+----+----| | |
29727 | |SIN |COS |TAN |SQRT|y^x |1/x | | |
29728 | |----+----+----+----+----+----| | |
29729 | | ENTER |+/- |EEX |UNDO| <- | | |
29730 | |-----+---+-+--+--+-+---++----| | |
29731 | | INV | 7 | 8 | 9 | / | | |
29732 | |-----+-----+-----+-----+-----| | |
29733 | | HYP | 4 | 5 | 6 | * | | |
29734 | |-----+-----+-----+-----+-----| | |
29735 | |EXEC | 1 | 2 | 3 | - | | |
29736 | |-----+-----+-----+-----+-----| | |
29737 | | OFF | 0 | . | PI | + | | |
29738 | |-----+-----+-----+-----+-----+ | |
d7b8e6c6 | 29739 | @end group |
5d67986c | 29740 | @end smallexample |
d7b8e6c6 EZ |
29741 | |
29742 | @noindent | |
07ce2eb3 | 29743 | This is the menu that appears the first time you start Keypad mode. |
d7b8e6c6 EZ |
29744 | It will show up in a vertical window on the right side of your screen. |
29745 | Above this menu is the traditional Calc stack display. On a 24-line | |
29746 | screen you will be able to see the top three stack entries. | |
29747 | ||
29748 | The ten digit keys, decimal point, and @key{EEX} key are used for | |
29749 | entering numbers in the obvious way. @key{EEX} begins entry of an | |
29750 | exponent in scientific notation. Just as with regular Calc, the | |
29751 | number is pushed onto the stack as soon as you press @key{ENTER} | |
29752 | or any other function key. | |
29753 | ||
29754 | The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During | |
29755 | numeric entry it changes the sign of the number or of the exponent. | |
29756 | At other times it changes the sign of the number on the top of the | |
29757 | stack. | |
29758 | ||
29759 | The @key{INV} and @key{HYP} keys modify other keys. As well as | |
07ce2eb3 | 29760 | having the effects described elsewhere in this manual, Keypad mode |
d7b8e6c6 EZ |
29761 | defines several other ``inverse'' operations. These are described |
29762 | below and in the following sections. | |
29763 | ||
29764 | The @key{ENTER} key finishes the current numeric entry, or otherwise | |
29765 | duplicates the top entry on the stack. | |
29766 | ||
29767 | The @key{UNDO} key undoes the most recent Calc operation. | |
29768 | @kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is | |
5d67986c | 29769 | ``last arguments'' (@kbd{M-@key{RET}}). |
d7b8e6c6 EZ |
29770 | |
29771 | The @key{<-} key acts as a ``backspace'' during numeric entry. | |
29772 | At other times it removes the top stack entry. @kbd{INV <-} | |
29773 | clears the entire stack. @kbd{HYP <-} takes an integer from | |
29774 | the stack, then removes that many additional stack elements. | |
29775 | ||
29776 | The @key{EXEC} key prompts you to enter any keystroke sequence | |
29777 | that would normally work in Calc mode. This can include a | |
29778 | numeric prefix if you wish. It is also possible simply to | |
29779 | switch into the Calc window and type commands in it; there is | |
07ce2eb3 | 29780 | nothing ``magic'' about this window when Keypad mode is active. |
d7b8e6c6 EZ |
29781 | |
29782 | The other keys in this display perform their obvious calculator | |
29783 | functions. @key{CLN2} rounds the top-of-stack by temporarily | |
29784 | reducing the precision by 2 digits. @key{FLT} converts an | |
29785 | integer or fraction on the top of the stack to floating-point. | |
29786 | ||
29787 | The @key{INV} and @key{HYP} keys combined with several of these keys | |
29788 | give you access to some common functions even if the appropriate menu | |
29789 | is not displayed. Obviously you don't need to learn these keys | |
29790 | unless you find yourself wasting time switching among the menus. | |
29791 | ||
29792 | @table @kbd | |
29793 | @item INV +/- | |
29794 | is the same as @key{1/x}. | |
29795 | @item INV + | |
29796 | is the same as @key{SQRT}. | |
29797 | @item INV - | |
29798 | is the same as @key{CONJ}. | |
29799 | @item INV * | |
29800 | is the same as @key{y^x}. | |
29801 | @item INV / | |
a4231b04 | 29802 | is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}). |
d7b8e6c6 EZ |
29803 | @item HYP/INV 1 |
29804 | are the same as @key{SIN} / @kbd{INV SIN}. | |
29805 | @item HYP/INV 2 | |
29806 | are the same as @key{COS} / @kbd{INV COS}. | |
29807 | @item HYP/INV 3 | |
29808 | are the same as @key{TAN} / @kbd{INV TAN}. | |
29809 | @item INV/HYP 4 | |
29810 | are the same as @key{LN} / @kbd{HYP LN}. | |
29811 | @item INV/HYP 5 | |
29812 | are the same as @key{EXP} / @kbd{HYP EXP}. | |
29813 | @item INV 6 | |
29814 | is the same as @key{ABS}. | |
29815 | @item INV 7 | |
29816 | is the same as @key{RND} (@code{calc-round}). | |
29817 | @item INV 8 | |
29818 | is the same as @key{CLN2}. | |
29819 | @item INV 9 | |
29820 | is the same as @key{FLT} (@code{calc-float}). | |
29821 | @item INV 0 | |
29822 | is the same as @key{IMAG}. | |
29823 | @item INV . | |
29824 | is the same as @key{PREC}. | |
29825 | @item INV ENTER | |
29826 | is the same as @key{SWAP}. | |
29827 | @item HYP ENTER | |
29828 | is the same as @key{RLL3}. | |
29829 | @item INV HYP ENTER | |
29830 | is the same as @key{OVER}. | |
29831 | @item HYP +/- | |
29832 | packs the top two stack entries as an error form. | |
29833 | @item HYP EEX | |
29834 | packs the top two stack entries as a modulo form. | |
29835 | @item INV EEX | |
29836 | creates an interval form; this removes an integer which is one | |
29837 | of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed | |
29838 | by the two limits of the interval. | |
29839 | @end table | |
29840 | ||
58547c3e | 29841 | The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *} |
d7b8e6c6 | 29842 | again has the same effect. This is analogous to typing @kbd{q} or |
58547c3e | 29843 | hitting @kbd{C-x * c} again in the normal calculator. If Calc is |
d7b8e6c6 EZ |
29844 | running standalone (the @code{full-calc-keypad} command appeared in the |
29845 | command line that started Emacs), then @kbd{OFF} is replaced with | |
29846 | @kbd{EXIT}; clicking on this actually exits Emacs itself. | |
29847 | ||
29848 | @node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode | |
29849 | @section Functions Menu | |
29850 | ||
d7b8e6c6 | 29851 | @smallexample |
5d67986c | 29852 | @group |
d7b8e6c6 EZ |
29853 | |----+----+----+----+----+----2 |
29854 | |IGAM|BETA|IBET|ERF |BESJ|BESY| | |
29855 | |----+----+----+----+----+----| | |
29856 | |IMAG|CONJ| RE |ATN2|RAND|RAGN| | |
29857 | |----+----+----+----+----+----| | |
29858 | |GCD |FACT|DFCT|BNOM|PERM|NXTP| | |
29859 | |----+----+----+----+----+----| | |
d7b8e6c6 | 29860 | @end group |
5d67986c | 29861 | @end smallexample |
d7b8e6c6 EZ |
29862 | |
29863 | @noindent | |
29864 | This menu provides various operations from the @kbd{f} and @kbd{k} | |
29865 | prefix keys. | |
29866 | ||
29867 | @key{IMAG} multiplies the number on the stack by the imaginary | |
a4231b04 | 29868 | number @expr{i = (0, 1)}. |
d7b8e6c6 EZ |
29869 | |
29870 | @key{RE} extracts the real part a complex number. @kbd{INV RE} | |
29871 | extracts the imaginary part. | |
29872 | ||
29873 | @key{RAND} takes a number from the top of the stack and computes | |
29874 | a random number greater than or equal to zero but less than that | |
29875 | number. (@xref{Random Numbers}.) @key{RAGN} is the ``random | |
29876 | again'' command; it computes another random number using the | |
29877 | same limit as last time. | |
29878 | ||
29879 | @key{INV GCD} computes the LCM (least common multiple) function. | |
29880 | ||
a4231b04 | 29881 | @key{INV FACT} is the gamma function. |
8e04863e | 29882 | @texline @math{\Gamma(x) = (x-1)!}. |
a4231b04 | 29883 | @infoline @expr{gamma(x) = (x-1)!}. |
d7b8e6c6 EZ |
29884 | |
29885 | @key{PERM} is the number-of-permutations function, which is on the | |
29886 | @kbd{H k c} key in normal Calc. | |
29887 | ||
29888 | @key{NXTP} finds the next prime after a number. @kbd{INV NXTP} | |
29889 | finds the previous prime. | |
29890 | ||
29891 | @node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode | |
29892 | @section Binary Menu | |
29893 | ||
d7b8e6c6 | 29894 | @smallexample |
5d67986c | 29895 | @group |
d7b8e6c6 EZ |
29896 | |----+----+----+----+----+----3 |
29897 | |AND | OR |XOR |NOT |LSH |RSH | | |
29898 | |----+----+----+----+----+----| | |
29899 | |DEC |HEX |OCT |BIN |WSIZ|ARSH| | |
29900 | |----+----+----+----+----+----| | |
29901 | | A | B | C | D | E | F | | |
29902 | |----+----+----+----+----+----| | |
d7b8e6c6 | 29903 | @end group |
5d67986c | 29904 | @end smallexample |
d7b8e6c6 EZ |
29905 | |
29906 | @noindent | |
29907 | The keys in this menu perform operations on binary integers. | |
29908 | Note that both logical and arithmetic right-shifts are provided. | |
29909 | @key{INV LSH} rotates one bit to the left. | |
29910 | ||
29911 | The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}. | |
29912 | The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}. | |
29913 | ||
29914 | The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the | |
29915 | current radix for display and entry of numbers: Decimal, hexadecimal, | |
29916 | octal, or binary. The six letter keys @key{A} through @key{F} are used | |
29917 | for entering hexadecimal numbers. | |
29918 | ||
29919 | The @key{WSIZ} key displays the current word size for binary operations | |
29920 | and allows you to enter a new word size. You can respond to the prompt | |
29921 | using either the keyboard or the digits and @key{ENTER} from the keypad. | |
29922 | The initial word size is 32 bits. | |
29923 | ||
29924 | @node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode | |
29925 | @section Vectors Menu | |
29926 | ||
d7b8e6c6 | 29927 | @smallexample |
5d67986c | 29928 | @group |
d7b8e6c6 EZ |
29929 | |----+----+----+----+----+----4 |
29930 | |SUM |PROD|MAX |MAP*|MAP^|MAP$| | |
29931 | |----+----+----+----+----+----| | |
29932 | |MINV|MDET|MTRN|IDNT|CRSS|"x" | | |
29933 | |----+----+----+----+----+----| | |
29934 | |PACK|UNPK|INDX|BLD |LEN |... | | |
29935 | |----+----+----+----+----+----| | |
d7b8e6c6 | 29936 | @end group |
5d67986c | 29937 | @end smallexample |
d7b8e6c6 EZ |
29938 | |
29939 | @noindent | |
29940 | The keys in this menu operate on vectors and matrices. | |
29941 | ||
29942 | @key{PACK} removes an integer @var{n} from the top of the stack; | |
29943 | the next @var{n} stack elements are removed and packed into a vector, | |
29944 | which is replaced onto the stack. Thus the sequence | |
29945 | @kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector | |
29946 | @samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row | |
29947 | on the stack as a vector, then use a final @key{PACK} to collect the | |
29948 | rows into a matrix. | |
29949 | ||
29950 | @key{UNPK} unpacks the vector on the stack, pushing each of its | |
29951 | components separately. | |
29952 | ||
29953 | @key{INDX} removes an integer @var{n}, then builds a vector of | |
29954 | integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers | |
29955 | from the stack: The vector size @var{n}, the starting number, | |
29956 | and the increment. @kbd{BLD} takes an integer @var{n} and any | |
29957 | value @var{x} and builds a vector of @var{n} copies of @var{x}. | |
29958 | ||
29959 | @key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n} | |
29960 | identity matrix. | |
29961 | ||
29962 | @key{LEN} replaces a vector by its length, an integer. | |
29963 | ||
29964 | @key{...} turns on or off ``abbreviated'' display mode for large vectors. | |
29965 | ||
29966 | @key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix | |
29967 | inverse, determinant, and transpose, and vector cross product. | |
29968 | ||
29969 | @key{SUM} replaces a vector by the sum of its elements. It is | |
29970 | equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}). | |
29971 | @key{PROD} computes the product of the elements of a vector, and | |
29972 | @key{MAX} computes the maximum of all the elements of a vector. | |
29973 | ||
29974 | @key{INV SUM} computes the alternating sum of the first element | |
29975 | minus the second, plus the third, minus the fourth, and so on. | |
29976 | @key{INV MAX} computes the minimum of the vector elements. | |
29977 | ||
29978 | @key{HYP SUM} computes the mean of the vector elements. | |
29979 | @key{HYP PROD} computes the sample standard deviation. | |
29980 | @key{HYP MAX} computes the median. | |
29981 | ||
29982 | @key{MAP*} multiplies two vectors elementwise. It is equivalent | |
29983 | to the @kbd{V M *} command. @key{MAP^} computes powers elementwise. | |
29984 | The arguments must be vectors of equal length, or one must be a vector | |
29985 | and the other must be a plain number. For example, @kbd{2 MAP^} squares | |
29986 | all the elements of a vector. | |
29987 | ||
29988 | @key{MAP$} maps the formula on the top of the stack across the | |
29989 | vector in the second-to-top position. If the formula contains | |
29990 | several variables, Calc takes that many vectors starting at the | |
29991 | second-to-top position and matches them to the variables in | |
29992 | alphabetical order. The result is a vector of the same size as | |
29993 | the input vectors, whose elements are the formula evaluated with | |
29994 | the variables set to the various sets of numbers in those vectors. | |
29995 | For example, you could simulate @key{MAP^} using @key{MAP$} with | |
29996 | the formula @samp{x^y}. | |
29997 | ||
a4231b04 JB |
29998 | The @kbd{"x"} key pushes the variable name @expr{x} onto the |
29999 | stack. To build the formula @expr{x^2 + 6}, you would use the | |
d7b8e6c6 EZ |
30000 | key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be |
30001 | suitable for use with the @key{MAP$} key described above. | |
30002 | With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the | |
a4231b04 JB |
30003 | @kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and |
30004 | @expr{t}, respectively. | |
d7b8e6c6 EZ |
30005 | |
30006 | @node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode | |
30007 | @section Modes Menu | |
30008 | ||
d7b8e6c6 | 30009 | @smallexample |
5d67986c | 30010 | @group |
d7b8e6c6 EZ |
30011 | |----+----+----+----+----+----5 |
30012 | |FLT |FIX |SCI |ENG |GRP | | | |
30013 | |----+----+----+----+----+----| | |
30014 | |RAD |DEG |FRAC|POLR|SYMB|PREC| | |
30015 | |----+----+----+----+----+----| | |
30016 | |SWAP|RLL3|RLL4|OVER|STO |RCL | | |
30017 | |----+----+----+----+----+----| | |
d7b8e6c6 | 30018 | @end group |
5d67986c | 30019 | @end smallexample |
d7b8e6c6 EZ |
30020 | |
30021 | @noindent | |
30022 | The keys in this menu manipulate modes, variables, and the stack. | |
30023 | ||
30024 | The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select | |
30025 | floating-point, fixed-point, scientific, or engineering notation. | |
30026 | @key{FIX} displays two digits after the decimal by default; the | |
30027 | others display full precision. With the @key{INV} prefix, these | |
30028 | keys pop a number-of-digits argument from the stack. | |
30029 | ||
30030 | The @key{GRP} key turns grouping of digits with commas on or off. | |
30031 | @kbd{INV GRP} enables grouping to the right of the decimal point as | |
30032 | well as to the left. | |
30033 | ||
30034 | The @key{RAD} and @key{DEG} keys switch between radians and degrees | |
30035 | for trigonometric functions. | |
30036 | ||
30037 | The @key{FRAC} key turns Fraction mode on or off. This affects | |
30038 | whether commands like @kbd{/} with integer arguments produce | |
30039 | fractional or floating-point results. | |
30040 | ||
30041 | The @key{POLR} key turns Polar mode on or off, determining whether | |
30042 | polar or rectangular complex numbers are used by default. | |
30043 | ||
30044 | The @key{SYMB} key turns Symbolic mode on or off, in which | |
30045 | operations that would produce inexact floating-point results | |
30046 | are left unevaluated as algebraic formulas. | |
30047 | ||
30048 | The @key{PREC} key selects the current precision. Answer with | |
30049 | the keyboard or with the keypad digit and @key{ENTER} keys. | |
30050 | ||
30051 | The @key{SWAP} key exchanges the top two stack elements. | |
30052 | The @key{RLL3} key rotates the top three stack elements upwards. | |
30053 | The @key{RLL4} key rotates the top four stack elements upwards. | |
30054 | The @key{OVER} key duplicates the second-to-top stack element. | |
30055 | ||
30056 | The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and | |
30057 | @kbd{s r} in regular Calc. @xref{Store and Recall}. Click the | |
30058 | @key{STO} or @key{RCL} key, then one of the ten digits. (Named | |
07ce2eb3 | 30059 | variables are not available in Keypad mode.) You can also use, |
d7b8e6c6 EZ |
30060 | for example, @kbd{STO + 3} to add to register 3. |
30061 | ||
30062 | @node Embedded Mode, Programming, Keypad Mode, Top | |
30063 | @chapter Embedded Mode | |
30064 | ||
30065 | @noindent | |
07ce2eb3 | 30066 | Embedded mode in Calc provides an alternative to copying numbers |
d7b8e6c6 | 30067 | and formulas back and forth between editing buffers and the Calc |
07ce2eb3 | 30068 | stack. In Embedded mode, your editing buffer becomes temporarily |
d7b8e6c6 EZ |
30069 | linked to the stack and this copying is taken care of automatically. |
30070 | ||
30071 | @menu | |
30072 | * Basic Embedded Mode:: | |
30073 | * More About Embedded Mode:: | |
30074 | * Assignments in Embedded Mode:: | |
30075 | * Mode Settings in Embedded Mode:: | |
30076 | * Customizing Embedded Mode:: | |
30077 | @end menu | |
30078 | ||
30079 | @node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode | |
30080 | @section Basic Embedded Mode | |
30081 | ||
30082 | @noindent | |
58547c3e | 30083 | @kindex C-x * e |
d7b8e6c6 EZ |
30084 | @pindex calc-embedded |
30085 | To enter Embedded mode, position the Emacs point (cursor) on a | |
58547c3e JB |
30086 | formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}). |
30087 | Note that @kbd{C-x * e} is not to be used in the Calc stack buffer | |
d7b8e6c6 EZ |
30088 | like most Calc commands, but rather in regular editing buffers that |
30089 | are visiting your own files. | |
30090 | ||
1dddb589 JB |
30091 | Calc will try to guess an appropriate language based on the major mode |
30092 | of the editing buffer. (@xref{Language Modes}.) If the current buffer is | |
30093 | in @code{latex-mode}, for example, Calc will set its language to La@TeX{}. | |
30094 | Similarly, Calc will use @TeX{} language for @code{tex-mode}, | |
30095 | @code{plain-tex-mode} and @code{context-mode}, C language for | |
30096 | @code{c-mode} and @code{c++-mode}, FORTRAN language for | |
30097 | @code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode}, | |
58547c3e | 30098 | and eqn for @code{nroff-mode} (@pxref{Customizing Calc}). |
b154df16 | 30099 | These can be overridden with Calc's mode |
1dddb589 JB |
30100 | changing commands (@pxref{Mode Settings in Embedded Mode}). If no |
30101 | suitable language is available, Calc will continue with its current language. | |
30102 | ||
d7b8e6c6 EZ |
30103 | Calc normally scans backward and forward in the buffer for the |
30104 | nearest opening and closing @dfn{formula delimiters}. The simplest | |
07ce2eb3 | 30105 | delimiters are blank lines. Other delimiters that Embedded mode |
d7b8e6c6 EZ |
30106 | understands are: |
30107 | ||
30108 | @enumerate | |
30109 | @item | |
30110 | The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$}, | |
30111 | @samp{\[ \]}, and @samp{\( \)}; | |
30112 | @item | |
8ed713c6 | 30113 | Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters); |
d7b8e6c6 EZ |
30114 | @item |
30115 | Lines beginning with @samp{@@} (Texinfo delimiters). | |
30116 | @item | |
30117 | Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters); | |
30118 | @item | |
30119 | Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else. | |
30120 | @end enumerate | |
30121 | ||
30122 | @xref{Customizing Embedded Mode}, to see how to make Calc recognize | |
30123 | your own favorite delimiters. Delimiters like @samp{$ $} can appear | |
30124 | on their own separate lines or in-line with the formula. | |
30125 | ||
30126 | If you give a positive or negative numeric prefix argument, Calc | |
f16fc7f9 JB |
30127 | instead uses the current point as one end of the formula, and includes |
30128 | that many lines forward or backward (respectively, including the current | |
30129 | line). Explicit delimiters are not necessary in this case. | |
d7b8e6c6 | 30130 | |
2be7b183 JB |
30131 | With a prefix argument of zero, Calc uses the current region (delimited |
30132 | by point and mark) instead of formula delimiters. With a prefix | |
30133 | argument of @kbd{C-u} only, Calc uses the current line as the formula. | |
d7b8e6c6 | 30134 | |
58547c3e | 30135 | @kindex C-x * w |
d7b8e6c6 | 30136 | @pindex calc-embedded-word |
58547c3e | 30137 | The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded |
2be7b183 JB |
30138 | mode on the current ``word''; in this case Calc will scan for the first |
30139 | non-numeric character (i.e., the first character that is not a digit, | |
30140 | sign, decimal point, or upper- or lower-case @samp{e}) forward and | |
30141 | backward to delimit the formula. | |
d7b8e6c6 EZ |
30142 | |
30143 | When you enable Embedded mode for a formula, Calc reads the text | |
30144 | between the delimiters and tries to interpret it as a Calc formula. | |
1dddb589 | 30145 | Calc can generally identify @TeX{} formulas and |
d7b8e6c6 EZ |
30146 | Big-style formulas even if the language mode is wrong. If Calc |
30147 | can't make sense of the formula, it beeps and refuses to enter | |
30148 | Embedded mode. But if the current language is wrong, Calc can | |
30149 | sometimes parse the formula successfully (but incorrectly); | |
30150 | for example, the C expression @samp{atan(a[1])} can be parsed | |
30151 | in Normal language mode, but the @code{atan} won't correspond to | |
30152 | the built-in @code{arctan} function, and the @samp{a[1]} will be | |
30153 | interpreted as @samp{a} times the vector @samp{[1]}! | |
30154 | ||
58547c3e | 30155 | If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded |
d7b8e6c6 EZ |
30156 | formula which is blank, say with the cursor on the space between |
30157 | the two delimiters @samp{$ $}, Calc will immediately prompt for | |
30158 | an algebraic entry. | |
30159 | ||
30160 | Only one formula in one buffer can be enabled at a time. If you | |
30161 | move to another area of the current buffer and give Calc commands, | |
30162 | Calc turns Embedded mode off for the old formula and then tries | |
30163 | to restart Embedded mode at the new position. Other buffers are | |
30164 | not affected by Embedded mode. | |
30165 | ||
30166 | When Embedded mode begins, Calc pushes the current formula onto | |
30167 | the stack. No Calc stack window is created; however, Calc copies | |
30168 | the top-of-stack position into the original buffer at all times. | |
58547c3e | 30169 | You can create a Calc window by hand with @kbd{C-x * o} if you |
d7b8e6c6 EZ |
30170 | find you need to see the entire stack. |
30171 | ||
58547c3e | 30172 | For example, typing @kbd{C-x * e} while somewhere in the formula |
d7b8e6c6 EZ |
30173 | @samp{n>2} in the following line enables Embedded mode on that |
30174 | inequality: | |
30175 | ||
30176 | @example | |
30177 | We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$. | |
30178 | @end example | |
30179 | ||
30180 | @noindent | |
a4231b04 | 30181 | The formula @expr{n>2} will be pushed onto the Calc stack, and |
d7b8e6c6 EZ |
30182 | the top of stack will be copied back into the editing buffer. |
30183 | This means that spaces will appear around the @samp{>} symbol | |
30184 | to match Calc's usual display style: | |
30185 | ||
30186 | @example | |
30187 | We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$. | |
30188 | @end example | |
30189 | ||
30190 | @noindent | |
30191 | No spaces have appeared around the @samp{+} sign because it's | |
30192 | in a different formula, one which we have not yet touched with | |
30193 | Embedded mode. | |
30194 | ||
30195 | Now that Embedded mode is enabled, keys you type in this buffer | |
30196 | are interpreted as Calc commands. At this point we might use | |
30197 | the ``commute'' command @kbd{j C} to reverse the inequality. | |
30198 | This is a selection-based command for which we first need to | |
30199 | move the cursor onto the operator (@samp{>} in this case) that | |
30200 | needs to be commuted. | |
30201 | ||
30202 | @example | |
30203 | We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$. | |
30204 | @end example | |
30205 | ||
58547c3e | 30206 | The @kbd{C-x * o} command is a useful way to open a Calc window |
d7b8e6c6 EZ |
30207 | without actually selecting that window. Giving this command |
30208 | verifies that @samp{2 < n} is also on the Calc stack. Typing | |
5d67986c | 30209 | @kbd{17 @key{RET}} would produce: |
d7b8e6c6 EZ |
30210 | |
30211 | @example | |
30212 | We define $F_n = F_(n-1)+F_(n-2)$ for all $17$. | |
30213 | @end example | |
30214 | ||
30215 | @noindent | |
30216 | with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB} | |
30217 | at this point will exchange the two stack values and restore | |
30218 | @samp{2 < n} to the embedded formula. Even though you can't | |
30219 | normally see the stack in Embedded mode, it is still there and | |
30220 | it still operates in the same way. But, as with old-fashioned | |
30221 | RPN calculators, you can only see the value at the top of the | |
58547c3e | 30222 | stack at any given time (unless you use @kbd{C-x * o}). |
d7b8e6c6 | 30223 | |
58547c3e | 30224 | Typing @kbd{C-x * e} again turns Embedded mode off. The Calc |
d7b8e6c6 EZ |
30225 | window reveals that the formula @w{@samp{2 < n}} is automatically |
30226 | removed from the stack, but the @samp{17} is not. Entering | |
30227 | Embedded mode always pushes one thing onto the stack, and | |
30228 | leaving Embedded mode always removes one thing. Anything else | |
30229 | that happens on the stack is entirely your business as far as | |
30230 | Embedded mode is concerned. | |
30231 | ||
58547c3e | 30232 | If you press @kbd{C-x * e} in the wrong place by accident, it is |
d7b8e6c6 EZ |
30233 | possible that Calc will be able to parse the nearby text as a |
30234 | formula and will mangle that text in an attempt to redisplay it | |
30235 | ``properly'' in the current language mode. If this happens, | |
58547c3e | 30236 | press @kbd{C-x * e} again to exit Embedded mode, then give the |
d7b8e6c6 EZ |
30237 | regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put |
30238 | the text back the way it was before Calc edited it. Note that Calc's | |
30239 | own Undo command (typed before you turn Embedded mode back off) | |
30240 | will not do you any good, because as far as Calc is concerned | |
30241 | you haven't done anything with this formula yet. | |
30242 | ||
30243 | @node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode | |
30244 | @section More About Embedded Mode | |
30245 | ||
30246 | @noindent | |
30247 | When Embedded mode ``activates'' a formula, i.e., when it examines | |
30248 | the formula for the first time since the buffer was created or | |
30249 | loaded, Calc tries to sense the language in which the formula was | |
053bc283 JB |
30250 | written. If the formula contains any La@TeX{}-like @samp{\} sequences, |
30251 | it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to | |
d7b8e6c6 EZ |
30252 | be written in multi-line Big mode, it is parsed in Big mode. Otherwise, |
30253 | it is parsed according to the current language mode. | |
30254 | ||
30255 | Note that Calc does not change the current language mode according | |
1dddb589 | 30256 | the formula it reads in. Even though it can read a La@TeX{} formula when |
053bc283 | 30257 | not in La@TeX{} mode, it will immediately rewrite this formula using |
1dddb589 | 30258 | whatever language mode is in effect. |
d7b8e6c6 EZ |
30259 | |
30260 | @tex | |
30261 | \bigskip | |
30262 | @end tex | |
30263 | ||
30264 | @kindex d p | |
30265 | @pindex calc-show-plain | |
30266 | Calc's parser is unable to read certain kinds of formulas. For | |
30267 | example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can | |
30268 | specify matrix display styles which the parser is unable to | |
30269 | recognize as matrices. The @kbd{d p} (@code{calc-show-plain}) | |
30270 | command turns on a mode in which a ``plain'' version of a | |
30271 | formula is placed in front of the fully-formatted version. | |
30272 | When Calc reads a formula that has such a plain version in | |
30273 | front, it reads the plain version and ignores the formatted | |
30274 | version. | |
30275 | ||
30276 | Plain formulas are preceded and followed by @samp{%%%} signs | |
30277 | by default. This notation has the advantage that the @samp{%} | |
053bc283 JB |
30278 | character begins a comment in @TeX{} and La@TeX{}, so if your formula is |
30279 | embedded in a @TeX{} or La@TeX{} document its plain version will be | |
5127c216 JB |
30280 | invisible in the final printed copy. Certain major modes have different |
30281 | delimiters to ensure that the ``plain'' version will be | |
30282 | in a comment for those modes, also. | |
30283 | See @ref{Customizing Embedded Mode} to see how to change the ``plain'' | |
30284 | formula delimiters. | |
d7b8e6c6 EZ |
30285 | |
30286 | There are several notations which Calc's parser for ``big'' | |
30287 | formatted formulas can't yet recognize. In particular, it can't | |
30288 | read the large symbols for @code{sum}, @code{prod}, and @code{integ}, | |
30289 | and it can't handle @samp{=>} with the righthand argument omitted. | |
30290 | Also, Calc won't recognize special formats you have defined with | |
30291 | the @kbd{Z C} command (@pxref{User-Defined Compositions}). In | |
30292 | these cases it is important to use ``plain'' mode to make sure | |
30293 | Calc will be able to read your formula later. | |
30294 | ||
30295 | Another example where ``plain'' mode is important is if you have | |
30296 | specified a float mode with few digits of precision. Normally | |
30297 | any digits that are computed but not displayed will simply be | |
30298 | lost when you save and re-load your embedded buffer, but ``plain'' | |
30299 | mode allows you to make sure that the complete number is present | |
30300 | in the file as well as the rounded-down number. | |
30301 | ||
30302 | @tex | |
30303 | \bigskip | |
30304 | @end tex | |
30305 | ||
30306 | Embedded buffers remember active formulas for as long as they | |
30307 | exist in Emacs memory. Suppose you have an embedded formula | |
a4231b04 | 30308 | which is @cpi{} to the normal 12 decimal places, and then |
d7b8e6c6 EZ |
30309 | type @w{@kbd{C-u 5 d n}} to display only five decimal places. |
30310 | If you then type @kbd{d n}, all 12 places reappear because the | |
30311 | full number is still there on the Calc stack. More surprisingly, | |
30312 | even if you exit Embedded mode and later re-enter it for that | |
30313 | formula, typing @kbd{d n} will restore all 12 places because | |
30314 | each buffer remembers all its active formulas. However, if you | |
30315 | save the buffer in a file and reload it in a new Emacs session, | |
30316 | all non-displayed digits will have been lost unless you used | |
30317 | ``plain'' mode. | |
30318 | ||
30319 | @tex | |
30320 | \bigskip | |
30321 | @end tex | |
30322 | ||
30323 | In some applications of Embedded mode, you will want to have a | |
30324 | sequence of copies of a formula that show its evolution as you | |
30325 | work on it. For example, you might want to have a sequence | |
30326 | like this in your file (elaborating here on the example from | |
30327 | the ``Getting Started'' chapter): | |
30328 | ||
30329 | @smallexample | |
30330 | The derivative of | |
30331 | ||
30332 | ln(ln(x)) | |
30333 | ||
30334 | is | |
30335 | ||
30336 | @r{(the derivative of }ln(ln(x))@r{)} | |
30337 | ||
30338 | whose value at x = 2 is | |
30339 | ||
30340 | @r{(the value)} | |
30341 | ||
30342 | and at x = 3 is | |
30343 | ||
30344 | @r{(the value)} | |
30345 | @end smallexample | |
30346 | ||
58547c3e | 30347 | @kindex C-x * d |
d7b8e6c6 | 30348 | @pindex calc-embedded-duplicate |
58547c3e JB |
30349 | The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a |
30350 | handy way to make sequences like this. If you type @kbd{C-x * d}, | |
d7b8e6c6 EZ |
30351 | the formula under the cursor (which may or may not have Embedded |
30352 | mode enabled for it at the time) is copied immediately below and | |
30353 | Embedded mode is then enabled for that copy. | |
30354 | ||
30355 | For this example, you would start with just | |
30356 | ||
30357 | @smallexample | |
30358 | The derivative of | |
30359 | ||
30360 | ln(ln(x)) | |
30361 | @end smallexample | |
30362 | ||
30363 | @noindent | |
58547c3e | 30364 | and press @kbd{C-x * d} with the cursor on this formula. The result |
d7b8e6c6 EZ |
30365 | is |
30366 | ||
30367 | @smallexample | |
30368 | The derivative of | |
30369 | ||
30370 | ln(ln(x)) | |
30371 | ||
30372 | ||
30373 | ln(ln(x)) | |
30374 | @end smallexample | |
30375 | ||
30376 | @noindent | |
30377 | with the second copy of the formula enabled in Embedded mode. | |
5d67986c | 30378 | You can now press @kbd{a d x @key{RET}} to take the derivative, and |
58547c3e | 30379 | @kbd{C-x * d C-x * d} to make two more copies of the derivative. |
5d67986c | 30380 | To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate |
d7b8e6c6 | 30381 | the last formula, then move up to the second-to-last formula |
5d67986c | 30382 | and type @kbd{2 s l x @key{RET}}. |
d7b8e6c6 | 30383 | |
58547c3e | 30384 | Finally, you would want to press @kbd{C-x * e} to exit Embedded |
d7b8e6c6 EZ |
30385 | mode, then go up and insert the necessary text in between the |
30386 | various formulas and numbers. | |
30387 | ||
30388 | @tex | |
30389 | \bigskip | |
30390 | @end tex | |
30391 | ||
58547c3e JB |
30392 | @kindex C-x * f |
30393 | @kindex C-x * ' | |
d7b8e6c6 | 30394 | @pindex calc-embedded-new-formula |
58547c3e | 30395 | The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command |
d7b8e6c6 EZ |
30396 | creates a new embedded formula at the current point. It inserts |
30397 | some default delimiters, which are usually just blank lines, | |
30398 | and then does an algebraic entry to get the formula (which is | |
30399 | then enabled for Embedded mode). This is just shorthand for | |
30400 | typing the delimiters yourself, positioning the cursor between | |
58547c3e JB |
30401 | the new delimiters, and pressing @kbd{C-x * e}. The key sequence |
30402 | @kbd{C-x * '} is equivalent to @kbd{C-x * f}. | |
d7b8e6c6 | 30403 | |
58547c3e JB |
30404 | @kindex C-x * n |
30405 | @kindex C-x * p | |
d7b8e6c6 EZ |
30406 | @pindex calc-embedded-next |
30407 | @pindex calc-embedded-previous | |
58547c3e | 30408 | The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p} |
d7b8e6c6 EZ |
30409 | (@code{calc-embedded-previous}) commands move the cursor to the |
30410 | next or previous active embedded formula in the buffer. They | |
30411 | can take positive or negative prefix arguments to move by several | |
30412 | formulas. Note that these commands do not actually examine the | |
30413 | text of the buffer looking for formulas; they only see formulas | |
30414 | which have previously been activated in Embedded mode. In fact, | |
58547c3e | 30415 | @kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which |
d7b8e6c6 EZ |
30416 | embedded formulas are currently active. Also, note that these |
30417 | commands do not enable Embedded mode on the next or previous | |
58547c3e | 30418 | formula, they just move the cursor. |
d7b8e6c6 | 30419 | |
58547c3e | 30420 | @kindex C-x * ` |
d7b8e6c6 | 30421 | @pindex calc-embedded-edit |
58547c3e | 30422 | The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the |
d7b8e6c6 EZ |
30423 | embedded formula at the current point as if by @kbd{`} (@code{calc-edit}). |
30424 | Embedded mode does not have to be enabled for this to work. Press | |
33108698 | 30425 | @kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel. |
d7b8e6c6 EZ |
30426 | |
30427 | @node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode | |
30428 | @section Assignments in Embedded Mode | |
30429 | ||
30430 | @noindent | |
30431 | The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators | |
30432 | are especially useful in Embedded mode. They allow you to make | |
30433 | a definition in one formula, then refer to that definition in | |
30434 | other formulas embedded in the same buffer. | |
30435 | ||
30436 | An embedded formula which is an assignment to a variable, as in | |
30437 | ||
30438 | @example | |
30439 | foo := 5 | |
30440 | @end example | |
30441 | ||
30442 | @noindent | |
a4231b04 | 30443 | records @expr{5} as the stored value of @code{foo} for the |
d7b8e6c6 | 30444 | purposes of Embedded mode operations in the current buffer. It |
a4231b04 | 30445 | does @emph{not} actually store @expr{5} as the ``global'' value |
d7b8e6c6 EZ |
30446 | of @code{foo}, however. Regular Calc operations, and Embedded |
30447 | formulas in other buffers, will not see this assignment. | |
30448 | ||
30449 | One way to use this assigned value is simply to create an | |
30450 | Embedded formula elsewhere that refers to @code{foo}, and to press | |
30451 | @kbd{=} in that formula. However, this permanently replaces the | |
30452 | @code{foo} in the formula with its current value. More interesting | |
30453 | is to use @samp{=>} elsewhere: | |
30454 | ||
30455 | @example | |
30456 | foo + 7 => 12 | |
30457 | @end example | |
30458 | ||
30459 | @xref{Evaluates-To Operator}, for a general discussion of @samp{=>}. | |
30460 | ||
30461 | If you move back and change the assignment to @code{foo}, any | |
30462 | @samp{=>} formulas which refer to it are automatically updated. | |
30463 | ||
30464 | @example | |
30465 | foo := 17 | |
30466 | ||
30467 | foo + 7 => 24 | |
30468 | @end example | |
30469 | ||
30470 | The obvious question then is, @emph{how} can one easily change the | |
30471 | assignment to @code{foo}? If you simply select the formula in | |
30472 | Embedded mode and type 17, the assignment itself will be replaced | |
30473 | by the 17. The effect on the other formula will be that the | |
30474 | variable @code{foo} becomes unassigned: | |
30475 | ||
30476 | @example | |
30477 | 17 | |
30478 | ||
30479 | foo + 7 => foo + 7 | |
30480 | @end example | |
30481 | ||
30482 | The right thing to do is first to use a selection command (@kbd{j 2} | |
30483 | will do the trick) to select the righthand side of the assignment. | |
5d67986c | 30484 | Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting |
d7b8e6c6 EZ |
30485 | Subformulas}, to see how this works). |
30486 | ||
58547c3e | 30487 | @kindex C-x * j |
d7b8e6c6 | 30488 | @pindex calc-embedded-select |
58547c3e JB |
30489 | The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an |
30490 | easy way to operate on assignments. It is just like @kbd{C-x * e}, | |
d7b8e6c6 EZ |
30491 | except that if the enabled formula is an assignment, it uses |
30492 | @kbd{j 2} to select the righthand side. If the enabled formula | |
30493 | is an evaluates-to, it uses @kbd{j 1} to select the lefthand side. | |
30494 | A formula can also be a combination of both: | |
30495 | ||
30496 | @example | |
30497 | bar := foo + 3 => 20 | |
30498 | @end example | |
30499 | ||
30500 | @noindent | |
58547c3e | 30501 | in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}). |
d7b8e6c6 EZ |
30502 | |
30503 | The formula is automatically deselected when you leave Embedded | |
30504 | mode. | |
30505 | ||
58547c3e | 30506 | @kindex C-x * u |
909bd0ca | 30507 | @pindex calc-embedded-update-formula |
d7b8e6c6 EZ |
30508 | Another way to change the assignment to @code{foo} would simply be |
30509 | to edit the number using regular Emacs editing rather than Embedded | |
30510 | mode. Then, we have to find a way to get Embedded mode to notice | |
58547c3e JB |
30511 | the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula}) |
30512 | command is a convenient way to do this. | |
d7b8e6c6 EZ |
30513 | |
30514 | @example | |
30515 | foo := 6 | |
30516 | ||
30517 | foo + 7 => 13 | |
30518 | @end example | |
30519 | ||
58547c3e | 30520 | Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that |
d7b8e6c6 | 30521 | is, temporarily enabling Embedded mode for the formula under the |
58547c3e JB |
30522 | cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does |
30523 | not actually use @kbd{C-x * e}, and in fact another formula somewhere | |
30524 | else can be enabled in Embedded mode while you use @kbd{C-x * u} and | |
d7b8e6c6 EZ |
30525 | that formula will not be disturbed. |
30526 | ||
58547c3e | 30527 | With a numeric prefix argument, @kbd{C-x * u} updates all active |
d7b8e6c6 EZ |
30528 | @samp{=>} formulas in the buffer. Formulas which have not yet |
30529 | been activated in Embedded mode, and formulas which do not have | |
30530 | @samp{=>} as their top-level operator, are not affected by this. | |
30531 | (This is useful only if you have used @kbd{m C}; see below.) | |
30532 | ||
58547c3e | 30533 | With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the |
d7b8e6c6 EZ |
30534 | region between mark and point rather than in the whole buffer. |
30535 | ||
58547c3e | 30536 | @kbd{C-x * u} is also a handy way to activate a formula, such as an |
d7b8e6c6 EZ |
30537 | @samp{=>} formula that has freshly been typed in or loaded from a |
30538 | file. | |
30539 | ||
58547c3e | 30540 | @kindex C-x * a |
d7b8e6c6 | 30541 | @pindex calc-embedded-activate |
58547c3e | 30542 | The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans |
d7b8e6c6 EZ |
30543 | through the current buffer and activates all embedded formulas |
30544 | that contain @samp{:=} or @samp{=>} symbols. This does not mean | |
30545 | that Embedded mode is actually turned on, but only that the | |
30546 | formulas' positions are registered with Embedded mode so that | |
30547 | the @samp{=>} values can be properly updated as assignments are | |
30548 | changed. | |
30549 | ||
58547c3e | 30550 | It is a good idea to type @kbd{C-x * a} right after loading a file |
d7b8e6c6 EZ |
30551 | that uses embedded @samp{=>} operators. Emacs includes a nifty |
30552 | ``buffer-local variables'' feature that you can use to do this | |
30553 | automatically. The idea is to place near the end of your file | |
30554 | a few lines that look like this: | |
30555 | ||
30556 | @example | |
30557 | --- Local Variables: --- | |
30558 | --- eval:(calc-embedded-activate) --- | |
30559 | --- End: --- | |
30560 | @end example | |
30561 | ||
30562 | @noindent | |
30563 | where the leading and trailing @samp{---} can be replaced by | |
30564 | any suitable strings (which must be the same on all three lines) | |
053bc283 | 30565 | or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good |
d7b8e6c6 EZ |
30566 | leading string and no trailing string would be necessary. In a |
30567 | C program, @samp{/*} and @samp{*/} would be good leading and | |
30568 | trailing strings. | |
30569 | ||
30570 | When Emacs loads a file into memory, it checks for a Local Variables | |
30571 | section like this one at the end of the file. If it finds this | |
30572 | section, it does the specified things (in this case, running | |
58547c3e | 30573 | @kbd{C-x * a} automatically) before editing of the file begins. |
d7b8e6c6 EZ |
30574 | The Local Variables section must be within 3000 characters of the |
30575 | end of the file for Emacs to find it, and it must be in the last | |
30576 | page of the file if the file has any page separators. | |
30577 | @xref{File Variables, , Local Variables in Files, emacs, the | |
30578 | Emacs manual}. | |
30579 | ||
58547c3e JB |
30580 | Note that @kbd{C-x * a} does not update the formulas it finds. |
30581 | To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}. | |
d7b8e6c6 EZ |
30582 | Generally this should not be a problem, though, because the |
30583 | formulas will have been up-to-date already when the file was | |
30584 | saved. | |
30585 | ||
58547c3e | 30586 | Normally, @kbd{C-x * a} activates all the formulas it finds, but |
d7b8e6c6 | 30587 | any previous active formulas remain active as well. With a |
58547c3e | 30588 | positive numeric prefix argument, @kbd{C-x * a} first deactivates |
d7b8e6c6 EZ |
30589 | all current active formulas, then actives the ones it finds in |
30590 | its scan of the buffer. With a negative prefix argument, | |
58547c3e | 30591 | @kbd{C-x * a} simply deactivates all formulas. |
d7b8e6c6 EZ |
30592 | |
30593 | Embedded mode has two symbols, @samp{Active} and @samp{~Active}, | |
30594 | which it puts next to the major mode name in a buffer's mode line. | |
30595 | It puts @samp{Active} if it has reason to believe that all | |
58547c3e | 30596 | formulas in the buffer are active, because you have typed @kbd{C-x * a} |
d7b8e6c6 EZ |
30597 | and Calc has not since had to deactivate any formulas (which can |
30598 | happen if Calc goes to update an @samp{=>} formula somewhere because | |
30599 | a variable changed, and finds that the formula is no longer there | |
30600 | due to some kind of editing outside of Embedded mode). Calc puts | |
30601 | @samp{~Active} in the mode line if some, but probably not all, | |
30602 | formulas in the buffer are active. This happens if you activate | |
58547c3e JB |
30603 | a few formulas one at a time but never use @kbd{C-x * a}, or if you |
30604 | used @kbd{C-x * a} but then Calc had to deactivate a formula | |
d7b8e6c6 EZ |
30605 | because it lost track of it. If neither of these symbols appears |
30606 | in the mode line, no embedded formulas are active in the buffer | |
58547c3e | 30607 | (e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}). |
d7b8e6c6 EZ |
30608 | |
30609 | Embedded formulas can refer to assignments both before and after them | |
30610 | in the buffer. If there are several assignments to a variable, the | |
30611 | nearest preceding assignment is used if there is one, otherwise the | |
30612 | following assignment is used. | |
30613 | ||
30614 | @example | |
30615 | x => 1 | |
30616 | ||
30617 | x := 1 | |
30618 | ||
30619 | x => 1 | |
30620 | ||
30621 | x := 2 | |
30622 | ||
30623 | x => 2 | |
30624 | @end example | |
30625 | ||
30626 | As well as simple variables, you can also assign to subscript | |
30627 | expressions of the form @samp{@var{var}_@var{number}} (as in | |
30628 | @code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}). | |
30629 | Assignments to other kinds of objects can be represented by Calc, | |
30630 | but the automatic linkage between assignments and references works | |
30631 | only for plain variables and these two kinds of subscript expressions. | |
30632 | ||
30633 | If there are no assignments to a given variable, the global | |
30634 | stored value for the variable is used (@pxref{Storing Variables}), | |
30635 | or, if no value is stored, the variable is left in symbolic form. | |
30636 | Note that global stored values will be lost when the file is saved | |
30637 | and loaded in a later Emacs session, unless you have used the | |
30638 | @kbd{s p} (@code{calc-permanent-variable}) command to save them; | |
30639 | @pxref{Operations on Variables}. | |
30640 | ||
30641 | The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic | |
30642 | recomputation of @samp{=>} forms on and off. If you turn automatic | |
58547c3e | 30643 | recomputation off, you will have to use @kbd{C-x * u} to update these |
d7b8e6c6 EZ |
30644 | formulas manually after an assignment has been changed. If you |
30645 | plan to change several assignments at once, it may be more efficient | |
58547c3e | 30646 | to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u} |
d7b8e6c6 EZ |
30647 | to update the entire buffer afterwards. The @kbd{m C} command also |
30648 | controls @samp{=>} formulas on the stack; @pxref{Evaluates-To | |
30649 | Operator}. When you turn automatic recomputation back on, the | |
30650 | stack will be updated but the Embedded buffer will not; you must | |
58547c3e | 30651 | use @kbd{C-x * u} to update the buffer by hand. |
d7b8e6c6 EZ |
30652 | |
30653 | @node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode | |
30654 | @section Mode Settings in Embedded Mode | |
30655 | ||
746539f6 JB |
30656 | @kindex m e |
30657 | @pindex calc-embedded-preserve-modes | |
d7b8e6c6 | 30658 | @noindent |
1dddb589 | 30659 | The mode settings can be changed while Calc is in embedded mode, but |
746539f6 JB |
30660 | by default they will revert to their original values when embedded mode |
30661 | is ended. However, the modes saved when the mode-recording mode is | |
30662 | @code{Save} (see below) and the modes in effect when the @kbd{m e} | |
30663 | (@code{calc-embedded-preserve-modes}) command is given | |
30664 | will be preserved when embedded mode is ended. | |
1dddb589 | 30665 | |
07ce2eb3 | 30666 | Embedded mode has a rather complicated mechanism for handling mode |
d7b8e6c6 EZ |
30667 | settings in Embedded formulas. It is possible to put annotations |
30668 | in the file that specify mode settings either global to the entire | |
30669 | file or local to a particular formula or formulas. In the latter | |
30670 | case, different modes can be specified for use when a formula | |
07ce2eb3 | 30671 | is the enabled Embedded mode formula. |
d7b8e6c6 | 30672 | |
07ce2eb3 JB |
30673 | When you give any mode-setting command, like @kbd{m f} (for Fraction |
30674 | mode) or @kbd{d s} (for scientific notation), Embedded mode adds | |
d7b8e6c6 EZ |
30675 | a line like the following one to the file just before the opening |
30676 | delimiter of the formula. | |
30677 | ||
30678 | @example | |
30679 | % [calc-mode: fractions: t] | |
30680 | % [calc-mode: float-format: (sci 0)] | |
30681 | @end example | |
30682 | ||
30683 | When Calc interprets an embedded formula, it scans the text before | |
30684 | the formula for mode-setting annotations like these and sets the | |
30685 | Calc buffer to match these modes. Modes not explicitly described | |
30686 | in the file are not changed. Calc scans all the way to the top of | |
30687 | the file, or up to a line of the form | |
30688 | ||
30689 | @example | |
30690 | % [calc-defaults] | |
30691 | @end example | |
30692 | ||
30693 | @noindent | |
30694 | which you can insert at strategic places in the file if this backward | |
30695 | scan is getting too slow, or just to provide a barrier between one | |
30696 | ``zone'' of mode settings and another. | |
30697 | ||
30698 | If the file contains several annotations for the same mode, the | |
30699 | closest one before the formula is used. Annotations after the | |
30700 | formula are never used (except for global annotations, described | |
30701 | below). | |
30702 | ||
30703 | The scan does not look for the leading @samp{% }, only for the | |
5127c216 JB |
30704 | square brackets and the text they enclose. In fact, the leading |
30705 | characters are different for different major modes. You can edit the | |
30706 | mode annotations to a style that works better in context if you wish. | |
d7b8e6c6 EZ |
30707 | @xref{Customizing Embedded Mode}, to see how to change the style |
30708 | that Calc uses when it generates the annotations. You can write | |
30709 | mode annotations into the file yourself if you know the syntax; | |
30710 | the easiest way to find the syntax for a given mode is to let | |
30711 | Calc write the annotation for it once and see what it does. | |
30712 | ||
30713 | If you give a mode-changing command for a mode that already has | |
30714 | a suitable annotation just above the current formula, Calc will | |
30715 | modify that annotation rather than generating a new, conflicting | |
30716 | one. | |
30717 | ||
30718 | Mode annotations have three parts, separated by colons. (Spaces | |
30719 | after the colons are optional.) The first identifies the kind | |
30720 | of mode setting, the second is a name for the mode itself, and | |
30721 | the third is the value in the form of a Lisp symbol, number, | |
30722 | or list. Annotations with unrecognizable text in the first or | |
30723 | second parts are ignored. The third part is not checked to make | |
2cbd16b9 | 30724 | sure the value is of a valid type or range; if you write an |
d7b8e6c6 EZ |
30725 | annotation by hand, be sure to give a proper value or results |
30726 | will be unpredictable. Mode-setting annotations are case-sensitive. | |
30727 | ||
07ce2eb3 | 30728 | While Embedded mode is enabled, the word @code{Local} appears in |
d7b8e6c6 EZ |
30729 | the mode line. This is to show that mode setting commands generate |
30730 | annotations that are ``local'' to the current formula or set of | |
30731 | formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command | |
30732 | causes Calc to generate different kinds of annotations. Pressing | |
30733 | @kbd{m R} repeatedly cycles through the possible modes. | |
30734 | ||
30735 | @code{LocEdit} and @code{LocPerm} modes generate annotations | |
30736 | that look like this, respectively: | |
30737 | ||
30738 | @example | |
30739 | % [calc-edit-mode: float-format: (sci 0)] | |
30740 | % [calc-perm-mode: float-format: (sci 5)] | |
30741 | @end example | |
30742 | ||
30743 | The first kind of annotation will be used only while a formula | |
07ce2eb3 | 30744 | is enabled in Embedded mode. The second kind will be used only |
d7b8e6c6 EZ |
30745 | when the formula is @emph{not} enabled. (Whether the formula |
30746 | is ``active'' or not, i.e., whether Calc has seen this formula | |
30747 | yet, is not relevant here.) | |
30748 | ||
30749 | @code{Global} mode generates an annotation like this at the end | |
30750 | of the file: | |
30751 | ||
30752 | @example | |
30753 | % [calc-global-mode: fractions t] | |
30754 | @end example | |
30755 | ||
30756 | Global mode annotations affect all formulas throughout the file, | |
30757 | and may appear anywhere in the file. This allows you to tuck your | |
30758 | mode annotations somewhere out of the way, say, on a new page of | |
30759 | the file, as long as those mode settings are suitable for all | |
30760 | formulas in the file. | |
30761 | ||
58547c3e | 30762 | Enabling a formula with @kbd{C-x * e} causes a fresh scan for local |
d7b8e6c6 EZ |
30763 | mode annotations; you will have to use this after adding annotations |
30764 | above a formula by hand to get the formula to notice them. Updating | |
58547c3e JB |
30765 | a formula with @kbd{C-x * u} will also re-scan the local modes, but |
30766 | global modes are only re-scanned by @kbd{C-x * a}. | |
d7b8e6c6 EZ |
30767 | |
30768 | Another way that modes can get out of date is if you add a local | |
30769 | mode annotation to a formula that has another formula after it. | |
30770 | In this example, we have used the @kbd{d s} command while the | |
30771 | first of the two embedded formulas is active. But the second | |
30772 | formula has not changed its style to match, even though by the | |
30773 | rules of reading annotations the @samp{(sci 0)} applies to it, too. | |
30774 | ||
30775 | @example | |
30776 | % [calc-mode: float-format: (sci 0)] | |
30777 | 1.23e2 | |
30778 | ||
30779 | 456. | |
30780 | @end example | |
30781 | ||
58547c3e | 30782 | We would have to go down to the other formula and press @kbd{C-x * u} |
d7b8e6c6 EZ |
30783 | on it in order to get it to notice the new annotation. |
30784 | ||
35626cba JB |
30785 | Two more mode-recording modes selectable by @kbd{m R} are available |
30786 | which are also available outside of Embedded mode. | |
30787 | (@pxref{General Mode Commands}.) They are @code{Save}, in which mode | |
30788 | settings are recorded permanently in your Calc init file (the file given | |
30789 | by the variable @code{calc-settings-file}, typically @file{~/.calc.el}) | |
d7b8e6c6 EZ |
30790 | rather than by annotating the current document, and no-recording |
30791 | mode (where there is no symbol like @code{Save} or @code{Local} in | |
30792 | the mode line), in which mode-changing commands do not leave any | |
30793 | annotations at all. | |
30794 | ||
07ce2eb3 | 30795 | When Embedded mode is not enabled, mode-recording modes except |
d7b8e6c6 EZ |
30796 | for @code{Save} have no effect. |
30797 | ||
30798 | @node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode | |
30799 | @section Customizing Embedded Mode | |
30800 | ||
30801 | @noindent | |
07ce2eb3 | 30802 | You can modify Embedded mode's behavior by setting various Lisp |
b154df16 | 30803 | variables described here. These variables are customizable |
58547c3e | 30804 | (@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable} |
b154df16 | 30805 | or @kbd{M-x edit-options} to adjust a variable on the fly. |
5127c216 JB |
30806 | (Another possibility would be to use a file-local variable annotation at |
30807 | the end of the file; | |
30808 | @pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.) | |
30809 | Many of the variables given mentioned here can be set to depend on the | |
58547c3e | 30810 | major mode of the editing buffer (@pxref{Customizing Calc}). |
d7b8e6c6 EZ |
30811 | |
30812 | @vindex calc-embedded-open-formula | |
30813 | The @code{calc-embedded-open-formula} variable holds a regular | |
30814 | expression for the opening delimiter of a formula. @xref{Regexp Search, | |
30815 | , Regular Expression Search, emacs, the Emacs manual}, to see | |
30816 | how regular expressions work. Basically, a regular expression is a | |
30817 | pattern that Calc can search for. A regular expression that considers | |
30818 | blank lines, @samp{$}, and @samp{$$} to be opening delimiters is | |
30819 | @code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this | |
30820 | regular expression is not completely plain, let's go through it | |
30821 | in detail. | |
30822 | ||
30823 | The surrounding @samp{" "} marks quote the text between them as a | |
30824 | Lisp string. If you left them off, @code{set-variable} or | |
30825 | @code{edit-options} would try to read the regular expression as a | |
30826 | Lisp program. | |
30827 | ||
30828 | The most obvious property of this regular expression is that it | |
30829 | contains indecently many backslashes. There are actually two levels | |
30830 | of backslash usage going on here. First, when Lisp reads a quoted | |
30831 | string, all pairs of characters beginning with a backslash are | |
30832 | interpreted as special characters. Here, @code{\n} changes to a | |
30833 | new-line character, and @code{\\} changes to a single backslash. | |
30834 | So the actual regular expression seen by Calc is | |
30835 | @samp{\`\|^ @r{(newline)} \|\$\$?}. | |
30836 | ||
30837 | Regular expressions also consider pairs beginning with backslash | |
30838 | to have special meanings. Sometimes the backslash is used to quote | |
30839 | a character that otherwise would have a special meaning in a regular | |
30840 | expression, like @samp{$}, which normally means ``end-of-line,'' | |
30841 | or @samp{?}, which means that the preceding item is optional. So | |
30842 | @samp{\$\$?} matches either one or two dollar signs. | |
30843 | ||
30844 | The other codes in this regular expression are @samp{^}, which matches | |
30845 | ``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`}, | |
30846 | which matches ``beginning-of-buffer.'' So the whole pattern means | |
30847 | that a formula begins at the beginning of the buffer, or on a newline | |
30848 | that occurs at the beginning of a line (i.e., a blank line), or at | |
30849 | one or two dollar signs. | |
30850 | ||
30851 | The default value of @code{calc-embedded-open-formula} looks just | |
30852 | like this example, with several more alternatives added on to | |
30853 | recognize various other common kinds of delimiters. | |
30854 | ||
30855 | By the way, the reason to use @samp{^\n} rather than @samp{^$} | |
30856 | or @samp{\n\n}, which also would appear to match blank lines, | |
30857 | is that the former expression actually ``consumes'' only one | |
30858 | newline character as @emph{part of} the delimiter, whereas the | |
30859 | latter expressions consume zero or two newlines, respectively. | |
30860 | The former choice gives the most natural behavior when Calc | |
30861 | must operate on a whole formula including its delimiters. | |
30862 | ||
30863 | See the Emacs manual for complete details on regular expressions. | |
30864 | But just for your convenience, here is a list of all characters | |
30865 | which must be quoted with backslash (like @samp{\$}) to avoid | |
30866 | some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note | |
30867 | the backslash in this list; for example, to match @samp{\[} you | |
30868 | must use @code{"\\\\\\["}. An exercise for the reader is to | |
30869 | account for each of these six backslashes!) | |
30870 | ||
30871 | @vindex calc-embedded-close-formula | |
30872 | The @code{calc-embedded-close-formula} variable holds a regular | |
30873 | expression for the closing delimiter of a formula. A closing | |
30874 | regular expression to match the above example would be | |
30875 | @code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the | |
30876 | other one, except it now uses @samp{\'} (``end-of-buffer'') and | |
30877 | @samp{\n$} (newline occurring at end of line, yet another way | |
30878 | of describing a blank line that is more appropriate for this | |
30879 | case). | |
30880 | ||
30881 | @vindex calc-embedded-open-word | |
30882 | @vindex calc-embedded-close-word | |
30883 | The @code{calc-embedded-open-word} and @code{calc-embedded-close-word} | |
58547c3e JB |
30884 | variables are similar expressions used when you type @kbd{C-x * w} |
30885 | instead of @kbd{C-x * e} to enable Embedded mode. | |
d7b8e6c6 EZ |
30886 | |
30887 | @vindex calc-embedded-open-plain | |
30888 | The @code{calc-embedded-open-plain} variable is a string which | |
30889 | begins a ``plain'' formula written in front of the formatted | |
30890 | formula when @kbd{d p} mode is turned on. Note that this is an | |
30891 | actual string, not a regular expression, because Calc must be able | |
30892 | to write this string into a buffer as well as to recognize it. | |
5127c216 JB |
30893 | The default string is @code{"%%% "} (note the trailing space), but may |
30894 | be different for certain major modes. | |
d7b8e6c6 EZ |
30895 | |
30896 | @vindex calc-embedded-close-plain | |
30897 | The @code{calc-embedded-close-plain} variable is a string which | |
5127c216 JB |
30898 | ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be |
30899 | different for different major modes. Without | |
07ce2eb3 | 30900 | the trailing newline here, the first line of a Big mode formula |
d7b8e6c6 EZ |
30901 | that followed might be shifted over with respect to the other lines. |
30902 | ||
30903 | @vindex calc-embedded-open-new-formula | |
30904 | The @code{calc-embedded-open-new-formula} variable is a string | |
30905 | which is inserted at the front of a new formula when you type | |
58547c3e JB |
30906 | @kbd{C-x * f}. Its default value is @code{"\n\n"}. If this |
30907 | string begins with a newline character and the @kbd{C-x * f} is | |
30908 | typed at the beginning of a line, @kbd{C-x * f} will skip this | |
d7b8e6c6 EZ |
30909 | first newline to avoid introducing unnecessary blank lines in |
30910 | the file. | |
30911 | ||
30912 | @vindex calc-embedded-close-new-formula | |
30913 | The @code{calc-embedded-close-new-formula} variable is the corresponding | |
30914 | string which is inserted at the end of a new formula. Its default | |
30915 | value is also @code{"\n\n"}. The final newline is omitted by | |
58547c3e JB |
30916 | @w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if |
30917 | @kbd{C-x * f} is typed on a blank line, both a leading opening | |
d7b8e6c6 EZ |
30918 | newline and a trailing closing newline are omitted.) |
30919 | ||
30920 | @vindex calc-embedded-announce-formula | |
30921 | The @code{calc-embedded-announce-formula} variable is a regular | |
30922 | expression which is sure to be followed by an embedded formula. | |
58547c3e JB |
30923 | The @kbd{C-x * a} command searches for this pattern as well as for |
30924 | @samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will | |
d7b8e6c6 EZ |
30925 | not activate just anything surrounded by formula delimiters; after |
30926 | all, blank lines are considered formula delimiters by default! | |
30927 | But if your language includes a delimiter which can only occur | |
30928 | actually in front of a formula, you can take advantage of it here. | |
5127c216 JB |
30929 | The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be |
30930 | different for different major modes. | |
30931 | This pattern will check for @samp{%Embed} followed by any number of | |
30932 | lines beginning with @samp{%} and a space. This last is important to | |
30933 | make Calc consider mode annotations part of the pattern, so that the | |
30934 | formula's opening delimiter really is sure to follow the pattern. | |
d7b8e6c6 EZ |
30935 | |
30936 | @vindex calc-embedded-open-mode | |
30937 | The @code{calc-embedded-open-mode} variable is a string (not a | |
30938 | regular expression) which should precede a mode annotation. | |
30939 | Calc never scans for this string; Calc always looks for the | |
30940 | annotation itself. But this is the string that is inserted before | |
30941 | the opening bracket when Calc adds an annotation on its own. | |
5127c216 JB |
30942 | The default is @code{"% "}, but may be different for different major |
30943 | modes. | |
d7b8e6c6 EZ |
30944 | |
30945 | @vindex calc-embedded-close-mode | |
30946 | The @code{calc-embedded-close-mode} variable is a string which | |
30947 | follows a mode annotation written by Calc. Its default value | |
5127c216 JB |
30948 | is simply a newline, @code{"\n"}, but may be different for different |
30949 | major modes. If you change this, it is a good idea still to end with a | |
30950 | newline so that mode annotations will appear on lines by themselves. | |
d7b8e6c6 | 30951 | |
58547c3e | 30952 | @node Programming, Customizing Calc, Embedded Mode, Top |
d7b8e6c6 EZ |
30953 | @chapter Programming |
30954 | ||
30955 | @noindent | |
30956 | There are several ways to ``program'' the Emacs Calculator, depending | |
30957 | on the nature of the problem you need to solve. | |
30958 | ||
30959 | @enumerate | |
30960 | @item | |
30961 | @dfn{Keyboard macros} allow you to record a sequence of keystrokes | |
30962 | and play them back at a later time. This is just the standard Emacs | |
30963 | keyboard macro mechanism, dressed up with a few more features such | |
30964 | as loops and conditionals. | |
30965 | ||
30966 | @item | |
30967 | @dfn{Algebraic definitions} allow you to use any formula to define a | |
30968 | new function. This function can then be used in algebraic formulas or | |
30969 | as an interactive command. | |
30970 | ||
30971 | @item | |
30972 | @dfn{Rewrite rules} are discussed in the section on algebra commands. | |
30973 | @xref{Rewrite Rules}. If you put your rewrite rules in the variable | |
30974 | @code{EvalRules}, they will be applied automatically to all Calc | |
30975 | results in just the same way as an internal ``rule'' is applied to | |
30976 | evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}. | |
30977 | ||
30978 | @item | |
30979 | @dfn{Lisp} is the programming language that Calc (and most of Emacs) | |
30980 | is written in. If the above techniques aren't powerful enough, you | |
30981 | can write Lisp functions to do anything that built-in Calc commands | |
30982 | can do. Lisp code is also somewhat faster than keyboard macros or | |
30983 | rewrite rules. | |
30984 | @end enumerate | |
30985 | ||
30986 | @kindex z | |
30987 | Programming features are available through the @kbd{z} and @kbd{Z} | |
30988 | prefix keys. New commands that you define are two-key sequences | |
30989 | beginning with @kbd{z}. Commands for managing these definitions | |
30990 | use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing}) | |
30991 | command is described elsewhere; @pxref{Troubleshooting Commands}. | |
30992 | The @kbd{Z C} (@code{calc-user-define-composition}) command is also | |
30993 | described elsewhere; @pxref{User-Defined Compositions}.) | |
30994 | ||
30995 | @menu | |
30996 | * Creating User Keys:: | |
30997 | * Keyboard Macros:: | |
30998 | * Invocation Macros:: | |
30999 | * Algebraic Definitions:: | |
31000 | * Lisp Definitions:: | |
31001 | @end menu | |
31002 | ||
31003 | @node Creating User Keys, Keyboard Macros, Programming, Programming | |
31004 | @section Creating User Keys | |
31005 | ||
31006 | @noindent | |
31007 | @kindex Z D | |
31008 | @pindex calc-user-define | |
31009 | Any Calculator command may be bound to a key using the @kbd{Z D} | |
31010 | (@code{calc-user-define}) command. Actually, it is bound to a two-key | |
31011 | sequence beginning with the lower-case @kbd{z} prefix. | |
31012 | ||
31013 | The @kbd{Z D} command first prompts for the key to define. For example, | |
31014 | press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then | |
31015 | prompted for the name of the Calculator command that this key should | |
31016 | run. For example, the @code{calc-sincos} command is not normally | |
31017 | available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the | |
31018 | @kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain | |
31019 | in effect for the rest of this Emacs session, or until you redefine | |
31020 | @kbd{z s} to be something else. | |
31021 | ||
31022 | You can actually bind any Emacs command to a @kbd{z} key sequence by | |
31023 | backspacing over the @samp{calc-} when you are prompted for the command name. | |
31024 | ||
31025 | As with any other prefix key, you can type @kbd{z ?} to see a list of | |
31026 | all the two-key sequences you have defined that start with @kbd{z}. | |
31027 | Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined. | |
31028 | ||
31029 | User keys are typically letters, but may in fact be any key. | |
31030 | (@key{META}-keys are not permitted, nor are a terminal's special | |
31031 | function keys which generate multi-character sequences when pressed.) | |
31032 | You can define different commands on the shifted and unshifted versions | |
31033 | of a letter if you wish. | |
31034 | ||
31035 | @kindex Z U | |
31036 | @pindex calc-user-undefine | |
31037 | The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key. | |
31038 | For example, the key sequence @kbd{Z U s} will undefine the @code{sincos} | |
31039 | key we defined above. | |
31040 | ||
31041 | @kindex Z P | |
31042 | @pindex calc-user-define-permanent | |
31043 | @cindex Storing user definitions | |
31044 | @cindex Permanent user definitions | |
3b846359 | 31045 | @cindex Calc init file, user-defined commands |
d7b8e6c6 EZ |
31046 | The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key |
31047 | binding permanent so that it will remain in effect even in future Emacs | |
31048 | sessions. (It does this by adding a suitable bit of Lisp code into | |
3b846359 JB |
31049 | your Calc init file; that is, the file given by the variable |
31050 | @code{calc-settings-file}, typically @file{~/.calc.el}.) For example, | |
31051 | @kbd{Z P s} would register our @code{sincos} command permanently. If | |
31052 | you later wish to unregister this command you must edit your Calc init | |
31053 | file by hand. (@xref{General Mode Commands}, for a way to tell Calc to | |
31054 | use a different file for the Calc init file.) | |
d7b8e6c6 EZ |
31055 | |
31056 | The @kbd{Z P} command also saves the user definition, if any, for the | |
31057 | command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user | |
31058 | key could invoke a command, which in turn calls an algebraic function, | |
31059 | which might have one or more special display formats. A single @kbd{Z P} | |
31060 | command will save all of these definitions. | |
a2db4c6b JB |
31061 | To save an algebraic function, type @kbd{'} (the apostrophe) |
31062 | when prompted for a key, and type the function name. To save a command | |
31063 | without its key binding, type @kbd{M-x} and enter a function name. (The | |
31064 | @samp{calc-} prefix will automatically be inserted for you.) | |
31065 | (If the command you give implies a function, the function will be saved, | |
31066 | and if the function has any display formats, those will be saved, but | |
31067 | not the other way around: Saving a function will not save any commands | |
31068 | or key bindings associated with the function.) | |
d7b8e6c6 EZ |
31069 | |
31070 | @kindex Z E | |
31071 | @pindex calc-user-define-edit | |
31072 | @cindex Editing user definitions | |
31073 | The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition | |
31074 | of a user key. This works for keys that have been defined by either | |
31075 | keyboard macros or formulas; further details are contained in the relevant | |
31076 | following sections. | |
31077 | ||
31078 | @node Keyboard Macros, Invocation Macros, Creating User Keys, Programming | |
31079 | @section Programming with Keyboard Macros | |
31080 | ||
31081 | @noindent | |
31082 | @kindex X | |
31083 | @cindex Programming with keyboard macros | |
31084 | @cindex Keyboard macros | |
31085 | The easiest way to ``program'' the Emacs Calculator is to use standard | |
31086 | keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From | |
31087 | this point on, keystrokes you type will be saved away as well as | |
31088 | performing their usual functions. Press @kbd{C-x )} to end recording. | |
31089 | Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to | |
31090 | execute your keyboard macro by replaying the recorded keystrokes. | |
31091 | @xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further | |
a4231b04 | 31092 | information. |
d7b8e6c6 EZ |
31093 | |
31094 | When you use @kbd{X} to invoke a keyboard macro, the entire macro is | |
31095 | treated as a single command by the undo and trail features. The stack | |
31096 | display buffer is not updated during macro execution, but is instead | |
31097 | fixed up once the macro completes. Thus, commands defined with keyboard | |
31098 | macros are convenient and efficient. The @kbd{C-x e} command, on the | |
31099 | other hand, invokes the keyboard macro with no special treatment: Each | |
31100 | command in the macro will record its own undo information and trail entry, | |
31101 | and update the stack buffer accordingly. If your macro uses features | |
31102 | outside of Calc's control to operate on the contents of the Calc stack | |
31103 | buffer, or if it includes Undo, Redo, or last-arguments commands, you | |
31104 | must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date | |
31105 | at all times. You could also consider using @kbd{K} (@code{calc-keep-args}) | |
31106 | instead of @kbd{M-@key{RET}} (@code{calc-last-args}). | |
31107 | ||
31108 | Calc extends the standard Emacs keyboard macros in several ways. | |
31109 | Keyboard macros can be used to create user-defined commands. Keyboard | |
31110 | macros can include conditional and iteration structures, somewhat | |
31111 | analogous to those provided by a traditional programmable calculator. | |
31112 | ||
31113 | @menu | |
31114 | * Naming Keyboard Macros:: | |
31115 | * Conditionals in Macros:: | |
31116 | * Loops in Macros:: | |
31117 | * Local Values in Macros:: | |
31118 | * Queries in Macros:: | |
31119 | @end menu | |
31120 | ||
31121 | @node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros | |
31122 | @subsection Naming Keyboard Macros | |
31123 | ||
31124 | @noindent | |
31125 | @kindex Z K | |
31126 | @pindex calc-user-define-kbd-macro | |
31127 | Once you have defined a keyboard macro, you can bind it to a @kbd{z} | |
31128 | key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command. | |
31129 | This command prompts first for a key, then for a command name. For | |
31130 | example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will | |
31131 | define a keyboard macro which negates the top two numbers on the stack | |
31132 | (@key{TAB} swaps the top two stack elements). Now you can type | |
31133 | @kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key | |
31134 | sequence. The default command name (if you answer the second prompt with | |
31135 | just the @key{RET} key as in this example) will be something like | |
31136 | @samp{calc-User-n}. The keyboard macro will now be available as both | |
31137 | @kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more | |
a4231b04 | 31138 | descriptive command name if you wish. |
d7b8e6c6 EZ |
31139 | |
31140 | Macros defined by @kbd{Z K} act like single commands; they are executed | |
31141 | in the same way as by the @kbd{X} key. If you wish to define the macro | |
31142 | as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}), | |
31143 | give a negative prefix argument to @kbd{Z K}. | |
31144 | ||
31145 | Once you have bound your keyboard macro to a key, you can use | |
31146 | @kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}. | |
31147 | ||
31148 | @cindex Keyboard macros, editing | |
31149 | The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has | |
74857f83 JB |
31150 | been defined by a keyboard macro tries to use the @code{edmacro} package |
31151 | edit the macro. Type @kbd{C-c C-c} to finish editing and update | |
33108698 JB |
31152 | the definition stored on the key, or, to cancel the edit, kill the |
31153 | buffer with @kbd{C-x k}. | |
74857f83 JB |
31154 | The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, |
31155 | @code{DEL}, and @code{NUL} must be entered as these three character | |
31156 | sequences, written in all uppercase, as must the prefixes @code{C-} and | |
31157 | @code{M-}. Spaces and line breaks are ignored. Other characters are | |
d7b8e6c6 EZ |
31158 | copied verbatim into the keyboard macro. Basically, the notation is the |
31159 | same as is used in all of this manual's examples, except that the manual | |
74857f83 JB |
31160 | takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}}, |
31161 | we take it for granted that it is clear we really mean | |
31162 | @kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}. | |
d7b8e6c6 | 31163 | |
58547c3e | 31164 | @kindex C-x * m |
d7b8e6c6 | 31165 | @pindex read-kbd-macro |
58547c3e | 31166 | The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region'' |
d7b8e6c6 EZ |
31167 | of spelled-out keystrokes and defines it as the current keyboard macro. |
31168 | It is a convenient way to define a keyboard macro that has been stored | |
31169 | in a file, or to define a macro without executing it at the same time. | |
d7b8e6c6 EZ |
31170 | |
31171 | @node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros | |
31172 | @subsection Conditionals in Keyboard Macros | |
31173 | ||
31174 | @noindent | |
31175 | @kindex Z [ | |
31176 | @kindex Z ] | |
31177 | @pindex calc-kbd-if | |
31178 | @pindex calc-kbd-else | |
31179 | @pindex calc-kbd-else-if | |
31180 | @pindex calc-kbd-end-if | |
31181 | @cindex Conditional structures | |
31182 | The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if}) | |
31183 | commands allow you to put simple tests in a keyboard macro. When Calc | |
31184 | sees the @kbd{Z [}, it pops an object from the stack and, if the object is | |
31185 | a non-zero value, continues executing keystrokes. But if the object is | |
31186 | zero, or if it is not provably nonzero, Calc skips ahead to the matching | |
31187 | @kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for | |
31188 | performing tests which conveniently produce 1 for true and 0 for false. | |
31189 | ||
31190 | For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value | |
31191 | function in the form of a keyboard macro. This macro duplicates the | |
31192 | number on the top of the stack, pushes zero and compares using @kbd{a <} | |
31193 | (@code{calc-less-than}), then, if the number was less than zero, | |
31194 | executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign | |
31195 | command is skipped. | |
31196 | ||
31197 | To program this macro, type @kbd{C-x (}, type the above sequence of | |
31198 | keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be | |
31199 | executed while you are making the definition as well as when you later | |
31200 | re-execute the macro by typing @kbd{X}. Thus you should make sure a | |
31201 | suitable number is on the stack before defining the macro so that you | |
31202 | don't get a stack-underflow error during the definition process. | |
31203 | ||
31204 | Conditionals can be nested arbitrarily. However, there should be exactly | |
31205 | one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro. | |
31206 | ||
31207 | @kindex Z : | |
31208 | The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between | |
31209 | two keystroke sequences. The general format is @kbd{@var{cond} Z [ | |
31210 | @var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true | |
31211 | (i.e., if the top of stack contains a non-zero number after @var{cond} | |
31212 | has been executed), the @var{then-part} will be executed and the | |
31213 | @var{else-part} will be skipped. Otherwise, the @var{then-part} will | |
31214 | be skipped and the @var{else-part} will be executed. | |
31215 | ||
31216 | @kindex Z | | |
31217 | The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose | |
31218 | between any number of alternatives. For example, | |
31219 | @kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z : | |
31220 | @var{part3} Z ]} will execute @var{part1} if @var{cond1} is true, | |
31221 | otherwise it will execute @var{part2} if @var{cond2} is true, otherwise | |
31222 | it will execute @var{part3}. | |
31223 | ||
31224 | More precisely, @kbd{Z [} pops a number and conditionally skips to the | |
31225 | next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when | |
31226 | actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}. | |
31227 | @kbd{Z |} pops a number and conditionally skips to the next matching | |
31228 | @kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally | |
31229 | equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |} | |
31230 | does not. | |
31231 | ||
31232 | Calc's conditional and looping constructs work by scanning the | |
31233 | keyboard macro for occurrences of character sequences like @samp{Z:} | |
31234 | and @samp{Z]}. One side-effect of this is that if you use these | |
31235 | constructs you must be careful that these character pairs do not | |
31236 | occur by accident in other parts of the macros. Since Calc rarely | |
31237 | uses shift-@kbd{Z} for any purpose except as a prefix character, this | |
31238 | is not likely to be a problem. Another side-effect is that it will | |
31239 | not work to define your own custom key bindings for these commands. | |
31240 | Only the standard shift-@kbd{Z} bindings will work correctly. | |
31241 | ||
31242 | @kindex Z C-g | |
31243 | If Calc gets stuck while skipping characters during the definition of a | |
31244 | macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g} | |
31245 | actually adds a @kbd{C-g} keystroke to the macro.) | |
31246 | ||
31247 | @node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros | |
31248 | @subsection Loops in Keyboard Macros | |
31249 | ||
31250 | @noindent | |
31251 | @kindex Z < | |
31252 | @kindex Z > | |
31253 | @pindex calc-kbd-repeat | |
31254 | @pindex calc-kbd-end-repeat | |
31255 | @cindex Looping structures | |
31256 | @cindex Iterative structures | |
31257 | The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >} | |
31258 | (@code{calc-kbd-end-repeat}) commands pop a number from the stack, | |
31259 | which must be an integer, then repeat the keystrokes between the brackets | |
31260 | the specified number of times. If the integer is zero or negative, the | |
31261 | body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >} | |
31262 | computes two to a nonnegative integer power. First, we push 1 on the | |
31263 | stack and then swap the integer argument back to the top. The @kbd{Z <} | |
31264 | pops that argument leaving the 1 back on top of the stack. Then, we | |
a4231b04 | 31265 | repeat a multiply-by-two step however many times. |
d7b8e6c6 EZ |
31266 | |
31267 | Once again, the keyboard macro is executed as it is being entered. | |
31268 | In this case it is especially important to set up reasonable initial | |
31269 | conditions before making the definition: Suppose the integer 1000 just | |
31270 | happened to be sitting on the stack before we typed the above definition! | |
31271 | Another approach is to enter a harmless dummy definition for the macro, | |
31272 | then go back and edit in the real one with a @kbd{Z E} command. Yet | |
31273 | another approach is to type the macro as written-out keystroke names | |
58547c3e | 31274 | in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the |
d7b8e6c6 EZ |
31275 | macro. |
31276 | ||
31277 | @kindex Z / | |
31278 | @pindex calc-break | |
31279 | The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out | |
31280 | of a keyboard macro loop prematurely. It pops an object from the stack; | |
31281 | if that object is true (a non-zero number), control jumps out of the | |
31282 | innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues | |
31283 | after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no | |
31284 | effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;} | |
a4231b04 | 31285 | in the C language. |
d7b8e6c6 EZ |
31286 | |
31287 | @kindex Z ( | |
31288 | @kindex Z ) | |
31289 | @pindex calc-kbd-for | |
31290 | @pindex calc-kbd-end-for | |
31291 | The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for}) | |
31292 | commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the | |
31293 | value of the counter available inside the loop. The general layout is | |
31294 | @kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (} | |
31295 | command pops initial and final values from the stack. It then creates | |
31296 | a temporary internal counter and initializes it with the value @var{init}. | |
31297 | The @kbd{Z (} command then repeatedly pushes the counter value onto the | |
31298 | stack and executes @var{body} and @var{step}, adding @var{step} to the | |
a4231b04 | 31299 | counter each time until the loop finishes. |
d7b8e6c6 EZ |
31300 | |
31301 | @cindex Summations (by keyboard macros) | |
31302 | By default, the loop finishes when the counter becomes greater than (or | |
31303 | less than) @var{final}, assuming @var{initial} is less than (greater | |
31304 | than) @var{final}. If @var{initial} is equal to @var{final}, the body | |
31305 | executes exactly once. The body of the loop always executes at least | |
31306 | once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the | |
31307 | squares of the integers from 1 to 10, in steps of 1. | |
31308 | ||
31309 | If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is | |
31310 | forced to use upward-counting conventions. In this case, if @var{initial} | |
31311 | is greater than @var{final} the body will not be executed at all. | |
31312 | Note that @var{step} may still be negative in this loop; the prefix | |
31313 | argument merely constrains the loop-finished test. Likewise, a prefix | |
8e04863e | 31314 | argument of @mathit{-1} forces downward-counting conventions. |
d7b8e6c6 EZ |
31315 | |
31316 | @kindex Z @{ | |
31317 | @kindex Z @} | |
31318 | @pindex calc-kbd-loop | |
31319 | @pindex calc-kbd-end-loop | |
31320 | The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}} | |
31321 | (@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and | |
31322 | @kbd{Z >}, except that they do not pop a count from the stack---they | |
31323 | effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}} | |
31324 | loop ought to include at least one @kbd{Z /} to make sure the loop | |
31325 | doesn't run forever. (If any error message occurs which causes Emacs | |
31326 | to beep, the keyboard macro will also be halted; this is a standard | |
31327 | feature of Emacs. You can also generally press @kbd{C-g} to halt a | |
31328 | running keyboard macro, although not all versions of Unix support | |
31329 | this feature.) | |
31330 | ||
31331 | The conditional and looping constructs are not actually tied to | |
31332 | keyboard macros, but they are most often used in that context. | |
31333 | For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push | |
31334 | ten copies of 23 onto the stack. This can be typed ``live'' just | |
31335 | as easily as in a macro definition. | |
31336 | ||
31337 | @xref{Conditionals in Macros}, for some additional notes about | |
31338 | conditional and looping commands. | |
31339 | ||
31340 | @node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros | |
31341 | @subsection Local Values in Macros | |
31342 | ||
31343 | @noindent | |
31344 | @cindex Local variables | |
31345 | @cindex Restoring saved modes | |
31346 | Keyboard macros sometimes want to operate under known conditions | |
31347 | without affecting surrounding conditions. For example, a keyboard | |
07ce2eb3 | 31348 | macro may wish to turn on Fraction mode, or set a particular |
d7b8e6c6 EZ |
31349 | precision, independent of the user's normal setting for those |
31350 | modes. | |
31351 | ||
31352 | @kindex Z ` | |
31353 | @kindex Z ' | |
31354 | @pindex calc-kbd-push | |
31355 | @pindex calc-kbd-pop | |
31356 | Macros also sometimes need to use local variables. Assignments to | |
31357 | local variables inside the macro should not affect any variables | |
31358 | outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '} | |
31359 | (@code{calc-kbd-pop}) commands give you both of these capabilities. | |
31360 | ||
31361 | When you type @kbd{Z `} (with a backquote or accent grave character), | |
31362 | the values of various mode settings are saved away. The ten ``quick'' | |
31363 | variables @code{q0} through @code{q9} are also saved. When | |
31364 | you type @w{@kbd{Z '}} (with an apostrophe), these values are restored. | |
31365 | Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested. | |
31366 | ||
31367 | If a keyboard macro halts due to an error in between a @kbd{Z `} and | |
31368 | a @kbd{Z '}, the saved values will be restored correctly even though | |
31369 | the macro never reaches the @kbd{Z '} command. Thus you can use | |
31370 | @kbd{Z `} and @kbd{Z '} without having to worry about what happens | |
31371 | in exceptional conditions. | |
31372 | ||
31373 | If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts | |
31374 | you into a ``recursive edit.'' You can tell you are in a recursive | |
31375 | edit because there will be extra square brackets in the mode line, | |
31376 | as in @samp{[(Calculator)]}. These brackets will go away when you | |
31377 | type the matching @kbd{Z '} command. The modes and quick variables | |
31378 | will be saved and restored in just the same way as if actual keyboard | |
31379 | macros were involved. | |
31380 | ||
31381 | The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision | |
31382 | and binary word size, the angular mode (Deg, Rad, or HMS), the | |
31383 | simplification mode, Algebraic mode, Symbolic mode, Infinite mode, | |
31384 | Matrix or Scalar mode, Fraction mode, and the current complex mode | |
31385 | (Polar or Rectangular). The ten ``quick'' variables' values (or lack | |
31386 | thereof) are also saved. | |
31387 | ||
31388 | Most mode-setting commands act as toggles, but with a numeric prefix | |
31389 | they force the mode either on (positive prefix) or off (negative | |
31390 | or zero prefix). Since you don't know what the environment might | |
31391 | be when you invoke your macro, it's best to use prefix arguments | |
31392 | for all mode-setting commands inside the macro. | |
31393 | ||
31394 | In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes | |
31395 | listed above to their default values. As usual, the matching @kbd{Z '} | |
31396 | will restore the modes to their settings from before the @kbd{C-u Z `}. | |
07ce2eb3 | 31397 | Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode |
d7b8e6c6 EZ |
31398 | to its default (off) but leaves the other modes the same as they were |
31399 | outside the construct. | |
31400 | ||
31401 | The contents of the stack and trail, values of non-quick variables, and | |
31402 | other settings such as the language mode and the various display modes, | |
31403 | are @emph{not} affected by @kbd{Z `} and @kbd{Z '}. | |
31404 | ||
31405 | @node Queries in Macros, , Local Values in Macros, Keyboard Macros | |
31406 | @subsection Queries in Keyboard Macros | |
31407 | ||
faa3b6fc JB |
31408 | @c @noindent |
31409 | @c @kindex Z = | |
31410 | @c @pindex calc-kbd-report | |
31411 | @c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative | |
31412 | @c message including the value on the top of the stack. You are prompted | |
31413 | @c to enter a string. That string, along with the top-of-stack value, | |
31414 | @c is displayed unless @kbd{m w} (@code{calc-working}) has been used | |
31415 | @c to turn such messages off. | |
d7b8e6c6 | 31416 | |
faa3b6fc | 31417 | @noindent |
d7b8e6c6 EZ |
31418 | @kindex Z # |
31419 | @pindex calc-kbd-query | |
faa3b6fc JB |
31420 | The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic |
31421 | entry which takes its input from the keyboard, even during macro | |
31422 | execution. All the normal conventions of algebraic input, including the | |
31423 | use of @kbd{$} characters, are supported. The prompt message itself is | |
31424 | taken from the top of the stack, and so must be entered (as a string) | |
31425 | before the @kbd{Z #} command. (Recall, as a string it can be entered by | |
31426 | pressing the @kbd{"} key and will appear as a vector when it is put on | |
31427 | the stack. The prompt message is only put on the stack to provide a | |
31428 | prompt for the @kbd{Z #} command; it will not play any role in any | |
31429 | subsequent calculations.) This command allows your keyboard macros to | |
31430 | accept numbers or formulas as interactive input. | |
31431 | ||
31432 | As an example, | |
e9d3dbea | 31433 | @kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for |
faa3b6fc JB |
31434 | input with ``Power: '' in the minibuffer, then return 2 to the provided |
31435 | power. (The response to the prompt that's given, 3 in this example, | |
31436 | will not be part of the macro.) | |
d7b8e6c6 | 31437 | |
baf2630d | 31438 | @xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of |
d7b8e6c6 EZ |
31439 | @kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept |
31440 | keyboard input during a keyboard macro. In particular, you can use | |
31441 | @kbd{C-x q} to enter a recursive edit, which allows the user to perform | |
31442 | any Calculator operations interactively before pressing @kbd{C-M-c} to | |
31443 | return control to the keyboard macro. | |
31444 | ||
31445 | @node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming | |
31446 | @section Invocation Macros | |
31447 | ||
58547c3e | 31448 | @kindex C-x * z |
d7b8e6c6 EZ |
31449 | @kindex Z I |
31450 | @pindex calc-user-invocation | |
31451 | @pindex calc-user-define-invocation | |
58547c3e | 31452 | Calc provides one special keyboard macro, called up by @kbd{C-x * z} |
d7b8e6c6 EZ |
31453 | (@code{calc-user-invocation}), that is intended to allow you to define |
31454 | your own special way of starting Calc. To define this ``invocation | |
31455 | macro,'' create the macro in the usual way with @kbd{C-x (} and | |
31456 | @kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}). | |
31457 | There is only one invocation macro, so you don't need to type any | |
31458 | additional letters after @kbd{Z I}. From now on, you can type | |
58547c3e | 31459 | @kbd{C-x * z} at any time to execute your invocation macro. |
d7b8e6c6 EZ |
31460 | |
31461 | For example, suppose you find yourself often grabbing rectangles of | |
31462 | numbers into Calc and multiplying their columns. You can do this | |
58547c3e JB |
31463 | by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns. |
31464 | To make this into an invocation macro, just type @kbd{C-x ( C-x * r | |
d7b8e6c6 | 31465 | V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data, |
58547c3e | 31466 | just mark the data in its buffer in the usual way and type @kbd{C-x * z}. |
d7b8e6c6 EZ |
31467 | |
31468 | Invocation macros are treated like regular Emacs keyboard macros; | |
31469 | all the special features described above for @kbd{Z K}-style macros | |
58547c3e | 31470 | do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it |
d7b8e6c6 EZ |
31471 | uses the macro that was last stored by @kbd{Z I}. (In fact, the |
31472 | macro does not even have to have anything to do with Calc!) | |
31473 | ||
31474 | The @kbd{m m} command saves the last invocation macro defined by | |
31475 | @kbd{Z I} along with all the other Calc mode settings. | |
31476 | @xref{General Mode Commands}. | |
31477 | ||
31478 | @node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming | |
31479 | @section Programming with Formulas | |
31480 | ||
31481 | @noindent | |
31482 | @kindex Z F | |
31483 | @pindex calc-user-define-formula | |
31484 | @cindex Programming with algebraic formulas | |
31485 | Another way to create a new Calculator command uses algebraic formulas. | |
31486 | The @kbd{Z F} (@code{calc-user-define-formula}) command stores the | |
31487 | formula at the top of the stack as the definition for a key. This | |
31488 | command prompts for five things: The key, the command name, the function | |
31489 | name, the argument list, and the behavior of the command when given | |
31490 | non-numeric arguments. | |
31491 | ||
31492 | For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula | |
31493 | @samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this | |
31494 | formula on the @kbd{z m} key sequence. The next prompt is for a command | |
31495 | name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form | |
31496 | for the new command. If you simply press @key{RET}, a default name like | |
31497 | @code{calc-User-m} will be constructed. In our example, suppose we enter | |
31498 | @kbd{spam @key{RET}} to define the new command as @code{calc-spam}. | |
31499 | ||
31500 | If you want to give the formula a long-style name only, you can press | |
31501 | @key{SPC} or @key{RET} when asked which single key to use. For example | |
31502 | @kbd{Z F @key{RET} spam @key{RET}} defines the new command as | |
31503 | @kbd{M-x calc-spam}, with no keyboard equivalent. | |
31504 | ||
a2db4c6b JB |
31505 | The third prompt is for an algebraic function name. The default is to |
31506 | use the same name as the command name but without the @samp{calc-} | |
31507 | prefix. (If this is of the form @samp{User-m}, the hyphen is removed so | |
31508 | it won't be taken for a minus sign in algebraic formulas.) | |
31509 | This is the name you will use if you want to enter your | |
d7b8e6c6 EZ |
31510 | new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}. |
31511 | Then the new function can be invoked by pushing two numbers on the | |
31512 | stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic | |
a4231b04 | 31513 | formula @samp{yow(x,y)}. |
d7b8e6c6 EZ |
31514 | |
31515 | The fourth prompt is for the function's argument list. This is used to | |
31516 | associate values on the stack with the variables that appear in the formula. | |
31517 | The default is a list of all variables which appear in the formula, sorted | |
31518 | into alphabetical order. In our case, the default would be @samp{(a b)}. | |
31519 | This means that, when the user types @kbd{z m}, the Calculator will remove | |
31520 | two numbers from the stack, substitute these numbers for @samp{a} and | |
31521 | @samp{b} (respectively) in the formula, then simplify the formula and | |
31522 | push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m} | |
31523 | would replace the 10 and 100 on the stack with the number 210, which is | |
a4231b04 JB |
31524 | @expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula |
31525 | @samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and | |
31526 | @expr{b=100} in the definition. | |
d7b8e6c6 EZ |
31527 | |
31528 | You can rearrange the order of the names before pressing @key{RET} to | |
31529 | control which stack positions go to which variables in the formula. If | |
31530 | you remove a variable from the argument list, that variable will be left | |
31531 | in symbolic form by the command. Thus using an argument list of @samp{(b)} | |
31532 | for our function would cause @kbd{10 z m} to replace the 10 on the stack | |
31533 | with the formula @samp{a + 20}. If we had used an argument list of | |
31534 | @samp{(b a)}, the result with inputs 10 and 100 would have been 120. | |
31535 | ||
31536 | You can also put a nameless function on the stack instead of just a | |
31537 | formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}. | |
31538 | In this example, the command will be defined by the formula @samp{a + 2 b} | |
31539 | using the argument list @samp{(a b)}. | |
31540 | ||
31541 | The final prompt is a y-or-n question concerning what to do if symbolic | |
31542 | arguments are given to your function. If you answer @kbd{y}, then | |
31543 | executing @kbd{z m} (using the original argument list @samp{(a b)}) with | |
a4231b04 | 31544 | arguments @expr{10} and @expr{x} will leave the function in symbolic |
d7b8e6c6 EZ |
31545 | form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n}, |
31546 | then the formula will always be expanded, even for non-constant | |
31547 | arguments: @samp{10 + 2 x}. If you never plan to feed algebraic | |
31548 | formulas to your new function, it doesn't matter how you answer this | |
a4231b04 | 31549 | question. |
d7b8e6c6 EZ |
31550 | |
31551 | If you answered @kbd{y} to this question you can still cause a function | |
31552 | call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}). | |
31553 | Also, Calc will expand the function if necessary when you take a | |
31554 | derivative or integral or solve an equation involving the function. | |
31555 | ||
31556 | @kindex Z G | |
31557 | @pindex calc-get-user-defn | |
31558 | Once you have defined a formula on a key, you can retrieve this formula | |
31559 | with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a | |
31560 | key, and this command pushes the formula that was used to define that | |
31561 | key onto the stack. Actually, it pushes a nameless function that | |
31562 | specifies both the argument list and the defining formula. You will get | |
31563 | an error message if the key is undefined, or if the key was not defined | |
a4231b04 | 31564 | by a @kbd{Z F} command. |
d7b8e6c6 EZ |
31565 | |
31566 | The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has | |
31567 | been defined by a formula uses a variant of the @code{calc-edit} command | |
33108698 JB |
31568 | to edit the defining formula. Press @kbd{C-c C-c} to finish editing and |
31569 | store the new formula back in the definition, or kill the buffer with | |
31570 | @kbd{C-x k} to | |
d7b8e6c6 EZ |
31571 | cancel the edit. (The argument list and other properties of the |
31572 | definition are unchanged; to adjust the argument list, you can use | |
31573 | @kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and | |
31574 | then re-execute the @kbd{Z F} command.) | |
31575 | ||
31576 | As usual, the @kbd{Z P} command records your definition permanently. | |
31577 | In this case it will permanently record all three of the relevant | |
31578 | definitions: the key, the command, and the function. | |
31579 | ||
31580 | You may find it useful to turn off the default simplifications with | |
31581 | @kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be | |
31582 | used as a function definition. For example, the formula @samp{deriv(a^2,v)} | |
31583 | which might be used to define a new function @samp{dsqr(a,v)} will be | |
31584 | ``simplified'' to 0 immediately upon entry since @code{deriv} considers | |
a4231b04 | 31585 | @expr{a} to be constant with respect to @expr{v}. Turning off |
d7b8e6c6 EZ |
31586 | default simplifications cures this problem: The definition will be stored |
31587 | in symbolic form without ever activating the @code{deriv} function. Press | |
31588 | @kbd{m D} to turn the default simplifications back on afterwards. | |
31589 | ||
31590 | @node Lisp Definitions, , Algebraic Definitions, Programming | |
31591 | @section Programming with Lisp | |
31592 | ||
31593 | @noindent | |
31594 | The Calculator can be programmed quite extensively in Lisp. All you | |
31595 | do is write a normal Lisp function definition, but with @code{defmath} | |
31596 | in place of @code{defun}. This has the same form as @code{defun}, but it | |
31597 | automagically replaces calls to standard Lisp functions like @code{+} and | |
31598 | @code{zerop} with calls to the corresponding functions in Calc's own library. | |
31599 | Thus you can write natural-looking Lisp code which operates on all of the | |
31600 | standard Calculator data types. You can then use @kbd{Z D} if you wish to | |
31601 | bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command | |
31602 | will not edit a Lisp-based definition. | |
31603 | ||
31604 | Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section | |
31605 | assumes a familiarity with Lisp programming concepts; if you do not know | |
31606 | Lisp, you may find keyboard macros or rewrite rules to be an easier way | |
31607 | to program the Calculator. | |
31608 | ||
31609 | This section first discusses ways to write commands, functions, or | |
31610 | small programs to be executed inside of Calc. Then it discusses how | |
31611 | your own separate programs are able to call Calc from the outside. | |
31612 | Finally, there is a list of internal Calc functions and data structures | |
31613 | for the true Lisp enthusiast. | |
31614 | ||
31615 | @menu | |
31616 | * Defining Functions:: | |
31617 | * Defining Simple Commands:: | |
31618 | * Defining Stack Commands:: | |
31619 | * Argument Qualifiers:: | |
31620 | * Example Definitions:: | |
31621 | ||
31622 | * Calling Calc from Your Programs:: | |
31623 | * Internals:: | |
31624 | @end menu | |
31625 | ||
31626 | @node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions | |
31627 | @subsection Defining New Functions | |
31628 | ||
31629 | @noindent | |
31630 | @findex defmath | |
31631 | The @code{defmath} function (actually a Lisp macro) is like @code{defun} | |
31632 | except that code in the body of the definition can make use of the full | |
31633 | range of Calculator data types. The prefix @samp{calcFunc-} is added | |
31634 | to the specified name to get the actual Lisp function name. As a simple | |
31635 | example, | |
31636 | ||
31637 | @example | |
31638 | (defmath myfact (n) | |
31639 | (if (> n 0) | |
31640 | (* n (myfact (1- n))) | |
31641 | 1)) | |
31642 | @end example | |
31643 | ||
31644 | @noindent | |
31645 | This actually expands to the code, | |
31646 | ||
31647 | @example | |
31648 | (defun calcFunc-myfact (n) | |
31649 | (if (math-posp n) | |
31650 | (math-mul n (calcFunc-myfact (math-add n -1))) | |
31651 | 1)) | |
31652 | @end example | |
31653 | ||
31654 | @noindent | |
31655 | This function can be used in algebraic expressions, e.g., @samp{myfact(5)}. | |
31656 | ||
31657 | The @samp{myfact} function as it is defined above has the bug that an | |
31658 | expression @samp{myfact(a+b)} will be simplified to 1 because the | |
31659 | formula @samp{a+b} is not considered to be @code{posp}. A robust | |
31660 | factorial function would be written along the following lines: | |
31661 | ||
31662 | @smallexample | |
31663 | (defmath myfact (n) | |
31664 | (if (> n 0) | |
31665 | (* n (myfact (1- n))) | |
31666 | (if (= n 0) | |
31667 | 1 | |
31668 | nil))) ; this could be simplified as: (and (= n 0) 1) | |
31669 | @end smallexample | |
31670 | ||
31671 | If a function returns @code{nil}, it is left unsimplified by the Calculator | |
31672 | (except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)} | |
31673 | will be simplified to @samp{myfact(a+3)} but no further. Beware that every | |
31674 | time the Calculator reexamines this formula it will attempt to resimplify | |
31675 | it, so your function ought to detect the returning-@code{nil} case as | |
31676 | efficiently as possible. | |
31677 | ||
31678 | The following standard Lisp functions are treated by @code{defmath}: | |
31679 | @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or | |
31680 | @code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=}, | |
31681 | @code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor}, | |
31682 | @code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for | |
a4231b04 | 31683 | @code{math-nearly-equal}, which is useful in implementing Taylor series. |
d7b8e6c6 EZ |
31684 | |
31685 | For other functions @var{func}, if a function by the name | |
31686 | @samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the | |
31687 | name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself | |
31688 | is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is | |
31689 | used on the assumption that this is a to-be-defined math function. Also, if | |
31690 | the function name is quoted as in @samp{('integerp a)} the function name is | |
a4231b04 | 31691 | always used exactly as written (but not quoted). |
d7b8e6c6 EZ |
31692 | |
31693 | Variable names have @samp{var-} prepended to them unless they appear in | |
31694 | the function's argument list or in an enclosing @code{let}, @code{let*}, | |
31695 | @code{for}, or @code{foreach} form, | |
31696 | or their names already contain a @samp{-} character. Thus a reference to | |
a4231b04 | 31697 | @samp{foo} is the same as a reference to @samp{var-foo}. |
d7b8e6c6 EZ |
31698 | |
31699 | A few other Lisp extensions are available in @code{defmath} definitions: | |
31700 | ||
31701 | @itemize @bullet | |
31702 | @item | |
31703 | The @code{elt} function accepts any number of index variables. | |
31704 | Note that Calc vectors are stored as Lisp lists whose first | |
31705 | element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields | |
31706 | the second element of vector @code{v}, and @samp{(elt m i j)} | |
31707 | yields one element of a Calc matrix. | |
31708 | ||
31709 | @item | |
31710 | The @code{setq} function has been extended to act like the Common | |
31711 | Lisp @code{setf} function. (The name @code{setf} is recognized as | |
31712 | a synonym of @code{setq}.) Specifically, the first argument of | |
31713 | @code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form, | |
31714 | in which case the effect is to store into the specified | |
a4231b04 | 31715 | element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x} |
d7b8e6c6 EZ |
31716 | into one element of a matrix. |
31717 | ||
31718 | @item | |
31719 | A @code{for} looping construct is available. For example, | |
31720 | @samp{(for ((i 0 10)) body)} executes @code{body} once for each | |
a4231b04 JB |
31721 | binding of @expr{i} from zero to 10. This is like a @code{let} |
31722 | form in that @expr{i} is temporarily bound to the loop count | |
d7b8e6c6 EZ |
31723 | without disturbing its value outside the @code{for} construct. |
31724 | Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)}, | |
a4231b04 JB |
31725 | are also available. For each value of @expr{i} from zero to 10, |
31726 | @expr{j} counts from 0 to @expr{i-1} in steps of two. Note that | |
d7b8e6c6 EZ |
31727 | @code{for} has the same general outline as @code{let*}, except |
31728 | that each element of the header is a list of three or four | |
31729 | things, not just two. | |
31730 | ||
31731 | @item | |
31732 | The @code{foreach} construct loops over elements of a list. | |
31733 | For example, @samp{(foreach ((x (cdr v))) body)} executes | |
a4231b04 JB |
31734 | @code{body} with @expr{x} bound to each element of Calc vector |
31735 | @expr{v} in turn. The purpose of @code{cdr} here is to skip over | |
d7b8e6c6 EZ |
31736 | the initial @code{vec} symbol in the vector. |
31737 | ||
31738 | @item | |
31739 | The @code{break} function breaks out of the innermost enclosing | |
31740 | @code{while}, @code{for}, or @code{foreach} loop. If given a | |
31741 | value, as in @samp{(break x)}, this value is returned by the | |
31742 | loop. (Lisp loops otherwise always return @code{nil}.) | |
31743 | ||
31744 | @item | |
31745 | The @code{return} function prematurely returns from the enclosing | |
a4231b04 | 31746 | function. For example, @samp{(return (+ x y))} returns @expr{x+y} |
d7b8e6c6 EZ |
31747 | as the value of a function. You can use @code{return} anywhere |
31748 | inside the body of the function. | |
31749 | @end itemize | |
31750 | ||
31751 | Non-integer numbers (and extremely large integers) cannot be included | |
31752 | directly into a @code{defmath} definition. This is because the Lisp | |
31753 | reader will fail to parse them long before @code{defmath} ever gets control. | |
31754 | Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic | |
31755 | formula can go between the quotes. For example, | |
31756 | ||
31757 | @smallexample | |
31758 | (defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5) | |
31759 | (and (numberp x) | |
31760 | (exp :"x * 0.5"))) | |
31761 | @end smallexample | |
31762 | ||
31763 | expands to | |
31764 | ||
31765 | @smallexample | |
31766 | (defun calcFunc-sqexp (x) | |
31767 | (and (math-numberp x) | |
31768 | (calcFunc-exp (math-mul x '(float 5 -1))))) | |
31769 | @end smallexample | |
31770 | ||
31771 | Note the use of @code{numberp} as a guard to ensure that the argument is | |
31772 | a number first, returning @code{nil} if not. The exponential function | |
31773 | could itself have been included in the expression, if we had preferred: | |
31774 | @samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion | |
31775 | step of @code{myfact} could have been written | |
31776 | ||
31777 | @example | |
31778 | :"n * myfact(n-1)" | |
31779 | @end example | |
31780 | ||
3b846359 JB |
31781 | A good place to put your @code{defmath} commands is your Calc init file |
31782 | (the file given by @code{calc-settings-file}, typically | |
31783 | @file{~/.calc.el}), which will not be loaded until Calc starts. | |
d7b8e6c6 EZ |
31784 | If a file named @file{.emacs} exists in your home directory, Emacs reads |
31785 | and executes the Lisp forms in this file as it starts up. While it may | |
3b846359 | 31786 | seem reasonable to put your favorite @code{defmath} commands there, |
d7b8e6c6 EZ |
31787 | this has the unfortunate side-effect that parts of the Calculator must be |
31788 | loaded in to process the @code{defmath} commands whether or not you will | |
3b846359 JB |
31789 | actually use the Calculator! If you want to put the @code{defmath} |
31790 | commands there (for example, if you redefine @code{calc-settings-file} | |
31791 | to be @file{.emacs}), a better effect can be had by writing | |
d7b8e6c6 EZ |
31792 | |
31793 | @example | |
31794 | (put 'calc-define 'thing '(progn | |
31795 | (defmath ... ) | |
31796 | (defmath ... ) | |
31797 | )) | |
31798 | @end example | |
31799 | ||
31800 | @noindent | |
31801 | @vindex calc-define | |
31802 | The @code{put} function adds a @dfn{property} to a symbol. Each Lisp | |
31803 | symbol has a list of properties associated with it. Here we add a | |
31804 | property with a name of @code{thing} and a @samp{(progn ...)} form as | |
31805 | its value. When Calc starts up, and at the start of every Calc command, | |
31806 | the property list for the symbol @code{calc-define} is checked and the | |
31807 | values of any properties found are evaluated as Lisp forms. The | |
31808 | properties are removed as they are evaluated. The property names | |
31809 | (like @code{thing}) are not used; you should choose something like the | |
31810 | name of your project so as not to conflict with other properties. | |
31811 | ||
31812 | The net effect is that you can put the above code in your @file{.emacs} | |
31813 | file and it will not be executed until Calc is loaded. Or, you can put | |
31814 | that same code in another file which you load by hand either before or | |
31815 | after Calc itself is loaded. | |
31816 | ||
31817 | The properties of @code{calc-define} are evaluated in the same order | |
31818 | that they were added. They can assume that the Calc modules @file{calc.el}, | |
31819 | @file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and | |
31820 | that the @samp{*Calculator*} buffer will be the current buffer. | |
31821 | ||
31822 | If your @code{calc-define} property only defines algebraic functions, | |
31823 | you can be sure that it will have been evaluated before Calc tries to | |
31824 | call your function, even if the file defining the property is loaded | |
31825 | after Calc is loaded. But if the property defines commands or key | |
31826 | sequences, it may not be evaluated soon enough. (Suppose it defines the | |
31827 | new command @code{tweak-calc}; the user can load your file, then type | |
31828 | @kbd{M-x tweak-calc} before Calc has had chance to do anything.) To | |
31829 | protect against this situation, you can put | |
31830 | ||
31831 | @example | |
31832 | (run-hooks 'calc-check-defines) | |
31833 | @end example | |
31834 | ||
31835 | @findex calc-check-defines | |
31836 | @noindent | |
31837 | at the end of your file. The @code{calc-check-defines} function is what | |
31838 | looks for and evaluates properties on @code{calc-define}; @code{run-hooks} | |
31839 | has the advantage that it is quietly ignored if @code{calc-check-defines} | |
31840 | is not yet defined because Calc has not yet been loaded. | |
31841 | ||
31842 | Examples of things that ought to be enclosed in a @code{calc-define} | |
31843 | property are @code{defmath} calls, @code{define-key} calls that modify | |
31844 | the Calc key map, and any calls that redefine things defined inside Calc. | |
31845 | Ordinary @code{defun}s need not be enclosed with @code{calc-define}. | |
31846 | ||
31847 | @node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions | |
31848 | @subsection Defining New Simple Commands | |
31849 | ||
31850 | @noindent | |
31851 | @findex interactive | |
31852 | If a @code{defmath} form contains an @code{interactive} clause, it defines | |
31853 | a Calculator command. Actually such a @code{defmath} results in @emph{two} | |
31854 | function definitions: One, a @samp{calcFunc-} function as was just described, | |
31855 | with the @code{interactive} clause removed. Two, a @samp{calc-} function | |
31856 | with a suitable @code{interactive} clause and some sort of wrapper to make | |
31857 | the command work in the Calc environment. | |
31858 | ||
31859 | In the simple case, the @code{interactive} clause has the same form as | |
31860 | for normal Emacs Lisp commands: | |
31861 | ||
31862 | @smallexample | |
31863 | (defmath increase-precision (delta) | |
31864 | "Increase precision by DELTA." ; This is the "documentation string" | |
31865 | (interactive "p") ; Register this as a M-x-able command | |
31866 | (setq calc-internal-prec (+ calc-internal-prec delta))) | |
31867 | @end smallexample | |
31868 | ||
31869 | This expands to the pair of definitions, | |
31870 | ||
31871 | @smallexample | |
31872 | (defun calc-increase-precision (delta) | |
31873 | "Increase precision by DELTA." | |
31874 | (interactive "p") | |
31875 | (calc-wrapper | |
31876 | (setq calc-internal-prec (math-add calc-internal-prec delta)))) | |
31877 | ||
31878 | (defun calcFunc-increase-precision (delta) | |
31879 | "Increase precision by DELTA." | |
31880 | (setq calc-internal-prec (math-add calc-internal-prec delta))) | |
31881 | @end smallexample | |
31882 | ||
31883 | @noindent | |
31884 | where in this case the latter function would never really be used! Note | |
31885 | that since the Calculator stores small integers as plain Lisp integers, | |
31886 | the @code{math-add} function will work just as well as the native | |
31887 | @code{+} even when the intent is to operate on native Lisp integers. | |
31888 | ||
31889 | @findex calc-wrapper | |
31890 | The @samp{calc-wrapper} call invokes a macro which surrounds the body of | |
31891 | the function with code that looks roughly like this: | |
31892 | ||
31893 | @smallexample | |
31894 | (let ((calc-command-flags nil)) | |
31895 | (unwind-protect | |
31896 | (save-excursion | |
31897 | (calc-select-buffer) | |
31898 | @emph{body of function} | |
31899 | @emph{renumber stack} | |
31900 | @emph{clear} Working @emph{message}) | |
31901 | @emph{realign cursor and window} | |
31902 | @emph{clear Inverse, Hyperbolic, and Keep Args flags} | |
31903 | @emph{update Emacs mode line})) | |
31904 | @end smallexample | |
31905 | ||
31906 | @findex calc-select-buffer | |
31907 | The @code{calc-select-buffer} function selects the @samp{*Calculator*} | |
31908 | buffer if necessary, say, because the command was invoked from inside | |
31909 | the @samp{*Calc Trail*} window. | |
31910 | ||
31911 | @findex calc-set-command-flag | |
5d67986c RS |
31912 | You can call, for example, @code{(calc-set-command-flag 'no-align)} to |
31913 | set the above-mentioned command flags. Calc routines recognize the | |
31914 | following command flags: | |
d7b8e6c6 EZ |
31915 | |
31916 | @table @code | |
31917 | @item renum-stack | |
31918 | Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered | |
31919 | after this command completes. This is set by routines like | |
31920 | @code{calc-push}. | |
31921 | ||
31922 | @item clear-message | |
31923 | Calc should call @samp{(message "")} if this command completes normally | |
31924 | (to clear a ``Working@dots{}'' message out of the echo area). | |
31925 | ||
31926 | @item no-align | |
31927 | Do not move the cursor back to the @samp{.} top-of-stack marker. | |
31928 | ||
31929 | @item position-point | |
31930 | Use the variables @code{calc-position-point-line} and | |
31931 | @code{calc-position-point-column} to position the cursor after | |
31932 | this command finishes. | |
31933 | ||
31934 | @item keep-flags | |
31935 | Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag}, | |
31936 | and @code{calc-keep-args-flag} at the end of this command. | |
31937 | ||
31938 | @item do-edit | |
31939 | Switch to buffer @samp{*Calc Edit*} after this command. | |
31940 | ||
31941 | @item hold-trail | |
31942 | Do not move trail pointer to end of trail when something is recorded | |
31943 | there. | |
31944 | @end table | |
31945 | ||
31946 | @kindex Y | |
31947 | @kindex Y ? | |
31948 | @vindex calc-Y-help-msgs | |
31949 | Calc reserves a special prefix key, shift-@kbd{Y}, for user-written | |
31950 | extensions to Calc. There are no built-in commands that work with | |
31951 | this prefix key; you must call @code{define-key} from Lisp (probably | |
31952 | from inside a @code{calc-define} property) to add to it. Initially only | |
31953 | @kbd{Y ?} is defined; it takes help messages from a list of strings | |
31954 | (initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All | |
31955 | other undefined keys except for @kbd{Y} are reserved for use by | |
31956 | future versions of Calc. | |
31957 | ||
31958 | If you are writing a Calc enhancement which you expect to give to | |
31959 | others, it is best to minimize the number of @kbd{Y}-key sequences | |
31960 | you use. In fact, if you have more than one key sequence you should | |
31961 | consider defining three-key sequences with a @kbd{Y}, then a key that | |
31962 | stands for your package, then a third key for the particular command | |
31963 | within your package. | |
31964 | ||
31965 | Users may wish to install several Calc enhancements, and it is possible | |
31966 | that several enhancements will choose to use the same key. In the | |
31967 | example below, a variable @code{inc-prec-base-key} has been defined | |
31968 | to contain the key that identifies the @code{inc-prec} package. Its | |
31969 | value is initially @code{"P"}, but a user can change this variable | |
31970 | if necessary without having to modify the file. | |
31971 | ||
31972 | Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I} | |
31973 | command that increases the precision, and a @kbd{Y P D} command that | |
31974 | decreases the precision. | |
31975 | ||
31976 | @smallexample | |
31977 | ;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91. | |
91ec56a9 | 31978 | ;; (Include copyright or copyleft stuff here.) |
d7b8e6c6 EZ |
31979 | |
31980 | (defvar inc-prec-base-key "P" | |
31981 | "Base key for inc-prec.el commands.") | |
31982 | ||
31983 | (put 'calc-define 'inc-prec '(progn | |
31984 | ||
31985 | (define-key calc-mode-map (format "Y%sI" inc-prec-base-key) | |
31986 | 'increase-precision) | |
31987 | (define-key calc-mode-map (format "Y%sD" inc-prec-base-key) | |
31988 | 'decrease-precision) | |
31989 | ||
31990 | (setq calc-Y-help-msgs | |
31991 | (cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key) | |
31992 | calc-Y-help-msgs)) | |
31993 | ||
31994 | (defmath increase-precision (delta) | |
31995 | "Increase precision by DELTA." | |
31996 | (interactive "p") | |
31997 | (setq calc-internal-prec (+ calc-internal-prec delta))) | |
31998 | ||
31999 | (defmath decrease-precision (delta) | |
32000 | "Decrease precision by DELTA." | |
32001 | (interactive "p") | |
32002 | (setq calc-internal-prec (- calc-internal-prec delta))) | |
32003 | ||
32004 | )) ; end of calc-define property | |
32005 | ||
32006 | (run-hooks 'calc-check-defines) | |
32007 | @end smallexample | |
32008 | ||
32009 | @node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions | |
32010 | @subsection Defining New Stack-Based Commands | |
32011 | ||
32012 | @noindent | |
32013 | To define a new computational command which takes and/or leaves arguments | |
32014 | on the stack, a special form of @code{interactive} clause is used. | |
32015 | ||
32016 | @example | |
32017 | (interactive @var{num} @var{tag}) | |
32018 | @end example | |
32019 | ||
32020 | @noindent | |
32021 | where @var{num} is an integer, and @var{tag} is a string. The effect is | |
32022 | to pop @var{num} values off the stack, resimplify them by calling | |
32023 | @code{calc-normalize}, and hand them to your function according to the | |
32024 | function's argument list. Your function may include @code{&optional} and | |
32025 | @code{&rest} parameters, so long as calling the function with @var{num} | |
2cbd16b9 | 32026 | parameters is valid. |
d7b8e6c6 EZ |
32027 | |
32028 | Your function must return either a number or a formula in a form | |
32029 | acceptable to Calc, or a list of such numbers or formulas. These value(s) | |
32030 | are pushed onto the stack when the function completes. They are also | |
32031 | recorded in the Calc Trail buffer on a line beginning with @var{tag}, | |
32032 | a string of (normally) four characters or less. If you omit @var{tag} | |
32033 | or use @code{nil} as a tag, the result is not recorded in the trail. | |
32034 | ||
32035 | As an example, the definition | |
32036 | ||
32037 | @smallexample | |
32038 | (defmath myfact (n) | |
32039 | "Compute the factorial of the integer at the top of the stack." | |
32040 | (interactive 1 "fact") | |
32041 | (if (> n 0) | |
32042 | (* n (myfact (1- n))) | |
32043 | (and (= n 0) 1))) | |
32044 | @end smallexample | |
32045 | ||
32046 | @noindent | |
32047 | is a version of the factorial function shown previously which can be used | |
32048 | as a command as well as an algebraic function. It expands to | |
32049 | ||
32050 | @smallexample | |
32051 | (defun calc-myfact () | |
32052 | "Compute the factorial of the integer at the top of the stack." | |
32053 | (interactive) | |
32054 | (calc-slow-wrapper | |
32055 | (calc-enter-result 1 "fact" | |
32056 | (cons 'calcFunc-myfact (calc-top-list-n 1))))) | |
32057 | ||
32058 | (defun calcFunc-myfact (n) | |
32059 | "Compute the factorial of the integer at the top of the stack." | |
32060 | (if (math-posp n) | |
32061 | (math-mul n (calcFunc-myfact (math-add n -1))) | |
32062 | (and (math-zerop n) 1))) | |
32063 | @end smallexample | |
32064 | ||
32065 | @findex calc-slow-wrapper | |
32066 | The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper} | |
32067 | that automatically puts up a @samp{Working...} message before the | |
32068 | computation begins. (This message can be turned off by the user | |
32069 | with an @kbd{m w} (@code{calc-working}) command.) | |
32070 | ||
32071 | @findex calc-top-list-n | |
32072 | The @code{calc-top-list-n} function returns a list of the specified number | |
32073 | of values from the top of the stack. It resimplifies each value by | |
32074 | calling @code{calc-normalize}. If its argument is zero it returns an | |
32075 | empty list. It does not actually remove these values from the stack. | |
32076 | ||
32077 | @findex calc-enter-result | |
32078 | The @code{calc-enter-result} function takes an integer @var{num} and string | |
32079 | @var{tag} as described above, plus a third argument which is either a | |
32080 | Calculator data object or a list of such objects. These objects are | |
32081 | resimplified and pushed onto the stack after popping the specified number | |
32082 | of values from the stack. If @var{tag} is non-@code{nil}, the values | |
32083 | being pushed are also recorded in the trail. | |
32084 | ||
32085 | Note that if @code{calcFunc-myfact} returns @code{nil} this represents | |
32086 | ``leave the function in symbolic form.'' To return an actual empty list, | |
32087 | in the sense that @code{calc-enter-result} will push zero elements back | |
32088 | onto the stack, you should return the special value @samp{'(nil)}, a list | |
32089 | containing the single symbol @code{nil}. | |
32090 | ||
32091 | The @code{interactive} declaration can actually contain a limited | |
32092 | Emacs-style code string as well which comes just before @var{num} and | |
32093 | @var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in | |
32094 | ||
32095 | @example | |
32096 | (defmath foo (a b &optional c) | |
32097 | (interactive "p" 2 "foo") | |
32098 | @var{body}) | |
32099 | @end example | |
32100 | ||
32101 | In this example, the command @code{calc-foo} will evaluate the expression | |
32102 | @samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if | |
a4231b04 | 32103 | executed with a numeric prefix argument of @expr{n}. |
d7b8e6c6 EZ |
32104 | |
32105 | The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"} | |
32106 | code as used with @code{defun}). It uses the numeric prefix argument as the | |
32107 | number of objects to remove from the stack and pass to the function. | |
32108 | In this case, the integer @var{num} serves as a default number of | |
32109 | arguments to be used when no prefix is supplied. | |
32110 | ||
32111 | @node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions | |
32112 | @subsection Argument Qualifiers | |
32113 | ||
32114 | @noindent | |
32115 | Anywhere a parameter name can appear in the parameter list you can also use | |
32116 | an @dfn{argument qualifier}. Thus the general form of a definition is: | |
32117 | ||
32118 | @example | |
32119 | (defmath @var{name} (@var{param} @var{param...} | |
32120 | &optional @var{param} @var{param...} | |
32121 | &rest @var{param}) | |
32122 | @var{body}) | |
32123 | @end example | |
32124 | ||
32125 | @noindent | |
32126 | where each @var{param} is either a symbol or a list of the form | |
32127 | ||
32128 | @example | |
32129 | (@var{qual} @var{param}) | |
32130 | @end example | |
32131 | ||
32132 | The following qualifiers are recognized: | |
32133 | ||
32134 | @table @samp | |
32135 | @item complete | |
32136 | @findex complete | |
32137 | The argument must not be an incomplete vector, interval, or complex number. | |
32138 | (This is rarely needed since the Calculator itself will never call your | |
32139 | function with an incomplete argument. But there is nothing stopping your | |
a4231b04 | 32140 | own Lisp code from calling your function with an incomplete argument.) |
d7b8e6c6 EZ |
32141 | |
32142 | @item integer | |
32143 | @findex integer | |
32144 | The argument must be an integer. If it is an integer-valued float | |
32145 | it will be accepted but converted to integer form. Non-integers and | |
32146 | formulas are rejected. | |
32147 | ||
32148 | @item natnum | |
32149 | @findex natnum | |
32150 | Like @samp{integer}, but the argument must be non-negative. | |
32151 | ||
32152 | @item fixnum | |
32153 | @findex fixnum | |
32154 | Like @samp{integer}, but the argument must fit into a native Lisp integer, | |
32155 | which on most systems means less than 2^23 in absolute value. The | |
32156 | argument is converted into Lisp-integer form if necessary. | |
32157 | ||
32158 | @item float | |
32159 | @findex float | |
32160 | The argument is converted to floating-point format if it is a number or | |
32161 | vector. If it is a formula it is left alone. (The argument is never | |
32162 | actually rejected by this qualifier.) | |
32163 | ||
32164 | @item @var{pred} | |
32165 | The argument must satisfy predicate @var{pred}, which is one of the | |
32166 | standard Calculator predicates. @xref{Predicates}. | |
32167 | ||
32168 | @item not-@var{pred} | |
32169 | The argument must @emph{not} satisfy predicate @var{pred}. | |
32170 | @end table | |
32171 | ||
32172 | For example, | |
32173 | ||
32174 | @example | |
32175 | (defmath foo (a (constp (not-matrixp b)) &optional (float c) | |
32176 | &rest (integer d)) | |
32177 | @var{body}) | |
32178 | @end example | |
32179 | ||
32180 | @noindent | |
32181 | expands to | |
32182 | ||
32183 | @example | |
32184 | (defun calcFunc-foo (a b &optional c &rest d) | |
32185 | (and (math-matrixp b) | |
32186 | (math-reject-arg b 'not-matrixp)) | |
32187 | (or (math-constp b) | |
32188 | (math-reject-arg b 'constp)) | |
32189 | (and c (setq c (math-check-float c))) | |
32190 | (setq d (mapcar 'math-check-integer d)) | |
32191 | @var{body}) | |
32192 | @end example | |
32193 | ||
32194 | @noindent | |
32195 | which performs the necessary checks and conversions before executing the | |
32196 | body of the function. | |
32197 | ||
32198 | @node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions | |
32199 | @subsection Example Definitions | |
32200 | ||
32201 | @noindent | |
32202 | This section includes some Lisp programming examples on a larger scale. | |
32203 | These programs make use of some of the Calculator's internal functions; | |
32204 | @pxref{Internals}. | |
32205 | ||
32206 | @menu | |
32207 | * Bit Counting Example:: | |
32208 | * Sine Example:: | |
32209 | @end menu | |
32210 | ||
32211 | @node Bit Counting Example, Sine Example, Example Definitions, Example Definitions | |
32212 | @subsubsection Bit-Counting | |
32213 | ||
32214 | @noindent | |
5d67986c RS |
32215 | @ignore |
32216 | @starindex | |
32217 | @end ignore | |
d7b8e6c6 EZ |
32218 | @tindex bcount |
32219 | Calc does not include a built-in function for counting the number of | |
32220 | ``one'' bits in a binary integer. It's easy to invent one using @kbd{b u} | |
32221 | to convert the integer to a set, and @kbd{V #} to count the elements of | |
32222 | that set; let's write a function that counts the bits without having to | |
32223 | create an intermediate set. | |
32224 | ||
32225 | @smallexample | |
32226 | (defmath bcount ((natnum n)) | |
32227 | (interactive 1 "bcnt") | |
32228 | (let ((count 0)) | |
32229 | (while (> n 0) | |
32230 | (if (oddp n) | |
32231 | (setq count (1+ count))) | |
32232 | (setq n (lsh n -1))) | |
32233 | count)) | |
32234 | @end smallexample | |
32235 | ||
32236 | @noindent | |
32237 | When this is expanded by @code{defmath}, it will become the following | |
32238 | Emacs Lisp function: | |
32239 | ||
32240 | @smallexample | |
32241 | (defun calcFunc-bcount (n) | |
32242 | (setq n (math-check-natnum n)) | |
32243 | (let ((count 0)) | |
32244 | (while (math-posp n) | |
32245 | (if (math-oddp n) | |
32246 | (setq count (math-add count 1))) | |
32247 | (setq n (calcFunc-lsh n -1))) | |
32248 | count)) | |
32249 | @end smallexample | |
32250 | ||
32251 | If the input numbers are large, this function involves a fair amount | |
32252 | of arithmetic. A binary right shift is essentially a division by two; | |
32253 | recall that Calc stores integers in decimal form so bit shifts must | |
32254 | involve actual division. | |
32255 | ||
32256 | To gain a bit more efficiency, we could divide the integer into | |
5d67986c | 32257 | @var{n}-bit chunks, each of which can be handled quickly because |
d7b8e6c6 EZ |
32258 | they fit into Lisp integers. It turns out that Calc's arithmetic |
32259 | routines are especially fast when dividing by an integer less than | |
5d67986c | 32260 | 1000, so we can set @var{n = 9} bits and use repeated division by 512: |
d7b8e6c6 EZ |
32261 | |
32262 | @smallexample | |
32263 | (defmath bcount ((natnum n)) | |
32264 | (interactive 1 "bcnt") | |
32265 | (let ((count 0)) | |
32266 | (while (not (fixnump n)) | |
32267 | (let ((qr (idivmod n 512))) | |
32268 | (setq count (+ count (bcount-fixnum (cdr qr))) | |
32269 | n (car qr)))) | |
32270 | (+ count (bcount-fixnum n)))) | |
32271 | ||
32272 | (defun bcount-fixnum (n) | |
32273 | (let ((count 0)) | |
32274 | (while (> n 0) | |
32275 | (setq count (+ count (logand n 1)) | |
32276 | n (lsh n -1))) | |
32277 | count)) | |
32278 | @end smallexample | |
32279 | ||
32280 | @noindent | |
32281 | Note that the second function uses @code{defun}, not @code{defmath}. | |
32282 | Because this function deals only with native Lisp integers (``fixnums''), | |
32283 | it can use the actual Emacs @code{+} and related functions rather | |
32284 | than the slower but more general Calc equivalents which @code{defmath} | |
32285 | uses. | |
32286 | ||
32287 | The @code{idivmod} function does an integer division, returning both | |
32288 | the quotient and the remainder at once. Again, note that while it | |
32289 | might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are | |
32290 | more efficient ways to split off the bottom nine bits of @code{n}, | |
32291 | actually they are less efficient because each operation is really | |
32292 | a division by 512 in disguise; @code{idivmod} allows us to do the | |
32293 | same thing with a single division by 512. | |
32294 | ||
32295 | @node Sine Example, , Bit Counting Example, Example Definitions | |
32296 | @subsubsection The Sine Function | |
32297 | ||
32298 | @noindent | |
5d67986c RS |
32299 | @ignore |
32300 | @starindex | |
32301 | @end ignore | |
d7b8e6c6 EZ |
32302 | @tindex mysin |
32303 | A somewhat limited sine function could be defined as follows, using the | |
a4231b04 | 32304 | well-known Taylor series expansion for |
8e04863e | 32305 | @texline @math{\sin x}: |
a4231b04 | 32306 | @infoline @samp{sin(x)}: |
d7b8e6c6 EZ |
32307 | |
32308 | @smallexample | |
32309 | (defmath mysin ((float (anglep x))) | |
32310 | (interactive 1 "mysn") | |
32311 | (setq x (to-radians x)) ; Convert from current angular mode. | |
32312 | (let ((sum x) ; Initial term of Taylor expansion of sin. | |
32313 | newsum | |
32314 | (nfact 1) ; "nfact" equals "n" factorial at all times. | |
32315 | (xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2. | |
32316 | (for ((n 3 100 2)) ; Upper limit of 100 is a good precaution. | |
32317 | (working "mysin" sum) ; Display "Working" message, if enabled. | |
32318 | (setq nfact (* nfact (1- n) n) | |
32319 | x (* x xnegsqr) | |
32320 | newsum (+ sum (/ x nfact))) | |
32321 | (if (~= newsum sum) ; If newsum is "nearly equal to" sum, | |
32322 | (break)) ; then we are done. | |
32323 | (setq sum newsum)) | |
32324 | sum)) | |
32325 | @end smallexample | |
32326 | ||
32327 | The actual @code{sin} function in Calc works by first reducing the problem | |
a4231b04 | 32328 | to a sine or cosine of a nonnegative number less than @cpiover{4}. This |
d7b8e6c6 EZ |
32329 | ensures that the Taylor series will converge quickly. Also, the calculation |
32330 | is carried out with two extra digits of precision to guard against cumulative | |
32331 | round-off in @samp{sum}. Finally, complex arguments are allowed and handled | |
32332 | by a separate algorithm. | |
32333 | ||
32334 | @smallexample | |
32335 | (defmath mysin ((float (scalarp x))) | |
32336 | (interactive 1 "mysn") | |
32337 | (setq x (to-radians x)) ; Convert from current angular mode. | |
32338 | (with-extra-prec 2 ; Evaluate with extra precision. | |
32339 | (cond ((complexp x) | |
32340 | (mysin-complex x)) | |
32341 | ((< x 0) | |
32342 | (- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0. | |
32343 | (t (mysin-raw x)))))) | |
32344 | ||
32345 | (defmath mysin-raw (x) | |
32346 | (cond ((>= x 7) | |
32347 | (mysin-raw (% x (two-pi)))) ; Now x < 7. | |
32348 | ((> x (pi-over-2)) | |
32349 | (- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2. | |
32350 | ((> x (pi-over-4)) | |
32351 | (mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4. | |
32352 | ((< x (- (pi-over-4))) | |
32353 | (- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4, | |
32354 | (t (mysin-series x)))) ; so the series will be efficient. | |
32355 | @end smallexample | |
32356 | ||
32357 | @noindent | |
32358 | where @code{mysin-complex} is an appropriate function to handle complex | |
32359 | numbers, @code{mysin-series} is the routine to compute the sine Taylor | |
32360 | series as before, and @code{mycos-raw} is a function analogous to | |
32361 | @code{mysin-raw} for cosines. | |
32362 | ||
a4231b04 | 32363 | The strategy is to ensure that @expr{x} is nonnegative before calling |
d7b8e6c6 | 32364 | @code{mysin-raw}. This function then recursively reduces its argument |
a4231b04 | 32365 | to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each |
d7b8e6c6 | 32366 | test, and particularly the first comparison against 7, is designed so |
28665d46 | 32367 | that small roundoff errors cannot produce an infinite loop. (Suppose |
d7b8e6c6 EZ |
32368 | we compared with @samp{(two-pi)} instead; if due to roundoff problems |
32369 | the modulo operator ever returned @samp{(two-pi)} exactly, an infinite | |
32370 | recursion could result!) We use modulo only for arguments that will | |
32371 | clearly get reduced, knowing that the next rule will catch any reductions | |
32372 | that this rule misses. | |
32373 | ||
32374 | If a program is being written for general use, it is important to code | |
32375 | it carefully as shown in this second example. For quick-and-dirty programs, | |
32376 | when you know that your own use of the sine function will never encounter | |
32377 | a large argument, a simpler program like the first one shown is fine. | |
32378 | ||
32379 | @node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions | |
32380 | @subsection Calling Calc from Your Lisp Programs | |
32381 | ||
32382 | @noindent | |
32383 | A later section (@pxref{Internals}) gives a full description of | |
32384 | Calc's internal Lisp functions. It's not hard to call Calc from | |
32385 | inside your programs, but the number of these functions can be daunting. | |
32386 | So Calc provides one special ``programmer-friendly'' function called | |
32387 | @code{calc-eval} that can be made to do just about everything you | |
32388 | need. It's not as fast as the low-level Calc functions, but it's | |
32389 | much simpler to use! | |
32390 | ||
32391 | It may seem that @code{calc-eval} itself has a daunting number of | |
32392 | options, but they all stem from one simple operation. | |
32393 | ||
32394 | In its simplest manifestation, @samp{(calc-eval "1+2")} parses the | |
32395 | string @code{"1+2"} as if it were a Calc algebraic entry and returns | |
32396 | the result formatted as a string: @code{"3"}. | |
32397 | ||
32398 | Since @code{calc-eval} is on the list of recommended @code{autoload} | |
32399 | functions, you don't need to make any special preparations to load | |
32400 | Calc before calling @code{calc-eval} the first time. Calc will be | |
32401 | loaded and initialized for you. | |
32402 | ||
32403 | All the Calc modes that are currently in effect will be used when | |
32404 | evaluating the expression and formatting the result. | |
32405 | ||
32406 | @ifinfo | |
32407 | @example | |
32408 | ||
32409 | @end example | |
32410 | @end ifinfo | |
32411 | @subsubsection Additional Arguments to @code{calc-eval} | |
32412 | ||
32413 | @noindent | |
32414 | If the input string parses to a list of expressions, Calc returns | |
32415 | the results separated by @code{", "}. You can specify a different | |
32416 | separator by giving a second string argument to @code{calc-eval}: | |
32417 | @samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}. | |
32418 | ||
32419 | The ``separator'' can also be any of several Lisp symbols which | |
32420 | request other behaviors from @code{calc-eval}. These are discussed | |
32421 | one by one below. | |
32422 | ||
32423 | You can give additional arguments to be substituted for | |
32424 | @samp{$}, @samp{$$}, and so on in the main expression. For | |
32425 | example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the | |
32426 | expression @code{"7/(1+1)"} to yield the result @code{"3.5"} | |
32427 | (assuming Fraction mode is not in effect). Note the @code{nil} | |
32428 | used as a placeholder for the item-separator argument. | |
32429 | ||
32430 | @ifinfo | |
32431 | @example | |
32432 | ||
32433 | @end example | |
32434 | @end ifinfo | |
32435 | @subsubsection Error Handling | |
32436 | ||
32437 | @noindent | |
32438 | If @code{calc-eval} encounters an error, it returns a list containing | |
32439 | the character position of the error, plus a suitable message as a | |
32440 | string. Note that @samp{1 / 0} is @emph{not} an error by Calc's | |
32441 | standards; it simply returns the string @code{"1 / 0"} which is the | |
32442 | division left in symbolic form. But @samp{(calc-eval "1/")} will | |
32443 | return the list @samp{(2 "Expected a number")}. | |
32444 | ||
32445 | If you bind the variable @code{calc-eval-error} to @code{t} | |
32446 | using a @code{let} form surrounding the call to @code{calc-eval}, | |
32447 | errors instead call the Emacs @code{error} function which aborts | |
32448 | to the Emacs command loop with a beep and an error message. | |
32449 | ||
32450 | If you bind this variable to the symbol @code{string}, error messages | |
32451 | are returned as strings instead of lists. The character position is | |
32452 | ignored. | |
32453 | ||
32454 | As a courtesy to other Lisp code which may be using Calc, be sure | |
32455 | to bind @code{calc-eval-error} using @code{let} rather than changing | |
32456 | it permanently with @code{setq}. | |
32457 | ||
32458 | @ifinfo | |
32459 | @example | |
32460 | ||
32461 | @end example | |
32462 | @end ifinfo | |
32463 | @subsubsection Numbers Only | |
32464 | ||
32465 | @noindent | |
32466 | Sometimes it is preferable to treat @samp{1 / 0} as an error | |
32467 | rather than returning a symbolic result. If you pass the symbol | |
32468 | @code{num} as the second argument to @code{calc-eval}, results | |
32469 | that are not constants are treated as errors. The error message | |
32470 | reported is the first @code{calc-why} message if there is one, | |
32471 | or otherwise ``Number expected.'' | |
32472 | ||
32473 | A result is ``constant'' if it is a number, vector, or other | |
32474 | object that does not include variables or function calls. If it | |
32475 | is a vector, the components must themselves be constants. | |
32476 | ||
32477 | @ifinfo | |
32478 | @example | |
32479 | ||
32480 | @end example | |
32481 | @end ifinfo | |
32482 | @subsubsection Default Modes | |
32483 | ||
32484 | @noindent | |
32485 | If the first argument to @code{calc-eval} is a list whose first | |
32486 | element is a formula string, then @code{calc-eval} sets all the | |
32487 | various Calc modes to their default values while the formula is | |
32488 | evaluated and formatted. For example, the precision is set to 12 | |
07ce2eb3 | 32489 | digits, digit grouping is turned off, and the Normal language |
d7b8e6c6 EZ |
32490 | mode is used. |
32491 | ||
32492 | This same principle applies to the other options discussed below. | |
32493 | If the first argument would normally be @var{x}, then it can also | |
32494 | be the list @samp{(@var{x})} to use the default mode settings. | |
32495 | ||
32496 | If there are other elements in the list, they are taken as | |
32497 | variable-name/value pairs which override the default mode | |
32498 | settings. Look at the documentation at the front of the | |
32499 | @file{calc.el} file to find the names of the Lisp variables for | |
32500 | the various modes. The mode settings are restored to their | |
32501 | original values when @code{calc-eval} is done. | |
32502 | ||
32503 | For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)} | |
32504 | computes the sum of two numbers, requiring a numeric result, and | |
32505 | using default mode settings except that the precision is 8 instead | |
32506 | of the default of 12. | |
32507 | ||
32508 | It's usually best to use this form of @code{calc-eval} unless your | |
32509 | program actually considers the interaction with Calc's mode settings | |
32510 | to be a feature. This will avoid all sorts of potential ``gotchas''; | |
32511 | consider what happens with @samp{(calc-eval "sqrt(2)" 'num)} | |
07ce2eb3 | 32512 | when the user has left Calc in Symbolic mode or No-Simplify mode. |
d7b8e6c6 EZ |
32513 | |
32514 | As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")} | |
a4231b04 JB |
32515 | checks if the number in string @expr{a} is less than the one in |
32516 | string @expr{b}. Without using a list, the integer 1 might | |
d7b8e6c6 EZ |
32517 | come out in a variety of formats which would be hard to test for |
32518 | conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But | |
32519 | see ``Predicates'' mode, below.) | |
32520 | ||
32521 | @ifinfo | |
32522 | @example | |
32523 | ||
32524 | @end example | |
32525 | @end ifinfo | |
32526 | @subsubsection Raw Numbers | |
32527 | ||
32528 | @noindent | |
32529 | Normally all input and output for @code{calc-eval} is done with strings. | |
32530 | You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)} | |
32531 | in place of @samp{(+ a b)}, but this is very inefficient since the | |
32532 | numbers must be converted to and from string format as they are passed | |
32533 | from one @code{calc-eval} to the next. | |
32534 | ||
32535 | If the separator is the symbol @code{raw}, the result will be returned | |
32536 | as a raw Calc data structure rather than a string. You can read about | |
32537 | how these objects look in the following sections, but usually you can | |
32538 | treat them as ``black box'' objects with no important internal | |
32539 | structure. | |
32540 | ||
32541 | There is also a @code{rawnum} symbol, which is a combination of | |
28665d46 | 32542 | @code{raw} (returning a raw Calc object) and @code{num} (signaling |
d7b8e6c6 EZ |
32543 | an error if that object is not a constant). |
32544 | ||
32545 | You can pass a raw Calc object to @code{calc-eval} in place of a | |
32546 | string, either as the formula itself or as one of the @samp{$} | |
32547 | arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an | |
32548 | addition function that operates on raw Calc objects. Of course | |
32549 | in this case it would be easier to call the low-level @code{math-add} | |
32550 | function in Calc, if you can remember its name. | |
32551 | ||
32552 | In particular, note that a plain Lisp integer is acceptable to Calc | |
32553 | as a raw object. (All Lisp integers are accepted on input, but | |
32554 | integers of more than six decimal digits are converted to ``big-integer'' | |
32555 | form for output. @xref{Data Type Formats}.) | |
32556 | ||
32557 | When it comes time to display the object, just use @samp{(calc-eval a)} | |
32558 | to format it as a string. | |
32559 | ||
32560 | It is an error if the input expression evaluates to a list of | |
32561 | values. The separator symbol @code{list} is like @code{raw} | |
32562 | except that it returns a list of one or more raw Calc objects. | |
32563 | ||
32564 | Note that a Lisp string is not a valid Calc object, nor is a list | |
32565 | containing a string. Thus you can still safely distinguish all the | |
32566 | various kinds of error returns discussed above. | |
32567 | ||
32568 | @ifinfo | |
32569 | @example | |
32570 | ||
32571 | @end example | |
32572 | @end ifinfo | |
32573 | @subsubsection Predicates | |
32574 | ||
32575 | @noindent | |
32576 | If the separator symbol is @code{pred}, the result of the formula is | |
32577 | treated as a true/false value; @code{calc-eval} returns @code{t} or | |
32578 | @code{nil}, respectively. A value is considered ``true'' if it is a | |
32579 | non-zero number, or false if it is zero or if it is not a number. | |
32580 | ||
32581 | For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether | |
32582 | one value is less than another. | |
32583 | ||
32584 | As usual, it is also possible for @code{calc-eval} to return one of | |
32585 | the error indicators described above. Lisp will interpret such an | |
32586 | indicator as ``true'' if you don't check for it explicitly. If you | |
32587 | wish to have an error register as ``false'', use something like | |
32588 | @samp{(eq (calc-eval ...) t)}. | |
32589 | ||
32590 | @ifinfo | |
32591 | @example | |
32592 | ||
32593 | @end example | |
32594 | @end ifinfo | |
32595 | @subsubsection Variable Values | |
32596 | ||
32597 | @noindent | |
32598 | Variables in the formula passed to @code{calc-eval} are not normally | |
32599 | replaced by their values. If you wish this, you can use the | |
32600 | @code{evalv} function (@pxref{Algebraic Manipulation}). For example, | |
32601 | if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable | |
32602 | @code{var-a}), then @samp{(calc-eval "a+pi")} will return the | |
32603 | formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")} | |
32604 | will return @code{"7.14159265359"}. | |
32605 | ||
32606 | To store in a Calc variable, just use @code{setq} to store in the | |
32607 | corresponding Lisp variable. (This is obtained by prepending | |
32608 | @samp{var-} to the Calc variable name.) Calc routines will | |
32609 | understand either string or raw form values stored in variables, | |
32610 | although raw data objects are much more efficient. For example, | |
32611 | to increment the Calc variable @code{a}: | |
32612 | ||
32613 | @example | |
32614 | (setq var-a (calc-eval "evalv(a+1)" 'raw)) | |
32615 | @end example | |
32616 | ||
32617 | @ifinfo | |
32618 | @example | |
32619 | ||
32620 | @end example | |
32621 | @end ifinfo | |
32622 | @subsubsection Stack Access | |
32623 | ||
32624 | @noindent | |
32625 | If the separator symbol is @code{push}, the formula argument is | |
32626 | evaluated (with possible @samp{$} expansions, as usual). The | |
32627 | result is pushed onto the Calc stack. The return value is @code{nil} | |
32628 | (unless there is an error from evaluating the formula, in which | |
32629 | case the return value depends on @code{calc-eval-error} in the | |
32630 | usual way). | |
32631 | ||
32632 | If the separator symbol is @code{pop}, the first argument to | |
32633 | @code{calc-eval} must be an integer instead of a string. That | |
32634 | many values are popped from the stack and thrown away. A negative | |
32635 | argument deletes the entry at that stack level. The return value | |
32636 | is the number of elements remaining in the stack after popping; | |
32637 | @samp{(calc-eval 0 'pop)} is a good way to measure the size of | |
32638 | the stack. | |
32639 | ||
32640 | If the separator symbol is @code{top}, the first argument to | |
32641 | @code{calc-eval} must again be an integer. The value at that | |
32642 | stack level is formatted as a string and returned. Thus | |
32643 | @samp{(calc-eval 1 'top)} returns the top-of-stack value. If the | |
32644 | integer is out of range, @code{nil} is returned. | |
32645 | ||
32646 | The separator symbol @code{rawtop} is just like @code{top} except | |
32647 | that the stack entry is returned as a raw Calc object instead of | |
32648 | as a string. | |
32649 | ||
32650 | In all of these cases the first argument can be made a list in | |
32651 | order to force the default mode settings, as described above. | |
32652 | Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the | |
32653 | second-to-top stack entry, formatted as a string using the default | |
32654 | instead of current display modes, except that the radix is | |
32655 | hexadecimal instead of decimal. | |
32656 | ||
32657 | It is, of course, polite to put the Calc stack back the way you | |
32658 | found it when you are done, unless the user of your program is | |
32659 | actually expecting it to affect the stack. | |
32660 | ||
32661 | Note that you do not actually have to switch into the @samp{*Calculator*} | |
32662 | buffer in order to use @code{calc-eval}; it temporarily switches into | |
32663 | the stack buffer if necessary. | |
32664 | ||
32665 | @ifinfo | |
32666 | @example | |
32667 | ||
32668 | @end example | |
32669 | @end ifinfo | |
32670 | @subsubsection Keyboard Macros | |
32671 | ||
32672 | @noindent | |
32673 | If the separator symbol is @code{macro}, the first argument must be a | |
32674 | string of characters which Calc can execute as a sequence of keystrokes. | |
32675 | This switches into the Calc buffer for the duration of the macro. | |
32676 | For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the | |
32677 | vector @samp{[1,2,3,4,5]} on the stack and then replaces it | |
32678 | with the sum of those numbers. Note that @samp{\r} is the Lisp | |
32679 | notation for the carriage-return, @key{RET}, character. | |
32680 | ||
32681 | If your keyboard macro wishes to pop the stack, @samp{\C-d} is | |
32682 | safer than @samp{\177} (the @key{DEL} character) because some | |
32683 | installations may have switched the meanings of @key{DEL} and | |
32684 | @kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for | |
32685 | ``pop-stack'' regardless of key mapping. | |
32686 | ||
32687 | If you provide a third argument to @code{calc-eval}, evaluation | |
32688 | of the keyboard macro will leave a record in the Trail using | |
32689 | that argument as a tag string. Normally the Trail is unaffected. | |
32690 | ||
32691 | The return value in this case is always @code{nil}. | |
32692 | ||
32693 | @ifinfo | |
32694 | @example | |
32695 | ||
32696 | @end example | |
32697 | @end ifinfo | |
32698 | @subsubsection Lisp Evaluation | |
32699 | ||
32700 | @noindent | |
32701 | Finally, if the separator symbol is @code{eval}, then the Lisp | |
32702 | @code{eval} function is called on the first argument, which must | |
32703 | be a Lisp expression rather than a Calc formula. Remember to | |
32704 | quote the expression so that it is not evaluated until inside | |
32705 | @code{calc-eval}. | |
32706 | ||
32707 | The difference from plain @code{eval} is that @code{calc-eval} | |
32708 | switches to the Calc buffer before evaluating the expression. | |
32709 | For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)} | |
32710 | will correctly affect the buffer-local Calc precision variable. | |
32711 | ||
32712 | An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}. | |
32713 | This is evaluating a call to the function that is normally invoked | |
32714 | by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.'' | |
32715 | Note that this function will leave a message in the echo area as | |
32716 | a side effect. Also, all Calc functions switch to the Calc buffer | |
32717 | automatically if not invoked from there, so the above call is | |
32718 | also equivalent to @samp{(calc-precision 17)} by itself. | |
32719 | In all cases, Calc uses @code{save-excursion} to switch back to | |
32720 | your original buffer when it is done. | |
32721 | ||
32722 | As usual the first argument can be a list that begins with a Lisp | |
32723 | expression to use default instead of current mode settings. | |
32724 | ||
32725 | The result of @code{calc-eval} in this usage is just the result | |
32726 | returned by the evaluated Lisp expression. | |
32727 | ||
32728 | @ifinfo | |
32729 | @example | |
32730 | ||
32731 | @end example | |
32732 | @end ifinfo | |
32733 | @subsubsection Example | |
32734 | ||
32735 | @noindent | |
32736 | @findex convert-temp | |
32737 | Here is a sample Emacs command that uses @code{calc-eval}. Suppose | |
32738 | you have a document with lots of references to temperatures on the | |
32739 | Fahrenheit scale, say ``98.6 F'', and you wish to convert these | |
32740 | references to Centigrade. The following command does this conversion. | |
32741 | Place the Emacs cursor right after the letter ``F'' and invoke the | |
32742 | command to change ``98.6 F'' to ``37 C''. Or, if the temperature is | |
32743 | already in Centigrade form, the command changes it back to Fahrenheit. | |
32744 | ||
32745 | @example | |
32746 | (defun convert-temp () | |
32747 | (interactive) | |
32748 | (save-excursion | |
32749 | (re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)") | |
32750 | (let* ((top1 (match-beginning 1)) | |
32751 | (bot1 (match-end 1)) | |
32752 | (number (buffer-substring top1 bot1)) | |
32753 | (top2 (match-beginning 2)) | |
32754 | (bot2 (match-end 2)) | |
32755 | (type (buffer-substring top2 bot2))) | |
32756 | (if (equal type "F") | |
32757 | (setq type "C" | |
32758 | number (calc-eval "($ - 32)*5/9" nil number)) | |
32759 | (setq type "F" | |
32760 | number (calc-eval "$*9/5 + 32" nil number))) | |
32761 | (goto-char top2) | |
32762 | (delete-region top2 bot2) | |
32763 | (insert-before-markers type) | |
32764 | (goto-char top1) | |
32765 | (delete-region top1 bot1) | |
32766 | (if (string-match "\\.$" number) ; change "37." to "37" | |
32767 | (setq number (substring number 0 -1))) | |
32768 | (insert number)))) | |
32769 | @end example | |
32770 | ||
32771 | Note the use of @code{insert-before-markers} when changing between | |
32772 | ``F'' and ``C'', so that the character winds up before the cursor | |
32773 | instead of after it. | |
32774 | ||
32775 | @node Internals, , Calling Calc from Your Programs, Lisp Definitions | |
32776 | @subsection Calculator Internals | |
32777 | ||
32778 | @noindent | |
32779 | This section describes the Lisp functions defined by the Calculator that | |
32780 | may be of use to user-written Calculator programs (as described in the | |
32781 | rest of this chapter). These functions are shown by their names as they | |
32782 | conventionally appear in @code{defmath}. Their full Lisp names are | |
32783 | generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their | |
32784 | apparent names. (Names that begin with @samp{calc-} are already in | |
32785 | their full Lisp form.) You can use the actual full names instead if you | |
32786 | prefer them, or if you are calling these functions from regular Lisp. | |
32787 | ||
32788 | The functions described here are scattered throughout the various | |
32789 | Calc component files. Note that @file{calc.el} includes @code{autoload}s | |
32790 | for only a few component files; when Calc wants to call an advanced | |
32791 | function it calls @samp{(calc-extensions)} first; this function | |
32792 | autoloads @file{calc-ext.el}, which in turn autoloads all the functions | |
32793 | in the remaining component files. | |
32794 | ||
32795 | Because @code{defmath} itself uses the extensions, user-written code | |
32796 | generally always executes with the extensions already loaded, so | |
32797 | normally you can use any Calc function and be confident that it will | |
32798 | be autoloaded for you when necessary. If you are doing something | |
32799 | special, check carefully to make sure each function you are using is | |
32800 | from @file{calc.el} or its components, and call @samp{(calc-extensions)} | |
32801 | before using any function based in @file{calc-ext.el} if you can't | |
32802 | prove this file will already be loaded. | |
32803 | ||
32804 | @menu | |
32805 | * Data Type Formats:: | |
32806 | * Interactive Lisp Functions:: | |
32807 | * Stack Lisp Functions:: | |
32808 | * Predicates:: | |
32809 | * Computational Lisp Functions:: | |
32810 | * Vector Lisp Functions:: | |
32811 | * Symbolic Lisp Functions:: | |
32812 | * Formatting Lisp Functions:: | |
32813 | * Hooks:: | |
32814 | @end menu | |
32815 | ||
32816 | @node Data Type Formats, Interactive Lisp Functions, Internals, Internals | |
32817 | @subsubsection Data Type Formats | |
32818 | ||
32819 | @noindent | |
32820 | Integers are stored in either of two ways, depending on their magnitude. | |
32821 | Integers less than one million in absolute value are stored as standard | |
32822 | Lisp integers. This is the only storage format for Calc data objects | |
32823 | which is not a Lisp list. | |
32824 | ||
32825 | Large integers are stored as lists of the form @samp{(bigpos @var{d0} | |
32826 | @var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or | |
32827 | @samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers | |
8e04863e | 32828 | @mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer |
d7b8e6c6 EZ |
32829 | from 0 to 999. The least significant digit is @var{d0}; the last digit, |
32830 | @var{dn}, which is always nonzero, is the most significant digit. For | |
8e04863e | 32831 | example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}. |
d7b8e6c6 EZ |
32832 | |
32833 | The distinction between small and large integers is entirely hidden from | |
32834 | the user. In @code{defmath} definitions, the Lisp predicate @code{integerp} | |
32835 | returns true for either kind of integer, and in general both big and small | |
32836 | integers are accepted anywhere the word ``integer'' is used in this manual. | |
32837 | If the distinction must be made, native Lisp integers are called @dfn{fixnums} | |
32838 | and large integers are called @dfn{bignums}. | |
32839 | ||
32840 | Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})} | |
32841 | where @var{n} is an integer (big or small) numerator, @var{d} is an | |
32842 | integer denominator greater than one, and @var{n} and @var{d} are relatively | |
32843 | prime. Note that fractions where @var{d} is one are automatically converted | |
32844 | to plain integers by all math routines; fractions where @var{d} is negative | |
32845 | are normalized by negating the numerator and denominator. | |
32846 | ||
32847 | Floating-point numbers are stored in the form, @samp{(float @var{mant} | |
32848 | @var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than | |
32849 | @samp{10^@var{p}} in absolute value (@var{p} represents the current | |
32850 | precision), and @var{exp} (the ``exponent'') is a fixnum. The value of | |
32851 | the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number | |
8e04863e | 32852 | @mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints |
d7b8e6c6 EZ |
32853 | are that the number 0.0 is always stored as @samp{(float 0 0)}, and, |
32854 | except for the 0.0 case, the rightmost base-10 digit of @var{mant} is | |
32855 | always nonzero. (If the rightmost digit is zero, the number is | |
a4231b04 | 32856 | rearranged by dividing @var{mant} by ten and incrementing @var{exp}.) |
d7b8e6c6 EZ |
32857 | |
32858 | Rectangular complex numbers are stored in the form @samp{(cplx @var{re} | |
32859 | @var{im})}, where @var{re} and @var{im} are each real numbers, either | |
32860 | integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}. | |
32861 | The @var{im} part is nonzero; complex numbers with zero imaginary | |
a4231b04 | 32862 | components are converted to real numbers automatically. |
d7b8e6c6 EZ |
32863 | |
32864 | Polar complex numbers are stored in the form @samp{(polar @var{r} | |
32865 | @var{theta})}, where @var{r} is a positive real value and @var{theta} | |
32866 | is a real value or HMS form representing an angle. This angle is | |
32867 | usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees, | |
32868 | or @samp{(-pi ..@: pi)} radians, according to the current angular mode. | |
32869 | If the angle is 0 the value is converted to a real number automatically. | |
32870 | (If the angle is 180 degrees, the value is usually also converted to a | |
a4231b04 | 32871 | negative real number.) |
d7b8e6c6 EZ |
32872 | |
32873 | Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m} | |
32874 | @var{s})}, where @var{h} is an integer or an integer-valued float (i.e., | |
32875 | a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued | |
32876 | float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number | |
a4231b04 | 32877 | in the range @samp{[0 ..@: 60)}. |
d7b8e6c6 EZ |
32878 | |
32879 | Date forms are stored as @samp{(date @var{n})}, where @var{n} is | |
32880 | a real number that counts days since midnight on the morning of | |
32881 | January 1, 1 AD. If @var{n} is an integer, this is a pure date | |
32882 | form. If @var{n} is a fraction or float, this is a date/time form. | |
32883 | ||
32884 | Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a | |
32885 | positive real number or HMS form, and @var{n} is a real number or HMS | |
32886 | form in the range @samp{[0 ..@: @var{m})}. | |
32887 | ||
32888 | Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x} | |
32889 | is the mean value and @var{sigma} is the standard deviation. Each | |
32890 | component is either a number, an HMS form, or a symbolic object | |
32891 | (a variable or function call). If @var{sigma} is zero, the value is | |
32892 | converted to a plain real number. If @var{sigma} is negative or | |
32893 | complex, it is automatically normalized to be a positive real. | |
32894 | ||
32895 | Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})}, | |
32896 | where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and | |
32897 | @var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask} | |
32898 | is a binary integer where 1 represents the fact that the interval is | |
32899 | closed on the high end, and 2 represents the fact that it is closed on | |
32900 | the low end. (Thus 3 represents a fully closed interval.) The interval | |
32901 | @w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x}; | |
32902 | intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask} | |
32903 | represent empty intervals. If @var{hi} is less than @var{lo}, the interval | |
32904 | is converted to a standard empty interval by replacing @var{hi} with @var{lo}. | |
32905 | ||
32906 | Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1} | |
32907 | is the first element of the vector, @var{v2} is the second, and so on. | |
32908 | An empty vector is stored as @samp{(vec)}. A matrix is simply a vector | |
32909 | where all @var{v}'s are themselves vectors of equal lengths. Note that | |
32910 | Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is | |
32911 | generally unused by Calc data structures. | |
32912 | ||
32913 | Variables are stored as @samp{(var @var{name} @var{sym})}, where | |
32914 | @var{name} is a Lisp symbol whose print name is used as the visible name | |
32915 | of the variable, and @var{sym} is a Lisp symbol in which the variable's | |
32916 | value is actually stored. Thus, @samp{(var pi var-pi)} represents the | |
32917 | special constant @samp{pi}. Almost always, the form is @samp{(var | |
32918 | @var{v} var-@var{v})}. If the variable name was entered with @code{#} | |
32919 | signs (which are converted to hyphens internally), the form is | |
32920 | @samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name | |
32921 | contains @code{#} characters, and @var{v} is a symbol that contains | |
32922 | @code{-} characters instead. The value of a variable is the Calc | |
32923 | object stored in its @var{sym} symbol's value cell. If the symbol's | |
32924 | value cell is void or if it contains @code{nil}, the variable has no | |
32925 | value. Special constants have the form @samp{(special-const | |
32926 | @var{value})} stored in their value cell, where @var{value} is a formula | |
32927 | which is evaluated when the constant's value is requested. Variables | |
32928 | which represent units are not stored in any special way; they are units | |
32929 | only because their names appear in the units table. If the value | |
32930 | cell contains a string, it is parsed to get the variable's value when | |
a4231b04 | 32931 | the variable is used. |
d7b8e6c6 EZ |
32932 | |
32933 | A Lisp list with any other symbol as the first element is a function call. | |
32934 | The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^}, | |
32935 | and @code{|} represent special binary operators; these lists are always | |
32936 | of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the | |
32937 | sub-formula on the lefthand side and @var{rhs} is the sub-formula on the | |
32938 | right. The symbol @code{neg} represents unary negation; this list is always | |
32939 | of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a | |
32940 | function that would be displayed in function-call notation; the symbol | |
32941 | @var{func} is in general always of the form @samp{calcFunc-@var{name}}. | |
32942 | The function cell of the symbol @var{func} should contain a Lisp function | |
32943 | for evaluating a call to @var{func}. This function is passed the remaining | |
32944 | elements of the list (themselves already evaluated) as arguments; such | |
32945 | functions should return @code{nil} or call @code{reject-arg} to signify | |
32946 | that they should be left in symbolic form, or they should return a Calc | |
32947 | object which represents their value, or a list of such objects if they | |
32948 | wish to return multiple values. (The latter case is allowed only for | |
32949 | functions which are the outer-level call in an expression whose value is | |
32950 | about to be pushed on the stack; this feature is considered obsolete | |
a4231b04 | 32951 | and is not used by any built-in Calc functions.) |
d7b8e6c6 EZ |
32952 | |
32953 | @node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals | |
32954 | @subsubsection Interactive Functions | |
32955 | ||
32956 | @noindent | |
32957 | The functions described here are used in implementing interactive Calc | |
32958 | commands. Note that this list is not exhaustive! If there is an | |
32959 | existing command that behaves similarly to the one you want to define, | |
32960 | you may find helpful tricks by checking the source code for that command. | |
32961 | ||
32962 | @defun calc-set-command-flag flag | |
32963 | Set the command flag @var{flag}. This is generally a Lisp symbol, but | |
32964 | may in fact be anything. The effect is to add @var{flag} to the list | |
32965 | stored in the variable @code{calc-command-flags}, unless it is already | |
32966 | there. @xref{Defining Simple Commands}. | |
32967 | @end defun | |
32968 | ||
32969 | @defun calc-clear-command-flag flag | |
32970 | If @var{flag} appears among the list of currently-set command flags, | |
32971 | remove it from that list. | |
32972 | @end defun | |
32973 | ||
32974 | @defun calc-record-undo rec | |
32975 | Add the ``undo record'' @var{rec} to the list of steps to take if the | |
32976 | current operation should need to be undone. Stack push and pop functions | |
32977 | automatically call @code{calc-record-undo}, so the kinds of undo records | |
32978 | you might need to create take the form @samp{(set @var{sym} @var{value})}, | |
32979 | which says that the Lisp variable @var{sym} was changed and had previously | |
32980 | contained @var{value}; @samp{(store @var{var} @var{value})} which says that | |
32981 | the Calc variable @var{var} (a string which is the name of the symbol that | |
32982 | contains the variable's value) was stored and its previous value was | |
32983 | @var{value} (either a Calc data object, or @code{nil} if the variable was | |
32984 | previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})}, | |
32985 | which means that to undo requires calling the function @samp{(@var{undo} | |
32986 | @var{args} @dots{})} and, if the undo is later redone, calling | |
a4231b04 | 32987 | @samp{(@var{redo} @var{args} @dots{})}. |
d7b8e6c6 EZ |
32988 | @end defun |
32989 | ||
32990 | @defun calc-record-why msg args | |
32991 | Record the error or warning message @var{msg}, which is normally a string. | |
32992 | This message will be replayed if the user types @kbd{w} (@code{calc-why}); | |
32993 | if the message string begins with a @samp{*}, it is considered important | |
32994 | enough to display even if the user doesn't type @kbd{w}. If one or more | |
32995 | @var{args} are present, the displayed message will be of the form, | |
32996 | @samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are | |
32997 | formatted on the assumption that they are either strings or Calc objects of | |
32998 | some sort. If @var{msg} is a symbol, it is the name of a Calc predicate | |
32999 | (such as @code{integerp} or @code{numvecp}) which the arguments did not | |
33000 | satisfy; it is expanded to a suitable string such as ``Expected an | |
33001 | integer.'' The @code{reject-arg} function calls @code{calc-record-why} | |
a4231b04 | 33002 | automatically; @pxref{Predicates}. |
d7b8e6c6 EZ |
33003 | @end defun |
33004 | ||
33005 | @defun calc-is-inverse | |
33006 | This predicate returns true if the current command is inverse, | |
33007 | i.e., if the Inverse (@kbd{I} key) flag was set. | |
33008 | @end defun | |
33009 | ||
33010 | @defun calc-is-hyperbolic | |
33011 | This predicate is the analogous function for the @kbd{H} key. | |
33012 | @end defun | |
33013 | ||
33014 | @node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals | |
33015 | @subsubsection Stack-Oriented Functions | |
33016 | ||
33017 | @noindent | |
33018 | The functions described here perform various operations on the Calc | |
33019 | stack and trail. They are to be used in interactive Calc commands. | |
33020 | ||
33021 | @defun calc-push-list vals n | |
33022 | Push the Calc objects in list @var{vals} onto the stack at stack level | |
33023 | @var{n}. If @var{n} is omitted it defaults to 1, so that the elements | |
33024 | are pushed at the top of the stack. If @var{n} is greater than 1, the | |
33025 | elements will be inserted into the stack so that the last element will | |
33026 | end up at level @var{n}, the next-to-last at level @var{n}+1, etc. | |
33027 | The elements of @var{vals} are assumed to be valid Calc objects, and | |
33028 | are not evaluated, rounded, or renormalized in any way. If @var{vals} | |
a4231b04 | 33029 | is an empty list, nothing happens. |
d7b8e6c6 EZ |
33030 | |
33031 | The stack elements are pushed without any sub-formula selections. | |
33032 | You can give an optional third argument to this function, which must | |
33033 | be a list the same size as @var{vals} of selections. Each selection | |
33034 | must be @code{eq} to some sub-formula of the corresponding formula | |
33035 | in @var{vals}, or @code{nil} if that formula should have no selection. | |
33036 | @end defun | |
33037 | ||
33038 | @defun calc-top-list n m | |
33039 | Return a list of the @var{n} objects starting at level @var{m} of the | |
33040 | stack. If @var{m} is omitted it defaults to 1, so that the elements are | |
33041 | taken from the top of the stack. If @var{n} is omitted, it also | |
33042 | defaults to 1, so that the top stack element (in the form of a | |
33043 | one-element list) is returned. If @var{m} is greater than 1, the | |
33044 | @var{m}th stack element will be at the end of the list, the @var{m}+1st | |
33045 | element will be next-to-last, etc. If @var{n} or @var{m} are out of | |
33046 | range, the command is aborted with a suitable error message. If @var{n} | |
33047 | is zero, the function returns an empty list. The stack elements are not | |
a4231b04 | 33048 | evaluated, rounded, or renormalized. |
d7b8e6c6 EZ |
33049 | |
33050 | If any stack elements contain selections, and selections have not | |
33051 | been disabled by the @kbd{j e} (@code{calc-enable-selections}) command, | |
33052 | this function returns the selected portions rather than the entire | |
33053 | stack elements. It can be given a third ``selection-mode'' argument | |
33054 | which selects other behaviors. If it is the symbol @code{t}, then | |
33055 | a selection in any of the requested stack elements produces an | |
ce7c7522 | 33056 | ``invalid operation on selections'' error. If it is the symbol @code{full}, |
d7b8e6c6 EZ |
33057 | the whole stack entry is always returned regardless of selections. |
33058 | If it is the symbol @code{sel}, the selected portion is always returned, | |
33059 | or @code{nil} if there is no selection. (This mode ignores the @kbd{j e} | |
33060 | command.) If the symbol is @code{entry}, the complete stack entry in | |
33061 | list form is returned; the first element of this list will be the whole | |
33062 | formula, and the third element will be the selection (or @code{nil}). | |
33063 | @end defun | |
33064 | ||
33065 | @defun calc-pop-stack n m | |
33066 | Remove the specified elements from the stack. The parameters @var{n} | |
33067 | and @var{m} are defined the same as for @code{calc-top-list}. The return | |
33068 | value of @code{calc-pop-stack} is uninteresting. | |
33069 | ||
33070 | If there are any selected sub-formulas among the popped elements, and | |
33071 | @kbd{j e} has not been used to disable selections, this produces an | |
33072 | error without changing the stack. If you supply an optional third | |
33073 | argument of @code{t}, the stack elements are popped even if they | |
33074 | contain selections. | |
33075 | @end defun | |
33076 | ||
33077 | @defun calc-record-list vals tag | |
33078 | This function records one or more results in the trail. The @var{vals} | |
33079 | are a list of strings or Calc objects. The @var{tag} is the four-character | |
33080 | tag string to identify the values. If @var{tag} is omitted, a blank tag | |
33081 | will be used. | |
33082 | @end defun | |
33083 | ||
33084 | @defun calc-normalize n | |
33085 | This function takes a Calc object and ``normalizes'' it. At the very | |
33086 | least this involves re-rounding floating-point values according to the | |
33087 | current precision and other similar jobs. Also, unless the user has | |
07ce2eb3 | 33088 | selected No-Simplify mode (@pxref{Simplification Modes}), this involves |
d7b8e6c6 EZ |
33089 | actually evaluating a formula object by executing the function calls |
33090 | it contains, and possibly also doing algebraic simplification, etc. | |
33091 | @end defun | |
33092 | ||
33093 | @defun calc-top-list-n n m | |
33094 | This function is identical to @code{calc-top-list}, except that it calls | |
33095 | @code{calc-normalize} on the values that it takes from the stack. They | |
33096 | are also passed through @code{check-complete}, so that incomplete | |
33097 | objects will be rejected with an error message. All computational | |
33098 | commands should use this in preference to @code{calc-top-list}; the only | |
33099 | standard Calc commands that operate on the stack without normalizing | |
33100 | are stack management commands like @code{calc-enter} and @code{calc-roll-up}. | |
33101 | This function accepts the same optional selection-mode argument as | |
33102 | @code{calc-top-list}. | |
33103 | @end defun | |
33104 | ||
33105 | @defun calc-top-n m | |
33106 | This function is a convenient form of @code{calc-top-list-n} in which only | |
33107 | a single element of the stack is taken and returned, rather than a list | |
33108 | of elements. This also accepts an optional selection-mode argument. | |
33109 | @end defun | |
33110 | ||
33111 | @defun calc-enter-result n tag vals | |
33112 | This function is a convenient interface to most of the above functions. | |
33113 | The @var{vals} argument should be either a single Calc object, or a list | |
33114 | of Calc objects; the object or objects are normalized, and the top @var{n} | |
33115 | stack entries are replaced by the normalized objects. If @var{tag} is | |
33116 | non-@code{nil}, the normalized objects are also recorded in the trail. | |
33117 | A typical stack-based computational command would take the form, | |
33118 | ||
33119 | @smallexample | |
33120 | (calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func} | |
33121 | (calc-top-list-n @var{n}))) | |
33122 | @end smallexample | |
33123 | ||
33124 | If any of the @var{n} stack elements replaced contain sub-formula | |
33125 | selections, and selections have not been disabled by @kbd{j e}, | |
33126 | this function takes one of two courses of action. If @var{n} is | |
33127 | equal to the number of elements in @var{vals}, then each element of | |
33128 | @var{vals} is spliced into the corresponding selection; this is what | |
33129 | happens when you use the @key{TAB} key, or when you use a unary | |
33130 | arithmetic operation like @code{sqrt}. If @var{vals} has only one | |
33131 | element but @var{n} is greater than one, there must be only one | |
33132 | selection among the top @var{n} stack elements; the element from | |
33133 | @var{vals} is spliced into that selection. This is what happens when | |
33134 | you use a binary arithmetic operation like @kbd{+}. Any other | |
33135 | combination of @var{n} and @var{vals} is an error when selections | |
33136 | are present. | |
33137 | @end defun | |
33138 | ||
33139 | @defun calc-unary-op tag func arg | |
33140 | This function implements a unary operator that allows a numeric prefix | |
33141 | argument to apply the operator over many stack entries. If the prefix | |
33142 | argument @var{arg} is @code{nil}, this uses @code{calc-enter-result} | |
33143 | as outlined above. Otherwise, it maps the function over several stack | |
a4231b04 | 33144 | elements; @pxref{Prefix Arguments}. For example, |
d7b8e6c6 EZ |
33145 | |
33146 | @smallexample | |
33147 | (defun calc-zeta (arg) | |
33148 | (interactive "P") | |
33149 | (calc-unary-op "zeta" 'calcFunc-zeta arg)) | |
33150 | @end smallexample | |
33151 | @end defun | |
33152 | ||
33153 | @defun calc-binary-op tag func arg ident unary | |
33154 | This function implements a binary operator, analogously to | |
33155 | @code{calc-unary-op}. The optional @var{ident} and @var{unary} | |
33156 | arguments specify the behavior when the prefix argument is zero or | |
33157 | one, respectively. If the prefix is zero, the value @var{ident} | |
33158 | is pushed onto the stack, if specified, otherwise an error message | |
33159 | is displayed. If the prefix is one, the unary function @var{unary} | |
33160 | is applied to the top stack element, or, if @var{unary} is not | |
33161 | specified, nothing happens. When the argument is two or more, | |
33162 | the binary function @var{func} is reduced across the top @var{arg} | |
33163 | stack elements; when the argument is negative, the function is | |
8e04863e | 33164 | mapped between the next-to-top @mathit{-@var{arg}} stack elements and the |
a4231b04 | 33165 | top element. |
d7b8e6c6 EZ |
33166 | @end defun |
33167 | ||
33168 | @defun calc-stack-size | |
33169 | Return the number of elements on the stack as an integer. This count | |
33170 | does not include elements that have been temporarily hidden by stack | |
33171 | truncation; @pxref{Truncating the Stack}. | |
33172 | @end defun | |
33173 | ||
33174 | @defun calc-cursor-stack-index n | |
33175 | Move the point to the @var{n}th stack entry. If @var{n} is zero, this | |
33176 | will be the @samp{.} line. If @var{n} is from 1 to the current stack size, | |
33177 | this will be the beginning of the first line of that stack entry's display. | |
33178 | If line numbers are enabled, this will move to the first character of the | |
a4231b04 | 33179 | line number, not the stack entry itself. |
d7b8e6c6 EZ |
33180 | @end defun |
33181 | ||
33182 | @defun calc-substack-height n | |
33183 | Return the number of lines between the beginning of the @var{n}th stack | |
33184 | entry and the bottom of the buffer. If @var{n} is zero, this | |
33185 | will be one (assuming no stack truncation). If all stack entries are | |
33186 | one line long (i.e., no matrices are displayed), the return value will | |
33187 | be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big | |
33188 | mode, the return value includes the blank lines that separate stack | |
a4231b04 | 33189 | entries.) |
d7b8e6c6 EZ |
33190 | @end defun |
33191 | ||
33192 | @defun calc-refresh | |
33193 | Erase the @code{*Calculator*} buffer and reformat its contents from memory. | |
33194 | This must be called after changing any parameter, such as the current | |
33195 | display radix, which might change the appearance of existing stack | |
33196 | entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing | |
33197 | is suppressed, but a flag is set so that the entire stack will be refreshed | |
a4231b04 | 33198 | rather than just the top few elements when the macro finishes.) |
d7b8e6c6 EZ |
33199 | @end defun |
33200 | ||
33201 | @node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals | |
33202 | @subsubsection Predicates | |
33203 | ||
33204 | @noindent | |
33205 | The functions described here are predicates, that is, they return a | |
33206 | true/false value where @code{nil} means false and anything else means | |
33207 | true. These predicates are expanded by @code{defmath}, for example, | |
33208 | from @code{zerop} to @code{math-zerop}. In many cases they correspond | |
33209 | to native Lisp functions by the same name, but are extended to cover | |
33210 | the full range of Calc data types. | |
33211 | ||
33212 | @defun zerop x | |
33213 | Returns true if @var{x} is numerically zero, in any of the Calc data | |
33214 | types. (Note that for some types, such as error forms and intervals, | |
33215 | it never makes sense to return true.) In @code{defmath}, the expression | |
33216 | @samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)}, | |
33217 | and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}. | |
33218 | @end defun | |
33219 | ||
33220 | @defun negp x | |
33221 | Returns true if @var{x} is negative. This accepts negative real numbers | |
33222 | of various types, negative HMS and date forms, and intervals in which | |
33223 | all included values are negative. In @code{defmath}, the expression | |
33224 | @samp{(< x 0)} will automatically be converted to @samp{(math-negp x)}, | |
33225 | and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}. | |
33226 | @end defun | |
33227 | ||
33228 | @defun posp x | |
33229 | Returns true if @var{x} is positive (and non-zero). For complex | |
33230 | numbers, none of these three predicates will return true. | |
33231 | @end defun | |
33232 | ||
33233 | @defun looks-negp x | |
33234 | Returns true if @var{x} is ``negative-looking.'' This returns true if | |
33235 | @var{x} is a negative number, or a formula with a leading minus sign | |
33236 | such as @samp{-a/b}. In other words, this is an object which can be | |
33237 | made simpler by calling @code{(- @var{x})}. | |
33238 | @end defun | |
33239 | ||
33240 | @defun integerp x | |
33241 | Returns true if @var{x} is an integer of any size. | |
33242 | @end defun | |
33243 | ||
33244 | @defun fixnump x | |
33245 | Returns true if @var{x} is a native Lisp integer. | |
33246 | @end defun | |
33247 | ||
33248 | @defun natnump x | |
33249 | Returns true if @var{x} is a nonnegative integer of any size. | |
33250 | @end defun | |
33251 | ||
33252 | @defun fixnatnump x | |
33253 | Returns true if @var{x} is a nonnegative Lisp integer. | |
33254 | @end defun | |
33255 | ||
33256 | @defun num-integerp x | |
33257 | Returns true if @var{x} is numerically an integer, i.e., either a | |
33258 | true integer or a float with no significant digits to the right of | |
33259 | the decimal point. | |
33260 | @end defun | |
33261 | ||
33262 | @defun messy-integerp x | |
33263 | Returns true if @var{x} is numerically, but not literally, an integer. | |
33264 | A value is @code{num-integerp} if it is @code{integerp} or | |
33265 | @code{messy-integerp} (but it is never both at once). | |
33266 | @end defun | |
33267 | ||
33268 | @defun num-natnump x | |
33269 | Returns true if @var{x} is numerically a nonnegative integer. | |
33270 | @end defun | |
33271 | ||
33272 | @defun evenp x | |
33273 | Returns true if @var{x} is an even integer. | |
33274 | @end defun | |
33275 | ||
33276 | @defun looks-evenp x | |
33277 | Returns true if @var{x} is an even integer, or a formula with a leading | |
33278 | multiplicative coefficient which is an even integer. | |
33279 | @end defun | |
33280 | ||
33281 | @defun oddp x | |
33282 | Returns true if @var{x} is an odd integer. | |
33283 | @end defun | |
33284 | ||
33285 | @defun ratp x | |
33286 | Returns true if @var{x} is a rational number, i.e., an integer or a | |
33287 | fraction. | |
33288 | @end defun | |
33289 | ||
33290 | @defun realp x | |
33291 | Returns true if @var{x} is a real number, i.e., an integer, fraction, | |
33292 | or floating-point number. | |
33293 | @end defun | |
33294 | ||
33295 | @defun anglep x | |
33296 | Returns true if @var{x} is a real number or HMS form. | |
33297 | @end defun | |
33298 | ||
33299 | @defun floatp x | |
33300 | Returns true if @var{x} is a float, or a complex number, error form, | |
33301 | interval, date form, or modulo form in which at least one component | |
33302 | is a float. | |
33303 | @end defun | |
33304 | ||
33305 | @defun complexp x | |
33306 | Returns true if @var{x} is a rectangular or polar complex number | |
33307 | (but not a real number). | |
33308 | @end defun | |
33309 | ||
33310 | @defun rect-complexp x | |
33311 | Returns true if @var{x} is a rectangular complex number. | |
33312 | @end defun | |
33313 | ||
33314 | @defun polar-complexp x | |
33315 | Returns true if @var{x} is a polar complex number. | |
33316 | @end defun | |
33317 | ||
33318 | @defun numberp x | |
33319 | Returns true if @var{x} is a real number or a complex number. | |
33320 | @end defun | |
33321 | ||
33322 | @defun scalarp x | |
33323 | Returns true if @var{x} is a real or complex number or an HMS form. | |
33324 | @end defun | |
33325 | ||
33326 | @defun vectorp x | |
33327 | Returns true if @var{x} is a vector (this simply checks if its argument | |
33328 | is a list whose first element is the symbol @code{vec}). | |
33329 | @end defun | |
33330 | ||
33331 | @defun numvecp x | |
33332 | Returns true if @var{x} is a number or vector. | |
33333 | @end defun | |
33334 | ||
33335 | @defun matrixp x | |
33336 | Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors, | |
33337 | all of the same size. | |
33338 | @end defun | |
33339 | ||
33340 | @defun square-matrixp x | |
33341 | Returns true if @var{x} is a square matrix. | |
33342 | @end defun | |
33343 | ||
33344 | @defun objectp x | |
33345 | Returns true if @var{x} is any numeric Calc object, including real and | |
33346 | complex numbers, HMS forms, date forms, error forms, intervals, and | |
33347 | modulo forms. (Note that error forms and intervals may include formulas | |
33348 | as their components; see @code{constp} below.) | |
33349 | @end defun | |
33350 | ||
33351 | @defun objvecp x | |
33352 | Returns true if @var{x} is an object or a vector. This also accepts | |
33353 | incomplete objects, but it rejects variables and formulas (except as | |
33354 | mentioned above for @code{objectp}). | |
33355 | @end defun | |
33356 | ||
33357 | @defun primp x | |
33358 | Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object, | |
33359 | i.e., one whose components cannot be regarded as sub-formulas. This | |
33360 | includes variables, and all @code{objectp} types except error forms | |
33361 | and intervals. | |
33362 | @end defun | |
33363 | ||
33364 | @defun constp x | |
33365 | Returns true if @var{x} is constant, i.e., a real or complex number, | |
33366 | HMS form, date form, or error form, interval, or vector all of whose | |
33367 | components are @code{constp}. | |
33368 | @end defun | |
33369 | ||
33370 | @defun lessp x y | |
33371 | Returns true if @var{x} is numerically less than @var{y}. Returns false | |
33372 | if @var{x} is greater than or equal to @var{y}, or if the order is | |
33373 | undefined or cannot be determined. Generally speaking, this works | |
33374 | by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In | |
33375 | @code{defmath}, the expression @samp{(< x y)} will automatically be | |
33376 | converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=}, | |
a4231b04 | 33377 | and @code{>=} are similarly converted in terms of @code{lessp}. |
d7b8e6c6 EZ |
33378 | @end defun |
33379 | ||
33380 | @defun beforep x y | |
33381 | Returns true if @var{x} comes before @var{y} in a canonical ordering | |
33382 | of Calc objects. If @var{x} and @var{y} are both real numbers, this | |
33383 | will be the same as @code{lessp}. But whereas @code{lessp} considers | |
33384 | other types of objects to be unordered, @code{beforep} puts any two | |
33385 | objects into a definite, consistent order. The @code{beforep} | |
33386 | function is used by the @kbd{V S} vector-sorting command, and also | |
33387 | by @kbd{a s} to put the terms of a product into canonical order: | |
33388 | This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}. | |
33389 | @end defun | |
33390 | ||
33391 | @defun equal x y | |
33392 | This is the standard Lisp @code{equal} predicate; it returns true if | |
33393 | @var{x} and @var{y} are structurally identical. This is the usual way | |
33394 | to compare numbers for equality, but note that @code{equal} will treat | |
33395 | 0 and 0.0 as different. | |
33396 | @end defun | |
33397 | ||
33398 | @defun math-equal x y | |
33399 | Returns true if @var{x} and @var{y} are numerically equal, either because | |
33400 | they are @code{equal}, or because their difference is @code{zerop}. In | |
33401 | @code{defmath}, the expression @samp{(= x y)} will automatically be | |
33402 | converted to @samp{(math-equal x y)}. | |
33403 | @end defun | |
33404 | ||
33405 | @defun equal-int x n | |
33406 | Returns true if @var{x} and @var{n} are numerically equal, where @var{n} | |
33407 | is a fixnum which is not a multiple of 10. This will automatically be | |
33408 | used by @code{defmath} in place of the more general @code{math-equal} | |
a4231b04 | 33409 | whenever possible. |
d7b8e6c6 EZ |
33410 | @end defun |
33411 | ||
33412 | @defun nearly-equal x y | |
33413 | Returns true if @var{x} and @var{y}, as floating-point numbers, are | |
33414 | equal except possibly in the last decimal place. For example, | |
33415 | 314.159 and 314.166 are considered nearly equal if the current | |
33416 | precision is 6 (since they differ by 7 units), but not if the current | |
33417 | precision is 7 (since they differ by 70 units). Most functions which | |
33418 | use series expansions use @code{with-extra-prec} to evaluate the | |
33419 | series with 2 extra digits of precision, then use @code{nearly-equal} | |
33420 | to decide when the series has converged; this guards against cumulative | |
33421 | error in the series evaluation without doing extra work which would be | |
33422 | lost when the result is rounded back down to the current precision. | |
33423 | In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}. | |
33424 | The @var{x} and @var{y} can be numbers of any kind, including complex. | |
33425 | @end defun | |
33426 | ||
33427 | @defun nearly-zerop x y | |
33428 | Returns true if @var{x} is nearly zero, compared to @var{y}. This | |
33429 | checks whether @var{x} plus @var{y} would by be @code{nearly-equal} | |
33430 | to @var{y} itself, to within the current precision, in other words, | |
33431 | if adding @var{x} to @var{y} would have a negligible effect on @var{y} | |
33432 | due to roundoff error. @var{X} may be a real or complex number, but | |
33433 | @var{y} must be real. | |
33434 | @end defun | |
33435 | ||
33436 | @defun is-true x | |
33437 | Return true if the formula @var{x} represents a true value in | |
33438 | Calc, not Lisp, terms. It tests if @var{x} is a non-zero number | |
33439 | or a provably non-zero formula. | |
33440 | @end defun | |
33441 | ||
33442 | @defun reject-arg val pred | |
33443 | Abort the current function evaluation due to unacceptable argument values. | |
33444 | This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a | |
33445 | Lisp error which @code{normalize} will trap. The net effect is that the | |
a4231b04 | 33446 | function call which led here will be left in symbolic form. |
d7b8e6c6 EZ |
33447 | @end defun |
33448 | ||
33449 | @defun inexact-value | |
07ce2eb3 | 33450 | If Symbolic mode is enabled, this will signal an error that causes |
d7b8e6c6 | 33451 | @code{normalize} to leave the formula in symbolic form, with the message |
07ce2eb3 JB |
33452 | ``Inexact result.'' (This function has no effect when not in Symbolic mode.) |
33453 | Note that if your function calls @samp{(sin 5)} in Symbolic mode, the | |
d7b8e6c6 EZ |
33454 | @code{sin} function will call @code{inexact-value}, which will cause your |
33455 | function to be left unsimplified. You may instead wish to call | |
07ce2eb3 | 33456 | @samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will |
a4231b04 | 33457 | return the formula @samp{sin(5)} to your function. |
d7b8e6c6 EZ |
33458 | @end defun |
33459 | ||
33460 | @defun overflow | |
33461 | This signals an error that will be reported as a floating-point overflow. | |
33462 | @end defun | |
33463 | ||
33464 | @defun underflow | |
33465 | This signals a floating-point underflow. | |
33466 | @end defun | |
33467 | ||
33468 | @node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals | |
33469 | @subsubsection Computational Functions | |
33470 | ||
33471 | @noindent | |
33472 | The functions described here do the actual computational work of the | |
33473 | Calculator. In addition to these, note that any function described in | |
33474 | the main body of this manual may be called from Lisp; for example, if | |
33475 | the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command, | |
33476 | this means @code{calc-sqrt} is an interactive stack-based square-root | |
33477 | command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt}) | |
a4231b04 | 33478 | is the actual Lisp function for taking square roots. |
d7b8e6c6 EZ |
33479 | |
33480 | The functions @code{math-add}, @code{math-sub}, @code{math-mul}, | |
33481 | @code{math-div}, @code{math-mod}, and @code{math-neg} are not included | |
33482 | in this list, since @code{defmath} allows you to write native Lisp | |
33483 | @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-}, | |
a4231b04 | 33484 | respectively, instead. |
d7b8e6c6 EZ |
33485 | |
33486 | @defun normalize val | |
33487 | (Full form: @code{math-normalize}.) | |
33488 | Reduce the value @var{val} to standard form. For example, if @var{val} | |
33489 | is a fixnum, it will be converted to a bignum if it is too large, and | |
33490 | if @var{val} is a bignum it will be normalized by clipping off trailing | |
33491 | (i.e., most-significant) zero digits and converting to a fixnum if it is | |
33492 | small. All the various data types are similarly converted to their standard | |
33493 | forms. Variables are left alone, but function calls are actually evaluated | |
33494 | in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will | |
a4231b04 | 33495 | return 6. |
d7b8e6c6 EZ |
33496 | |
33497 | If a function call fails, because the function is void or has the wrong | |
33498 | number of parameters, or because it returns @code{nil} or calls | |
33499 | @code{reject-arg} or @code{inexact-result}, @code{normalize} returns | |
a4231b04 | 33500 | the formula still in symbolic form. |
d7b8e6c6 | 33501 | |
07ce2eb3 | 33502 | If the current simplification mode is ``none'' or ``numeric arguments |
d7b8e6c6 | 33503 | only,'' @code{normalize} will act appropriately. However, the more |
07ce2eb3 | 33504 | powerful simplification modes (like Algebraic Simplification) are |
d7b8e6c6 EZ |
33505 | not handled by @code{normalize}. They are handled by @code{calc-normalize}, |
33506 | which calls @code{normalize} and possibly some other routines, such | |
33507 | as @code{simplify} or @code{simplify-units}. Programs generally will | |
33508 | never call @code{calc-normalize} except when popping or pushing values | |
a4231b04 | 33509 | on the stack. |
d7b8e6c6 EZ |
33510 | @end defun |
33511 | ||
33512 | @defun evaluate-expr expr | |
33513 | Replace all variables in @var{expr} that have values with their values, | |
33514 | then use @code{normalize} to simplify the result. This is what happens | |
a4231b04 | 33515 | when you press the @kbd{=} key interactively. |
d7b8e6c6 EZ |
33516 | @end defun |
33517 | ||
33518 | @defmac with-extra-prec n body | |
33519 | Evaluate the Lisp forms in @var{body} with precision increased by @var{n} | |
33520 | digits. This is a macro which expands to | |
33521 | ||
33522 | @smallexample | |
33523 | (math-normalize | |
33524 | (let ((calc-internal-prec (+ calc-internal-prec @var{n}))) | |
33525 | @var{body})) | |
33526 | @end smallexample | |
33527 | ||
33528 | The surrounding call to @code{math-normalize} causes a floating-point | |
33529 | result to be rounded down to the original precision afterwards. This | |
33530 | is important because some arithmetic operations assume a number's | |
33531 | mantissa contains no more digits than the current precision allows. | |
33532 | @end defmac | |
33533 | ||
33534 | @defun make-frac n d | |
33535 | Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling | |
33536 | @samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient. | |
33537 | @end defun | |
33538 | ||
33539 | @defun make-float mant exp | |
33540 | Build a floating-point value out of @var{mant} and @var{exp}, both | |
33541 | of which are arbitrary integers. This function will return a | |
33542 | properly normalized float value, or signal an overflow or underflow | |
33543 | if @var{exp} is out of range. | |
33544 | @end defun | |
33545 | ||
33546 | @defun make-sdev x sigma | |
33547 | Build an error form out of @var{x} and the absolute value of @var{sigma}. | |
33548 | If @var{sigma} is zero, the result is the number @var{x} directly. | |
33549 | If @var{sigma} is negative or complex, its absolute value is used. | |
33550 | If @var{x} or @var{sigma} is not a valid type of object for use in | |
33551 | error forms, this calls @code{reject-arg}. | |
33552 | @end defun | |
33553 | ||
33554 | @defun make-intv mask lo hi | |
33555 | Build an interval form out of @var{mask} (which is assumed to be an | |
33556 | integer from 0 to 3), and the limits @var{lo} and @var{hi}. If | |
33557 | @var{lo} is greater than @var{hi}, an empty interval form is returned. | |
33558 | This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable. | |
33559 | @end defun | |
33560 | ||
33561 | @defun sort-intv mask lo hi | |
33562 | Build an interval form, similar to @code{make-intv}, except that if | |
33563 | @var{lo} is less than @var{hi} they are simply exchanged, and the | |
33564 | bits of @var{mask} are swapped accordingly. | |
33565 | @end defun | |
33566 | ||
33567 | @defun make-mod n m | |
33568 | Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo | |
33569 | forms do not allow formulas as their components, if @var{n} or @var{m} | |
33570 | is not a real number or HMS form the result will be a formula which | |
33571 | is a call to @code{makemod}, the algebraic version of this function. | |
33572 | @end defun | |
33573 | ||
33574 | @defun float x | |
33575 | Convert @var{x} to floating-point form. Integers and fractions are | |
33576 | converted to numerically equivalent floats; components of complex | |
33577 | numbers, vectors, HMS forms, date forms, error forms, intervals, and | |
33578 | modulo forms are recursively floated. If the argument is a variable | |
33579 | or formula, this calls @code{reject-arg}. | |
33580 | @end defun | |
33581 | ||
33582 | @defun compare x y | |
8e04863e | 33583 | Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if |
d7b8e6c6 EZ |
33584 | @samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})}, |
33585 | 0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is | |
a4231b04 | 33586 | undefined or cannot be determined. |
d7b8e6c6 EZ |
33587 | @end defun |
33588 | ||
33589 | @defun numdigs n | |
33590 | Return the number of digits of integer @var{n}, effectively | |
33591 | @samp{ceil(log10(@var{n}))}, but much more efficient. Zero is | |
33592 | considered to have zero digits. | |
33593 | @end defun | |
33594 | ||
33595 | @defun scale-int x n | |
8e04863e | 33596 | Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}} |
d7b8e6c6 EZ |
33597 | digits with truncation toward zero. |
33598 | @end defun | |
33599 | ||
33600 | @defun scale-rounding x n | |
33601 | Like @code{scale-int}, except that a right shift rounds to the nearest | |
33602 | integer rather than truncating. | |
33603 | @end defun | |
33604 | ||
33605 | @defun fixnum n | |
33606 | Return the integer @var{n} as a fixnum, i.e., a native Lisp integer. | |
33607 | If @var{n} is outside the permissible range for Lisp integers (usually | |
33608 | 24 binary bits) the result is undefined. | |
33609 | @end defun | |
33610 | ||
33611 | @defun sqr x | |
33612 | Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}. | |
33613 | @end defun | |
33614 | ||
33615 | @defun quotient x y | |
33616 | Divide integer @var{x} by integer @var{y}; return an integer quotient | |
33617 | and discard the remainder. If @var{x} or @var{y} is negative, the | |
33618 | direction of rounding is undefined. | |
33619 | @end defun | |
33620 | ||
33621 | @defun idiv x y | |
33622 | Perform an integer division; if @var{x} and @var{y} are both nonnegative | |
33623 | integers, this uses the @code{quotient} function, otherwise it computes | |
33624 | @samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but | |
33625 | slower than for @code{quotient}. | |
33626 | @end defun | |
33627 | ||
33628 | @defun imod x y | |
33629 | Divide integer @var{x} by integer @var{y}; return the integer remainder | |
33630 | and discard the quotient. Like @code{quotient}, this works only for | |
33631 | integer arguments and is not well-defined for negative arguments. | |
33632 | For a more well-defined result, use @samp{(% @var{x} @var{y})}. | |
33633 | @end defun | |
33634 | ||
33635 | @defun idivmod x y | |
33636 | Divide integer @var{x} by integer @var{y}; return a cons cell whose | |
33637 | @code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr} | |
a4231b04 | 33638 | is @samp{(imod @var{x} @var{y})}. |
d7b8e6c6 EZ |
33639 | @end defun |
33640 | ||
33641 | @defun pow x y | |
33642 | Compute @var{x} to the power @var{y}. In @code{defmath} code, this can | |
33643 | also be written @samp{(^ @var{x} @var{y})} or | |
a4231b04 | 33644 | @w{@samp{(expt @var{x} @var{y})}}. |
d7b8e6c6 EZ |
33645 | @end defun |
33646 | ||
33647 | @defun abs-approx x | |
33648 | Compute a fast approximation to the absolute value of @var{x}. For | |
33649 | example, for a rectangular complex number the result is the sum of | |
33650 | the absolute values of the components. | |
33651 | @end defun | |
33652 | ||
651e237b JB |
33653 | @findex e |
33654 | @findex gamma-const | |
33655 | @findex ln-2 | |
33656 | @findex ln-10 | |
33657 | @findex phi | |
d7b8e6c6 EZ |
33658 | @findex pi-over-2 |
33659 | @findex pi-over-4 | |
33660 | @findex pi-over-180 | |
33661 | @findex sqrt-two-pi | |
33662 | @findex sqrt-e | |
651e237b | 33663 | @findex two-pi |
d7b8e6c6 EZ |
33664 | @defun pi |
33665 | The function @samp{(pi)} computes @samp{pi} to the current precision. | |
33666 | Other related constant-generating functions are @code{two-pi}, | |
33667 | @code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi}, | |
651e237b JB |
33668 | @code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and |
33669 | @code{gamma-const}. Each function returns a floating-point value in the | |
33670 | current precision, and each uses caching so that all calls after the | |
33671 | first are essentially free. | |
d7b8e6c6 EZ |
33672 | @end defun |
33673 | ||
33674 | @defmac math-defcache @var{func} @var{initial} @var{form} | |
33675 | This macro, usually used as a top-level call like @code{defun} or | |
33676 | @code{defvar}, defines a new cached constant analogous to @code{pi}, etc. | |
33677 | It defines a function @code{func} which returns the requested value; | |
33678 | if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})} | |
33679 | form which serves as an initial value for the cache. If @var{func} | |
33680 | is called when the cache is empty or does not have enough digits to | |
33681 | satisfy the current precision, the Lisp expression @var{form} is evaluated | |
33682 | with the current precision increased by four, and the result minus its | |
33683 | two least significant digits is stored in the cache. For example, | |
33684 | calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34 | |
33685 | digits, rounds it down to 32 digits for future use, then rounds it | |
a4231b04 | 33686 | again to 30 digits for use in the present request. |
d7b8e6c6 EZ |
33687 | @end defmac |
33688 | ||
33689 | @findex half-circle | |
33690 | @findex quarter-circle | |
33691 | @defun full-circle symb | |
33692 | If the current angular mode is Degrees or HMS, this function returns the | |
33693 | integer 360. In Radians mode, this function returns either the | |
33694 | corresponding value in radians to the current precision, or the formula | |
07ce2eb3 | 33695 | @samp{2*pi}, depending on the Symbolic mode. There are also similar |
d7b8e6c6 EZ |
33696 | function @code{half-circle} and @code{quarter-circle}. |
33697 | @end defun | |
33698 | ||
33699 | @defun power-of-2 n | |
33700 | Compute two to the integer power @var{n}, as a (potentially very large) | |
33701 | integer. Powers of two are cached, so only the first call for a | |
33702 | particular @var{n} is expensive. | |
33703 | @end defun | |
33704 | ||
33705 | @defun integer-log2 n | |
33706 | Compute the base-2 logarithm of @var{n}, which must be an integer which | |
33707 | is a power of two. If @var{n} is not a power of two, this function will | |
33708 | return @code{nil}. | |
33709 | @end defun | |
33710 | ||
33711 | @defun div-mod a b m | |
33712 | Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if | |
a4231b04 | 33713 | there is no solution, or if any of the arguments are not integers. |
d7b8e6c6 EZ |
33714 | @end defun |
33715 | ||
33716 | @defun pow-mod a b m | |
33717 | Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a}, | |
33718 | @var{b}, and @var{m} are integers, this uses an especially efficient | |
33719 | algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}. | |
33720 | @end defun | |
33721 | ||
33722 | @defun isqrt n | |
33723 | Compute the integer square root of @var{n}. This is the square root | |
33724 | of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}. | |
33725 | If @var{n} is itself an integer, the computation is especially efficient. | |
33726 | @end defun | |
33727 | ||
33728 | @defun to-hms a ang | |
33729 | Convert the argument @var{a} into an HMS form. If @var{ang} is specified, | |
33730 | it is the angular mode in which to interpret @var{a}, either @code{deg} | |
33731 | or @code{rad}. Otherwise, the current angular mode is used. If @var{a} | |
33732 | is already an HMS form it is returned as-is. | |
33733 | @end defun | |
33734 | ||
33735 | @defun from-hms a ang | |
33736 | Convert the HMS form @var{a} into a real number. If @var{ang} is specified, | |
33737 | it is the angular mode in which to express the result, otherwise the | |
33738 | current angular mode is used. If @var{a} is already a real number, it | |
33739 | is returned as-is. | |
33740 | @end defun | |
33741 | ||
33742 | @defun to-radians a | |
33743 | Convert the number or HMS form @var{a} to radians from the current | |
33744 | angular mode. | |
33745 | @end defun | |
33746 | ||
33747 | @defun from-radians a | |
33748 | Convert the number @var{a} from radians to the current angular mode. | |
33749 | If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}. | |
33750 | @end defun | |
33751 | ||
33752 | @defun to-radians-2 a | |
07ce2eb3 | 33753 | Like @code{to-radians}, except that in Symbolic mode a degrees to |
d7b8e6c6 EZ |
33754 | radians conversion yields a formula like @samp{@var{a}*pi/180}. |
33755 | @end defun | |
33756 | ||
33757 | @defun from-radians-2 a | |
07ce2eb3 | 33758 | Like @code{from-radians}, except that in Symbolic mode a radians to |
d7b8e6c6 EZ |
33759 | degrees conversion yields a formula like @samp{@var{a}*180/pi}. |
33760 | @end defun | |
33761 | ||
33762 | @defun random-digit | |
33763 | Produce a random base-1000 digit in the range 0 to 999. | |
33764 | @end defun | |
33765 | ||
33766 | @defun random-digits n | |
33767 | Produce a random @var{n}-digit integer; this will be an integer | |
33768 | in the interval @samp{[0, 10^@var{n})}. | |
33769 | @end defun | |
33770 | ||
33771 | @defun random-float | |
33772 | Produce a random float in the interval @samp{[0, 1)}. | |
33773 | @end defun | |
33774 | ||
33775 | @defun prime-test n iters | |
33776 | Determine whether the integer @var{n} is prime. Return a list which has | |
33777 | one of these forms: @samp{(nil @var{f})} means the number is non-prime | |
33778 | because it was found to be divisible by @var{f}; @samp{(nil)} means it | |
33779 | was found to be non-prime by table look-up (so no factors are known); | |
33780 | @samp{(nil unknown)} means it is definitely non-prime but no factors | |
33781 | are known because @var{n} was large enough that Fermat's probabilistic | |
33782 | test had to be used; @samp{(t)} means the number is definitely prime; | |
33783 | and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i} | |
33784 | iterations, is @var{p} percent sure that the number is prime. The | |
33785 | @var{iters} parameter is the number of Fermat iterations to use, in the | |
33786 | case that this is necessary. If @code{prime-test} returns ``maybe,'' | |
33787 | you can call it again with the same @var{n} to get a greater certainty; | |
a4231b04 | 33788 | @code{prime-test} remembers where it left off. |
d7b8e6c6 EZ |
33789 | @end defun |
33790 | ||
33791 | @defun to-simple-fraction f | |
33792 | If @var{f} is a floating-point number which can be represented exactly | |
33793 | as a small rational number. return that number, else return @var{f}. | |
33794 | For example, 0.75 would be converted to 3:4. This function is very | |
33795 | fast. | |
33796 | @end defun | |
33797 | ||
33798 | @defun to-fraction f tol | |
33799 | Find a rational approximation to floating-point number @var{f} to within | |
33800 | a specified tolerance @var{tol}; this corresponds to the algebraic | |
33801 | function @code{frac}, and can be rather slow. | |
33802 | @end defun | |
33803 | ||
33804 | @defun quarter-integer n | |
33805 | If @var{n} is an integer or integer-valued float, this function | |
33806 | returns zero. If @var{n} is a half-integer (i.e., an integer plus | |
8e04863e | 33807 | @mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer, |
d7b8e6c6 EZ |
33808 | it returns 1 or 3. If @var{n} is anything else, this function |
33809 | returns @code{nil}. | |
33810 | @end defun | |
33811 | ||
33812 | @node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals | |
33813 | @subsubsection Vector Functions | |
33814 | ||
33815 | @noindent | |
33816 | The functions described here perform various operations on vectors and | |
33817 | matrices. | |
33818 | ||
33819 | @defun math-concat x y | |
33820 | Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}} | |
33821 | in a symbolic formula. @xref{Building Vectors}. | |
33822 | @end defun | |
33823 | ||
33824 | @defun vec-length v | |
33825 | Return the length of vector @var{v}. If @var{v} is not a vector, the | |
33826 | result is zero. If @var{v} is a matrix, this returns the number of | |
33827 | rows in the matrix. | |
33828 | @end defun | |
33829 | ||
33830 | @defun mat-dimens m | |
33831 | Determine the dimensions of vector or matrix @var{m}. If @var{m} is not | |
33832 | a vector, the result is an empty list. If @var{m} is a plain vector | |
33833 | but not a matrix, the result is a one-element list containing the length | |
33834 | of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns, | |
33835 | the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors | |
33836 | produce lists of more than two dimensions. Note that the object | |
33837 | @samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size, | |
33838 | and is treated by this and other Calc routines as a plain vector of two | |
a4231b04 | 33839 | elements. |
d7b8e6c6 EZ |
33840 | @end defun |
33841 | ||
33842 | @defun dimension-error | |
33843 | Abort the current function with a message of ``Dimension error.'' | |
33844 | The Calculator will leave the function being evaluated in symbolic | |
33845 | form; this is really just a special case of @code{reject-arg}. | |
33846 | @end defun | |
33847 | ||
33848 | @defun build-vector args | |
5d67986c | 33849 | Return a Calc vector with @var{args} as elements. |
d7b8e6c6 EZ |
33850 | For example, @samp{(build-vector 1 2 3)} returns the Calc vector |
33851 | @samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}. | |
33852 | @end defun | |
33853 | ||
33854 | @defun make-vec obj dims | |
33855 | Return a Calc vector or matrix all of whose elements are equal to | |
33856 | @var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix | |
33857 | filled with 27's. | |
33858 | @end defun | |
33859 | ||
33860 | @defun row-matrix v | |
33861 | If @var{v} is a plain vector, convert it into a row matrix, i.e., | |
33862 | a matrix whose single row is @var{v}. If @var{v} is already a matrix, | |
33863 | leave it alone. | |
33864 | @end defun | |
33865 | ||
33866 | @defun col-matrix v | |
33867 | If @var{v} is a plain vector, convert it into a column matrix, i.e., a | |
33868 | matrix with each element of @var{v} as a separate row. If @var{v} is | |
33869 | already a matrix, leave it alone. | |
33870 | @end defun | |
33871 | ||
33872 | @defun map-vec f v | |
33873 | Map the Lisp function @var{f} over the Calc vector @var{v}. For example, | |
33874 | @samp{(map-vec 'math-floor v)} returns a vector of the floored components | |
33875 | of vector @var{v}. | |
33876 | @end defun | |
33877 | ||
33878 | @defun map-vec-2 f a b | |
33879 | Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}. | |
33880 | If @var{a} and @var{b} are vectors of equal length, the result is a | |
33881 | vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})} | |
33882 | for each pair of elements @var{ai} and @var{bi}. If either @var{a} or | |
33883 | @var{b} is a scalar, it is matched with each value of the other vector. | |
33884 | For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v} | |
33885 | with each element increased by one. Note that using @samp{'+} would not | |
33886 | work here, since @code{defmath} does not expand function names everywhere, | |
a4231b04 | 33887 | just where they are in the function position of a Lisp expression. |
d7b8e6c6 EZ |
33888 | @end defun |
33889 | ||
33890 | @defun reduce-vec f v | |
33891 | Reduce the function @var{f} over the vector @var{v}. For example, if | |
33892 | @var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}. | |
33893 | If @var{v} is a matrix, this reduces over the rows of @var{v}. | |
33894 | @end defun | |
33895 | ||
33896 | @defun reduce-cols f m | |
33897 | Reduce the function @var{f} over the columns of matrix @var{m}. For | |
33898 | example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result | |
33899 | is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}. | |
33900 | @end defun | |
33901 | ||
33902 | @defun mat-row m n | |
33903 | Return the @var{n}th row of matrix @var{m}. This is equivalent to | |
33904 | @samp{(elt m n)}. For a slower but safer version, use @code{mrow}. | |
33905 | (@xref{Extracting Elements}.) | |
33906 | @end defun | |
33907 | ||
33908 | @defun mat-col m n | |
33909 | Return the @var{n}th column of matrix @var{m}, in the form of a vector. | |
33910 | The arguments are not checked for correctness. | |
33911 | @end defun | |
33912 | ||
33913 | @defun mat-less-row m n | |
33914 | Return a copy of matrix @var{m} with its @var{n}th row deleted. The | |
33915 | number @var{n} must be in range from 1 to the number of rows in @var{m}. | |
33916 | @end defun | |
33917 | ||
33918 | @defun mat-less-col m n | |
33919 | Return a copy of matrix @var{m} with its @var{n}th column deleted. | |
33920 | @end defun | |
33921 | ||
33922 | @defun transpose m | |
33923 | Return the transpose of matrix @var{m}. | |
33924 | @end defun | |
33925 | ||
33926 | @defun flatten-vector v | |
33927 | Flatten nested vector @var{v} into a vector of scalars. For example, | |
33928 | if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}. | |
33929 | @end defun | |
33930 | ||
33931 | @defun copy-matrix m | |
33932 | If @var{m} is a matrix, return a copy of @var{m}. This maps | |
33933 | @code{copy-sequence} over the rows of @var{m}; in Lisp terms, each | |
33934 | element of the result matrix will be @code{eq} to the corresponding | |
33935 | element of @var{m}, but none of the @code{cons} cells that make up | |
33936 | the structure of the matrix will be @code{eq}. If @var{m} is a plain | |
a4231b04 | 33937 | vector, this is the same as @code{copy-sequence}. |
d7b8e6c6 EZ |
33938 | @end defun |
33939 | ||
33940 | @defun swap-rows m r1 r2 | |
33941 | Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In | |
33942 | other words, unlike most of the other functions described here, this | |
33943 | function changes @var{m} itself rather than building up a new result | |
33944 | matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)} | |
33945 | is true, with the side effect of exchanging the first two rows of | |
a4231b04 | 33946 | @var{m}. |
d7b8e6c6 EZ |
33947 | @end defun |
33948 | ||
33949 | @node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals | |
33950 | @subsubsection Symbolic Functions | |
33951 | ||
33952 | @noindent | |
33953 | The functions described here operate on symbolic formulas in the | |
33954 | Calculator. | |
33955 | ||
33956 | @defun calc-prepare-selection num | |
33957 | Prepare a stack entry for selection operations. If @var{num} is | |
33958 | omitted, the stack entry containing the cursor is used; otherwise, | |
33959 | it is the number of the stack entry to use. This function stores | |
33960 | useful information about the current stack entry into a set of | |
33961 | variables. @code{calc-selection-cache-num} contains the number of | |
33962 | the stack entry involved (equal to @var{num} if you specified it); | |
33963 | @code{calc-selection-cache-entry} contains the stack entry as a | |
33964 | list (such as @code{calc-top-list} would return with @code{entry} | |
33965 | as the selection mode); and @code{calc-selection-cache-comp} contains | |
33966 | a special ``tagged'' composition (@pxref{Formatting Lisp Functions}) | |
33967 | which allows Calc to relate cursor positions in the buffer with | |
33968 | their corresponding sub-formulas. | |
33969 | ||
33970 | A slight complication arises in the selection mechanism because | |
33971 | formulas may contain small integers. For example, in the vector | |
33972 | @samp{[1, 2, 1]} the first and last elements are @code{eq} to each | |
33973 | other; selections are recorded as the actual Lisp object that | |
33974 | appears somewhere in the tree of the whole formula, but storing | |
33975 | @code{1} would falsely select both @code{1}'s in the vector. So | |
33976 | @code{calc-prepare-selection} also checks the stack entry and | |
33977 | replaces any plain integers with ``complex number'' lists of the form | |
33978 | @samp{(cplx @var{n} 0)}. This list will be displayed the same as a | |
33979 | plain @var{n} and the change will be completely invisible to the | |
33980 | user, but it will guarantee that no two sub-formulas of the stack | |
33981 | entry will be @code{eq} to each other. Next time the stack entry | |
33982 | is involved in a computation, @code{calc-normalize} will replace | |
33983 | these lists with plain numbers again, again invisibly to the user. | |
33984 | @end defun | |
33985 | ||
33986 | @defun calc-encase-atoms x | |
33987 | This modifies the formula @var{x} to ensure that each part of the | |
33988 | formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick | |
33989 | described above. This function may use @code{setcar} to modify | |
33990 | the formula in-place. | |
33991 | @end defun | |
33992 | ||
33993 | @defun calc-find-selected-part | |
33994 | Find the smallest sub-formula of the current formula that contains | |
33995 | the cursor. This assumes @code{calc-prepare-selection} has been | |
33996 | called already. If the cursor is not actually on any part of the | |
33997 | formula, this returns @code{nil}. | |
33998 | @end defun | |
33999 | ||
34000 | @defun calc-change-current-selection selection | |
34001 | Change the currently prepared stack element's selection to | |
34002 | @var{selection}, which should be @code{eq} to some sub-formula | |
34003 | of the stack element, or @code{nil} to unselect the formula. | |
34004 | The stack element's appearance in the Calc buffer is adjusted | |
34005 | to reflect the new selection. | |
34006 | @end defun | |
34007 | ||
34008 | @defun calc-find-nth-part expr n | |
34009 | Return the @var{n}th sub-formula of @var{expr}. This function is used | |
34010 | by the selection commands, and (unless @kbd{j b} has been used) treats | |
34011 | sums and products as flat many-element formulas. Thus if @var{expr} | |
34012 | is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with | |
34013 | @var{n} equal to four will return @samp{d}. | |
34014 | @end defun | |
34015 | ||
34016 | @defun calc-find-parent-formula expr part | |
34017 | Return the sub-formula of @var{expr} which immediately contains | |
34018 | @var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part} | |
34019 | is @code{eq} to the @samp{c+1} term of @var{expr}, then this function | |
34020 | will return @samp{(c+1)*d}. If @var{part} turns out not to be a | |
34021 | sub-formula of @var{expr}, the function returns @code{nil}. If | |
34022 | @var{part} is @code{eq} to @var{expr}, the function returns @code{t}. | |
34023 | This function does not take associativity into account. | |
34024 | @end defun | |
34025 | ||
34026 | @defun calc-find-assoc-parent-formula expr part | |
34027 | This is the same as @code{calc-find-parent-formula}, except that | |
34028 | (unless @kbd{j b} has been used) it continues widening the selection | |
34029 | to contain a complete level of the formula. Given @samp{a} from | |
34030 | @samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will | |
34031 | return @samp{a + b} but @code{calc-find-assoc-parent-formula} will | |
34032 | return the whole expression. | |
34033 | @end defun | |
34034 | ||
34035 | @defun calc-grow-assoc-formula expr part | |
34036 | This expands sub-formula @var{part} of @var{expr} to encompass a | |
34037 | complete level of the formula. If @var{part} and its immediate | |
34038 | parent are not compatible associative operators, or if @kbd{j b} | |
34039 | has been used, this simply returns @var{part}. | |
34040 | @end defun | |
34041 | ||
34042 | @defun calc-find-sub-formula expr part | |
34043 | This finds the immediate sub-formula of @var{expr} which contains | |
34044 | @var{part}. It returns an index @var{n} such that | |
34045 | @samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}. | |
34046 | If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}. | |
34047 | If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This | |
34048 | function does not take associativity into account. | |
34049 | @end defun | |
34050 | ||
34051 | @defun calc-replace-sub-formula expr old new | |
34052 | This function returns a copy of formula @var{expr}, with the | |
34053 | sub-formula that is @code{eq} to @var{old} replaced by @var{new}. | |
34054 | @end defun | |
34055 | ||
34056 | @defun simplify expr | |
34057 | Simplify the expression @var{expr} by applying various algebraic rules. | |
34058 | This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This | |
34059 | always returns a copy of the expression; the structure @var{expr} points | |
34060 | to remains unchanged in memory. | |
34061 | ||
34062 | More precisely, here is what @code{simplify} does: The expression is | |
34063 | first normalized and evaluated by calling @code{normalize}. If any | |
34064 | @code{AlgSimpRules} have been defined, they are then applied. Then | |
34065 | the expression is traversed in a depth-first, bottom-up fashion; at | |
34066 | each level, any simplifications that can be made are made until no | |
34067 | further changes are possible. Once the entire formula has been | |
34068 | traversed in this way, it is compared with the original formula (from | |
34069 | before the call to @code{normalize}) and, if it has changed, | |
34070 | the entire procedure is repeated (starting with @code{normalize}) | |
34071 | until no further changes occur. Usually only two iterations are | |
34072 | needed:@: one to simplify the formula, and another to verify that no | |
34073 | further simplifications were possible. | |
34074 | @end defun | |
34075 | ||
34076 | @defun simplify-extended expr | |
34077 | Simplify the expression @var{expr}, with additional rules enabled that | |
34078 | help do a more thorough job, while not being entirely ``safe'' in all | |
34079 | circumstances. (For example, this mode will simplify @samp{sqrt(x^2)} | |
34080 | to @samp{x}, which is only valid when @var{x} is positive.) This is | |
34081 | implemented by temporarily binding the variable @code{math-living-dangerously} | |
34082 | to @code{t} (using a @code{let} form) and calling @code{simplify}. | |
34083 | Dangerous simplification rules are written to check this variable | |
a4231b04 | 34084 | before taking any action. |
d7b8e6c6 EZ |
34085 | @end defun |
34086 | ||
34087 | @defun simplify-units expr | |
34088 | Simplify the expression @var{expr}, treating variable names as units | |
34089 | whenever possible. This works by binding the variable | |
34090 | @code{math-simplifying-units} to @code{t} while calling @code{simplify}. | |
34091 | @end defun | |
34092 | ||
34093 | @defmac math-defsimplify funcs body | |
34094 | Register a new simplification rule; this is normally called as a top-level | |
34095 | form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol | |
34096 | (like @code{+} or @code{calcFunc-sqrt}), this simplification rule is | |
34097 | applied to the formulas which are calls to the specified function. Or, | |
34098 | @var{funcs} can be a list of such symbols; the rule applies to all | |
34099 | functions on the list. The @var{body} is written like the body of a | |
34100 | function with a single argument called @code{expr}. The body will be | |
34101 | executed with @code{expr} bound to a formula which is a call to one of | |
34102 | the functions @var{funcs}. If the function body returns @code{nil}, or | |
34103 | if it returns a result @code{equal} to the original @code{expr}, it is | |
34104 | ignored and Calc goes on to try the next simplification rule that applies. | |
34105 | If the function body returns something different, that new formula is | |
a4231b04 | 34106 | substituted for @var{expr} in the original formula. |
d7b8e6c6 EZ |
34107 | |
34108 | At each point in the formula, rules are tried in the order of the | |
34109 | original calls to @code{math-defsimplify}; the search stops after the | |
34110 | first rule that makes a change. Thus later rules for that same | |
34111 | function will not have a chance to trigger until the next iteration | |
34112 | of the main @code{simplify} loop. | |
34113 | ||
34114 | Note that, since @code{defmath} is not being used here, @var{body} must | |
34115 | be written in true Lisp code without the conveniences that @code{defmath} | |
34116 | provides. If you prefer, you can have @var{body} simply call another | |
34117 | function (defined with @code{defmath}) which does the real work. | |
34118 | ||
34119 | The arguments of a function call will already have been simplified | |
34120 | before any rules for the call itself are invoked. Since a new argument | |
34121 | list is consed up when this happens, this means that the rule's body is | |
34122 | allowed to rearrange the function's arguments destructively if that is | |
34123 | convenient. Here is a typical example of a simplification rule: | |
34124 | ||
34125 | @smallexample | |
34126 | (math-defsimplify calcFunc-arcsinh | |
34127 | (or (and (math-looks-negp (nth 1 expr)) | |
34128 | (math-neg (list 'calcFunc-arcsinh | |
34129 | (math-neg (nth 1 expr))))) | |
34130 | (and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh) | |
34131 | (or math-living-dangerously | |
34132 | (math-known-realp (nth 1 (nth 1 expr)))) | |
34133 | (nth 1 (nth 1 expr))))) | |
34134 | @end smallexample | |
34135 | ||
34136 | This is really a pair of rules written with one @code{math-defsimplify} | |
34137 | for convenience; the first replaces @samp{arcsinh(-x)} with | |
34138 | @samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x}, | |
a4231b04 | 34139 | replaces @samp{arcsinh(sinh(x))} with @samp{x}. |
d7b8e6c6 EZ |
34140 | @end defmac |
34141 | ||
34142 | @defun common-constant-factor expr | |
34143 | Check @var{expr} to see if it is a sum of terms all multiplied by the | |
34144 | same rational value. If so, return this value. If not, return @code{nil}. | |
34145 | For example, if called on @samp{6x + 9y + 12z}, it would return 3, since | |
34146 | 3 is a common factor of all the terms. | |
34147 | @end defun | |
34148 | ||
34149 | @defun cancel-common-factor expr factor | |
34150 | Assuming @var{expr} is a sum with @var{factor} as a common factor, | |
34151 | divide each term of the sum by @var{factor}. This is done by | |
34152 | destructively modifying parts of @var{expr}, on the assumption that | |
34153 | it is being used by a simplification rule (where such things are | |
34154 | allowed; see above). For example, consider this built-in rule for | |
34155 | square roots: | |
34156 | ||
34157 | @smallexample | |
34158 | (math-defsimplify calcFunc-sqrt | |
34159 | (let ((fac (math-common-constant-factor (nth 1 expr)))) | |
34160 | (and fac (not (eq fac 1)) | |
34161 | (math-mul (math-normalize (list 'calcFunc-sqrt fac)) | |
34162 | (math-normalize | |
34163 | (list 'calcFunc-sqrt | |
34164 | (math-cancel-common-factor | |
34165 | (nth 1 expr) fac))))))) | |
34166 | @end smallexample | |
34167 | @end defun | |
34168 | ||
34169 | @defun frac-gcd a b | |
34170 | Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be | |
34171 | rational numbers. This is the fraction composed of the GCD of the | |
34172 | numerators of @var{a} and @var{b}, over the GCD of the denominators. | |
34173 | It is used by @code{common-constant-factor}. Note that the standard | |
a4231b04 | 34174 | @code{gcd} function uses the LCM to combine the denominators. |
d7b8e6c6 EZ |
34175 | @end defun |
34176 | ||
34177 | @defun map-tree func expr many | |
34178 | Try applying Lisp function @var{func} to various sub-expressions of | |
34179 | @var{expr}. Initially, call @var{func} with @var{expr} itself as an | |
34180 | argument. If this returns an expression which is not @code{equal} to | |
34181 | @var{expr}, apply @var{func} again until eventually it does return | |
34182 | @var{expr} with no changes. Then, if @var{expr} is a function call, | |
34183 | recursively apply @var{func} to each of the arguments. This keeps going | |
34184 | until no changes occur anywhere in the expression; this final expression | |
34185 | is returned by @code{map-tree}. Note that, unlike simplification rules, | |
34186 | @var{func} functions may @emph{not} make destructive changes to | |
34187 | @var{expr}. If a third argument @var{many} is provided, it is an | |
34188 | integer which says how many times @var{func} may be applied; the | |
a4231b04 | 34189 | default, as described above, is infinitely many times. |
d7b8e6c6 EZ |
34190 | @end defun |
34191 | ||
34192 | @defun compile-rewrites rules | |
34193 | Compile the rewrite rule set specified by @var{rules}, which should | |
34194 | be a formula that is either a vector or a variable name. If the latter, | |
34195 | the compiled rules are saved so that later @code{compile-rules} calls | |
34196 | for that same variable can return immediately. If there are problems | |
34197 | with the rules, this function calls @code{error} with a suitable | |
34198 | message. | |
34199 | @end defun | |
34200 | ||
34201 | @defun apply-rewrites expr crules heads | |
34202 | Apply the compiled rewrite rule set @var{crules} to the expression | |
34203 | @var{expr}. This will make only one rewrite and only checks at the | |
34204 | top level of the expression. The result @code{nil} if no rules | |
34205 | matched, or if the only rules that matched did not actually change | |
34206 | the expression. The @var{heads} argument is optional; if is given, | |
34207 | it should be a list of all function names that (may) appear in | |
34208 | @var{expr}. The rewrite compiler tags each rule with the | |
34209 | rarest-looking function name in the rule; if you specify @var{heads}, | |
34210 | @code{apply-rewrites} can use this information to narrow its search | |
34211 | down to just a few rules in the rule set. | |
34212 | @end defun | |
34213 | ||
34214 | @defun rewrite-heads expr | |
34215 | Compute a @var{heads} list for @var{expr} suitable for use with | |
34216 | @code{apply-rewrites}, as discussed above. | |
34217 | @end defun | |
34218 | ||
34219 | @defun rewrite expr rules many | |
34220 | This is an all-in-one rewrite function. It compiles the rule set | |
34221 | specified by @var{rules}, then uses @code{map-tree} to apply the | |
34222 | rules throughout @var{expr} up to @var{many} (default infinity) | |
34223 | times. | |
34224 | @end defun | |
34225 | ||
34226 | @defun match-patterns pat vec not-flag | |
34227 | Given a Calc vector @var{vec} and an uncompiled pattern set or | |
34228 | pattern set variable @var{pat}, this function returns a new vector | |
34229 | of all elements of @var{vec} which do (or don't, if @var{not-flag} is | |
34230 | non-@code{nil}) match any of the patterns in @var{pat}. | |
34231 | @end defun | |
34232 | ||
34233 | @defun deriv expr var value symb | |
34234 | Compute the derivative of @var{expr} with respect to variable @var{var} | |
34235 | (which may actually be any sub-expression). If @var{value} is specified, | |
34236 | the derivative is evaluated at the value of @var{var}; otherwise, the | |
34237 | derivative is left in terms of @var{var}. If the expression contains | |
34238 | functions for which no derivative formula is known, new derivative | |
34239 | functions are invented by adding primes to the names; @pxref{Calculus}. | |
34240 | However, if @var{symb} is non-@code{nil}, the presence of undifferentiable | |
34241 | functions in @var{expr} instead cancels the whole differentiation, and | |
34242 | @code{deriv} returns @code{nil} instead. | |
34243 | ||
34244 | Derivatives of an @var{n}-argument function can be defined by | |
34245 | adding a @code{math-derivative-@var{n}} property to the property list | |
34246 | of the symbol for the function's derivative, which will be the | |
34247 | function name followed by an apostrophe. The value of the property | |
34248 | should be a Lisp function; it is called with the same arguments as the | |
34249 | original function call that is being differentiated. It should return | |
34250 | a formula for the derivative. For example, the derivative of @code{ln} | |
34251 | is defined by | |
34252 | ||
34253 | @smallexample | |
34254 | (put 'calcFunc-ln\' 'math-derivative-1 | |
34255 | (function (lambda (u) (math-div 1 u)))) | |
34256 | @end smallexample | |
34257 | ||
34258 | The two-argument @code{log} function has two derivatives, | |
34259 | @smallexample | |
34260 | (put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx | |
34261 | (function (lambda (x b) ... ))) | |
34262 | (put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db | |
34263 | (function (lambda (x b) ... ))) | |
34264 | @end smallexample | |
34265 | @end defun | |
34266 | ||
34267 | @defun tderiv expr var value symb | |
34268 | Compute the total derivative of @var{expr}. This is the same as | |
34269 | @code{deriv}, except that variables other than @var{var} are not | |
34270 | assumed to be constant with respect to @var{var}. | |
34271 | @end defun | |
34272 | ||
34273 | @defun integ expr var low high | |
34274 | Compute the integral of @var{expr} with respect to @var{var}. | |
34275 | @xref{Calculus}, for further details. | |
34276 | @end defun | |
34277 | ||
34278 | @defmac math-defintegral funcs body | |
34279 | Define a rule for integrating a function or functions of one argument; | |
34280 | this macro is very similar in format to @code{math-defsimplify}. | |
34281 | The main difference is that here @var{body} is the body of a function | |
34282 | with a single argument @code{u} which is bound to the argument to the | |
34283 | function being integrated, not the function call itself. Also, the | |
34284 | variable of integration is available as @code{math-integ-var}. If | |
34285 | evaluation of the integral requires doing further integrals, the body | |
34286 | should call @samp{(math-integral @var{x})} to find the integral of | |
34287 | @var{x} with respect to @code{math-integ-var}; this function returns | |
34288 | @code{nil} if the integral could not be done. Some examples: | |
34289 | ||
34290 | @smallexample | |
34291 | (math-defintegral calcFunc-conj | |
34292 | (let ((int (math-integral u))) | |
34293 | (and int | |
34294 | (list 'calcFunc-conj int)))) | |
34295 | ||
34296 | (math-defintegral calcFunc-cos | |
34297 | (and (equal u math-integ-var) | |
34298 | (math-from-radians-2 (list 'calcFunc-sin u)))) | |
34299 | @end smallexample | |
34300 | ||
34301 | In the @code{cos} example, we define only the integral of @samp{cos(x) dx}, | |
34302 | relying on the general integration-by-substitution facility to handle | |
34303 | cosines of more complicated arguments. An integration rule should return | |
34304 | @code{nil} if it can't do the integral; if several rules are defined for | |
34305 | the same function, they are tried in order until one returns a non-@code{nil} | |
a4231b04 | 34306 | result. |
d7b8e6c6 EZ |
34307 | @end defmac |
34308 | ||
34309 | @defmac math-defintegral-2 funcs body | |
34310 | Define a rule for integrating a function or functions of two arguments. | |
34311 | This is exactly analogous to @code{math-defintegral}, except that @var{body} | |
34312 | is written as the body of a function with two arguments, @var{u} and | |
a4231b04 | 34313 | @var{v}. |
d7b8e6c6 EZ |
34314 | @end defmac |
34315 | ||
34316 | @defun solve-for lhs rhs var full | |
34317 | Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating | |
34318 | the variable @var{var} on the lefthand side; return the resulting righthand | |
34319 | side, or @code{nil} if the equation cannot be solved. The variable | |
34320 | @var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that | |
34321 | the return value is a formula which does not contain @var{var}; this is | |
34322 | different from the user-level @code{solve} and @code{finv} functions, | |
34323 | which return a rearranged equation or a functional inverse, respectively. | |
34324 | If @var{full} is non-@code{nil}, a full solution including dummy signs | |
34325 | and dummy integers will be produced. User-defined inverses are provided | |
a4231b04 | 34326 | as properties in a manner similar to derivatives: |
d7b8e6c6 EZ |
34327 | |
34328 | @smallexample | |
34329 | (put 'calcFunc-ln 'math-inverse | |
34330 | (function (lambda (x) (list 'calcFunc-exp x)))) | |
34331 | @end smallexample | |
34332 | ||
34333 | This function can call @samp{(math-solve-get-sign @var{x})} to create | |
34334 | a new arbitrary sign variable, returning @var{x} times that sign, and | |
34335 | @samp{(math-solve-get-int @var{x})} to create a new arbitrary integer | |
34336 | variable multiplied by @var{x}. These functions simply return @var{x} | |
34337 | if the caller requested a non-``full'' solution. | |
34338 | @end defun | |
34339 | ||
34340 | @defun solve-eqn expr var full | |
34341 | This version of @code{solve-for} takes an expression which will | |
34342 | typically be an equation or inequality. (If it is not, it will be | |
34343 | interpreted as the equation @samp{@var{expr} = 0}.) It returns an | |
34344 | equation or inequality, or @code{nil} if no solution could be found. | |
34345 | @end defun | |
34346 | ||
34347 | @defun solve-system exprs vars full | |
34348 | This function solves a system of equations. Generally, @var{exprs} | |
34349 | and @var{vars} will be vectors of equal length. | |
34350 | @xref{Solving Systems of Equations}, for other options. | |
34351 | @end defun | |
34352 | ||
34353 | @defun expr-contains expr var | |
34354 | Returns a non-@code{nil} value if @var{var} occurs as a subexpression | |
34355 | of @var{expr}. | |
34356 | ||
34357 | This function might seem at first to be identical to | |
34358 | @code{calc-find-sub-formula}. The key difference is that | |
34359 | @code{expr-contains} uses @code{equal} to test for matches, whereas | |
34360 | @code{calc-find-sub-formula} uses @code{eq}. In the formula | |
34361 | @samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not | |
a4231b04 | 34362 | @code{eq} to each other. |
d7b8e6c6 EZ |
34363 | @end defun |
34364 | ||
34365 | @defun expr-contains-count expr var | |
34366 | Returns the number of occurrences of @var{var} as a subexpression | |
a4231b04 | 34367 | of @var{expr}, or @code{nil} if there are no occurrences. |
d7b8e6c6 EZ |
34368 | @end defun |
34369 | ||
34370 | @defun expr-depends expr var | |
34371 | Returns true if @var{expr} refers to any variable the occurs in @var{var}. | |
34372 | In other words, it checks if @var{expr} and @var{var} have any variables | |
34373 | in common. | |
34374 | @end defun | |
34375 | ||
34376 | @defun expr-contains-vars expr | |
34377 | Return true if @var{expr} contains any variables, or @code{nil} if @var{expr} | |
34378 | contains only constants and functions with constant arguments. | |
34379 | @end defun | |
34380 | ||
34381 | @defun expr-subst expr old new | |
34382 | Returns a copy of @var{expr}, with all occurrences of @var{old} replaced | |
34383 | by @var{new}. This treats @code{lambda} forms specially with respect | |
34384 | to the dummy argument variables, so that the effect is always to return | |
a4231b04 | 34385 | @var{expr} evaluated at @var{old} = @var{new}. |
d7b8e6c6 EZ |
34386 | @end defun |
34387 | ||
34388 | @defun multi-subst expr old new | |
34389 | This is like @code{expr-subst}, except that @var{old} and @var{new} | |
34390 | are lists of expressions to be substituted simultaneously. If one | |
34391 | list is shorter than the other, trailing elements of the longer list | |
34392 | are ignored. | |
34393 | @end defun | |
34394 | ||
34395 | @defun expr-weight expr | |
34396 | Returns the ``weight'' of @var{expr}, basically a count of the total | |
34397 | number of objects and function calls that appear in @var{expr}. For | |
34398 | ``primitive'' objects, this will be one. | |
34399 | @end defun | |
34400 | ||
34401 | @defun expr-height expr | |
34402 | Returns the ``height'' of @var{expr}, which is the deepest level to | |
34403 | which function calls are nested. (Note that @samp{@var{a} + @var{b}} | |
a4231b04 | 34404 | counts as a function call.) For primitive objects, this returns zero. |
d7b8e6c6 EZ |
34405 | @end defun |
34406 | ||
34407 | @defun polynomial-p expr var | |
34408 | Check if @var{expr} is a polynomial in variable (or sub-expression) | |
34409 | @var{var}. If so, return the degree of the polynomial, that is, the | |
34410 | highest power of @var{var} that appears in @var{expr}. For example, | |
34411 | for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns | |
34412 | @code{nil} unless @var{expr}, when expanded out by @kbd{a x} | |
34413 | (@code{calc-expand}), would consist of a sum of terms in which @var{var} | |
34414 | appears only raised to nonnegative integer powers. Note that if | |
34415 | @var{var} does not occur in @var{expr}, then @var{expr} is considered | |
a4231b04 | 34416 | a polynomial of degree 0. |
d7b8e6c6 EZ |
34417 | @end defun |
34418 | ||
34419 | @defun is-polynomial expr var degree loose | |
34420 | Check if @var{expr} is a polynomial in variable or sub-expression | |
34421 | @var{var}, and, if so, return a list representation of the polynomial | |
34422 | where the elements of the list are coefficients of successive powers of | |
34423 | @var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the | |
34424 | list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would | |
34425 | produce the list @samp{(1 2 1)}. The highest element of the list will | |
34426 | be non-zero, with the special exception that if @var{expr} is the | |
34427 | constant zero, the returned value will be @samp{(0)}. Return @code{nil} | |
34428 | if @var{expr} is not a polynomial in @var{var}. If @var{degree} is | |
34429 | specified, this will not consider polynomials of degree higher than that | |
34430 | value. This is a good precaution because otherwise an input of | |
34431 | @samp{(x+1)^1000} will cause a huge coefficient list to be built. If | |
34432 | @var{loose} is non-@code{nil}, then a looser definition of a polynomial | |
34433 | is used in which coefficients are no longer required not to depend on | |
34434 | @var{var}, but are only required not to take the form of polynomials | |
34435 | themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose | |
34436 | polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin | |
34437 | x))}. The result will never be @code{nil} in loose mode, since any | |
a4231b04 | 34438 | expression can be interpreted as a ``constant'' loose polynomial. |
d7b8e6c6 EZ |
34439 | @end defun |
34440 | ||
34441 | @defun polynomial-base expr pred | |
34442 | Check if @var{expr} is a polynomial in any variable that occurs in it; | |
34443 | if so, return that variable. (If @var{expr} is a multivariate polynomial, | |
34444 | this chooses one variable arbitrarily.) If @var{pred} is specified, it should | |
34445 | be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})}, | |
34446 | and which should return true if @code{mpb-top-expr} (a global name for | |
34447 | the original @var{expr}) is a suitable polynomial in @var{subexpr}. | |
34448 | The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})}; | |
34449 | you can use @var{pred} to specify additional conditions. Or, you could | |
34450 | have @var{pred} build up a list of every suitable @var{subexpr} that | |
a4231b04 | 34451 | is found. |
d7b8e6c6 EZ |
34452 | @end defun |
34453 | ||
34454 | @defun poly-simplify poly | |
34455 | Simplify polynomial coefficient list @var{poly} by (destructively) | |
34456 | clipping off trailing zeros. | |
34457 | @end defun | |
34458 | ||
34459 | @defun poly-mix a ac b bc | |
34460 | Mix two polynomial lists @var{a} and @var{b} (in the form returned by | |
34461 | @code{is-polynomial}) in a linear combination with coefficient expressions | |
34462 | @var{ac} and @var{bc}. The result is a (not necessarily simplified) | |
a4231b04 | 34463 | polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}. |
d7b8e6c6 EZ |
34464 | @end defun |
34465 | ||
34466 | @defun poly-mul a b | |
34467 | Multiply two polynomial coefficient lists @var{a} and @var{b}. The | |
34468 | result will be in simplified form if the inputs were simplified. | |
34469 | @end defun | |
34470 | ||
34471 | @defun build-polynomial-expr poly var | |
34472 | Construct a Calc formula which represents the polynomial coefficient | |
34473 | list @var{poly} applied to variable @var{var}. The @kbd{a c} | |
34474 | (@code{calc-collect}) command uses @code{is-polynomial} to turn an | |
34475 | expression into a coefficient list, then @code{build-polynomial-expr} | |
a4231b04 | 34476 | to turn the list back into an expression in regular form. |
d7b8e6c6 EZ |
34477 | @end defun |
34478 | ||
34479 | @defun check-unit-name var | |
34480 | Check if @var{var} is a variable which can be interpreted as a unit | |
34481 | name. If so, return the units table entry for that unit. This | |
34482 | will be a list whose first element is the unit name (not counting | |
34483 | prefix characters) as a symbol and whose second element is the | |
34484 | Calc expression which defines the unit. (Refer to the Calc sources | |
34485 | for details on the remaining elements of this list.) If @var{var} | |
34486 | is not a variable or is not a unit name, return @code{nil}. | |
34487 | @end defun | |
34488 | ||
34489 | @defun units-in-expr-p expr sub-exprs | |
34490 | Return true if @var{expr} contains any variables which can be | |
34491 | interpreted as units. If @var{sub-exprs} is @code{t}, the entire | |
34492 | expression is searched. If @var{sub-exprs} is @code{nil}, this | |
a4231b04 | 34493 | checks whether @var{expr} is directly a units expression. |
d7b8e6c6 EZ |
34494 | @end defun |
34495 | ||
34496 | @defun single-units-in-expr-p expr | |
34497 | Check whether @var{expr} contains exactly one units variable. If so, | |
34498 | return the units table entry for the variable. If @var{expr} does | |
34499 | not contain any units, return @code{nil}. If @var{expr} contains | |
34500 | two or more units, return the symbol @code{wrong}. | |
34501 | @end defun | |
34502 | ||
34503 | @defun to-standard-units expr which | |
34504 | Convert units expression @var{expr} to base units. If @var{which} | |
34505 | is @code{nil}, use Calc's native base units. Otherwise, @var{which} | |
34506 | can specify a units system, which is a list of two-element lists, | |
34507 | where the first element is a Calc base symbol name and the second | |
a4231b04 | 34508 | is an expression to substitute for it. |
d7b8e6c6 EZ |
34509 | @end defun |
34510 | ||
34511 | @defun remove-units expr | |
34512 | Return a copy of @var{expr} with all units variables replaced by ones. | |
34513 | This expression is generally normalized before use. | |
34514 | @end defun | |
34515 | ||
34516 | @defun extract-units expr | |
34517 | Return a copy of @var{expr} with everything but units variables replaced | |
34518 | by ones. | |
34519 | @end defun | |
34520 | ||
34521 | @node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals | |
34522 | @subsubsection I/O and Formatting Functions | |
34523 | ||
34524 | @noindent | |
34525 | The functions described here are responsible for parsing and formatting | |
34526 | Calc numbers and formulas. | |
34527 | ||
34528 | @defun calc-eval str sep arg1 arg2 @dots{} | |
34529 | This is the simplest interface to the Calculator from another Lisp program. | |
34530 | @xref{Calling Calc from Your Programs}. | |
34531 | @end defun | |
34532 | ||
34533 | @defun read-number str | |
34534 | If string @var{str} contains a valid Calc number, either integer, | |
34535 | fraction, float, or HMS form, this function parses and returns that | |
34536 | number. Otherwise, it returns @code{nil}. | |
34537 | @end defun | |
34538 | ||
34539 | @defun read-expr str | |
34540 | Read an algebraic expression from string @var{str}. If @var{str} does | |
34541 | not have the form of a valid expression, return a list of the form | |
34542 | @samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index | |
34543 | into @var{str} of the general location of the error, and @var{msg} is | |
a4231b04 | 34544 | a string describing the problem. |
d7b8e6c6 EZ |
34545 | @end defun |
34546 | ||
34547 | @defun read-exprs str | |
34548 | Read a list of expressions separated by commas, and return it as a | |
34549 | Lisp list. If an error occurs in any expressions, an error list as | |
34550 | shown above is returned instead. | |
34551 | @end defun | |
34552 | ||
34553 | @defun calc-do-alg-entry initial prompt no-norm | |
34554 | Read an algebraic formula or formulas using the minibuffer. All | |
34555 | conventions of regular algebraic entry are observed. The return value | |
34556 | is a list of Calc formulas; there will be more than one if the user | |
34557 | entered a list of values separated by commas. The result is @code{nil} | |
34558 | if the user presses Return with a blank line. If @var{initial} is | |
34559 | given, it is a string which the minibuffer will initially contain. | |
34560 | If @var{prompt} is given, it is the prompt string to use; the default | |
34561 | is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will | |
34562 | be returned exactly as parsed; otherwise, they will be passed through | |
a4231b04 | 34563 | @code{calc-normalize} first. |
d7b8e6c6 EZ |
34564 | |
34565 | To support the use of @kbd{$} characters in the algebraic entry, use | |
34566 | @code{let} to bind @code{calc-dollar-values} to a list of the values | |
34567 | to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind | |
34568 | @code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used} | |
34569 | will have been changed to the highest number of consecutive @kbd{$}s | |
a4231b04 | 34570 | that actually appeared in the input. |
d7b8e6c6 EZ |
34571 | @end defun |
34572 | ||
34573 | @defun format-number a | |
34574 | Convert the real or complex number or HMS form @var{a} to string form. | |
34575 | @end defun | |
34576 | ||
34577 | @defun format-flat-expr a prec | |
34578 | Convert the arbitrary Calc number or formula @var{a} to string form, | |
34579 | in the style used by the trail buffer and the @code{calc-edit} command. | |
34580 | This is a simple format designed | |
34581 | mostly to guarantee the string is of a form that can be re-parsed by | |
34582 | @code{read-expr}. Most formatting modes, such as digit grouping, | |
34583 | complex number format, and point character, are ignored to ensure the | |
34584 | result will be re-readable. The @var{prec} parameter is normally 0; if | |
34585 | you pass a large integer like 1000 instead, the expression will be | |
a4231b04 | 34586 | surrounded by parentheses unless it is a plain number or variable name. |
d7b8e6c6 EZ |
34587 | @end defun |
34588 | ||
34589 | @defun format-nice-expr a width | |
34590 | This is like @code{format-flat-expr} (with @var{prec} equal to 0), | |
34591 | except that newlines will be inserted to keep lines down to the | |
34592 | specified @var{width}, and vectors that look like matrices or rewrite | |
34593 | rules are written in a pseudo-matrix format. The @code{calc-edit} | |
34594 | command uses this when only one stack entry is being edited. | |
34595 | @end defun | |
34596 | ||
34597 | @defun format-value a width | |
34598 | Convert the Calc number or formula @var{a} to string form, using the | |
269b7745 | 34599 | format seen in the stack buffer. Beware the string returned may |
d7b8e6c6 EZ |
34600 | not be re-readable by @code{read-expr}, for example, because of digit |
34601 | grouping. Multi-line objects like matrices produce strings that | |
34602 | contain newline characters to separate the lines. The @var{w} | |
34603 | parameter, if given, is the target window size for which to format | |
34604 | the expressions. If @var{w} is omitted, the width of the Calculator | |
a4231b04 | 34605 | window is used. |
d7b8e6c6 EZ |
34606 | @end defun |
34607 | ||
34608 | @defun compose-expr a prec | |
34609 | Format the Calc number or formula @var{a} according to the current | |
34610 | language mode, returning a ``composition.'' To learn about the | |
34611 | structure of compositions, see the comments in the Calc source code. | |
34612 | You can specify the format of a given type of function call by putting | |
34613 | a @code{math-compose-@var{lang}} property on the function's symbol, | |
34614 | whose value is a Lisp function that takes @var{a} and @var{prec} as | |
34615 | arguments and returns a composition. Here @var{lang} is a language | |
34616 | mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal}, | |
34617 | @code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}. | |
34618 | In Big mode, Calc actually tries @code{math-compose-big} first, then | |
34619 | tries @code{math-compose-normal}. If this property does not exist, | |
34620 | or if the function returns @code{nil}, the function is written in the | |
34621 | normal function-call notation for that language. | |
34622 | @end defun | |
34623 | ||
34624 | @defun composition-to-string c w | |
34625 | Convert a composition structure returned by @code{compose-expr} into | |
34626 | a string. Multi-line compositions convert to strings containing | |
34627 | newline characters. The target window size is given by @var{w}. | |
34628 | The @code{format-value} function basically calls @code{compose-expr} | |
34629 | followed by @code{composition-to-string}. | |
34630 | @end defun | |
34631 | ||
34632 | @defun comp-width c | |
34633 | Compute the width in characters of composition @var{c}. | |
34634 | @end defun | |
34635 | ||
34636 | @defun comp-height c | |
34637 | Compute the height in lines of composition @var{c}. | |
34638 | @end defun | |
34639 | ||
34640 | @defun comp-ascent c | |
34641 | Compute the portion of the height of composition @var{c} which is on or | |
34642 | above the baseline. For a one-line composition, this will be one. | |
34643 | @end defun | |
34644 | ||
34645 | @defun comp-descent c | |
34646 | Compute the portion of the height of composition @var{c} which is below | |
34647 | the baseline. For a one-line composition, this will be zero. | |
34648 | @end defun | |
34649 | ||
34650 | @defun comp-first-char c | |
34651 | If composition @var{c} is a ``flat'' composition, return the first | |
34652 | (leftmost) character of the composition as an integer. Otherwise, | |
a4231b04 | 34653 | return @code{nil}. |
d7b8e6c6 EZ |
34654 | @end defun |
34655 | ||
34656 | @defun comp-last-char c | |
34657 | If composition @var{c} is a ``flat'' composition, return the last | |
34658 | (rightmost) character, otherwise return @code{nil}. | |
34659 | @end defun | |
34660 | ||
34661 | @comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals | |
34662 | @comment @subsubsection Lisp Variables | |
177c0ea7 | 34663 | @comment |
d7b8e6c6 EZ |
34664 | @comment @noindent |
34665 | @comment (This section is currently unfinished.) | |
34666 | ||
34667 | @node Hooks, , Formatting Lisp Functions, Internals | |
34668 | @subsubsection Hooks | |
34669 | ||
34670 | @noindent | |
34671 | Hooks are variables which contain Lisp functions (or lists of functions) | |
34672 | which are called at various times. Calc defines a number of hooks | |
34673 | that help you to customize it in various ways. Calc uses the Lisp | |
34674 | function @code{run-hooks} to invoke the hooks shown below. Several | |
34675 | other customization-related variables are also described here. | |
34676 | ||
34677 | @defvar calc-load-hook | |
34678 | This hook is called at the end of @file{calc.el}, after the file has | |
34679 | been loaded, before any functions in it have been called, but after | |
34680 | @code{calc-mode-map} and similar variables have been set up. | |
34681 | @end defvar | |
34682 | ||
34683 | @defvar calc-ext-load-hook | |
34684 | This hook is called at the end of @file{calc-ext.el}. | |
34685 | @end defvar | |
34686 | ||
34687 | @defvar calc-start-hook | |
34688 | This hook is called as the last step in a @kbd{M-x calc} command. | |
34689 | At this point, the Calc buffer has been created and initialized if | |
34690 | necessary, the Calc window and trail window have been created, | |
34691 | and the ``Welcome to Calc'' message has been displayed. | |
34692 | @end defvar | |
34693 | ||
34694 | @defvar calc-mode-hook | |
34695 | This hook is called when the Calc buffer is being created. Usually | |
34696 | this will only happen once per Emacs session. The hook is called | |
34697 | after Emacs has switched to the new buffer, the mode-settings file | |
34698 | has been read if necessary, and all other buffer-local variables | |
34699 | have been set up. After this hook returns, Calc will perform a | |
34700 | @code{calc-refresh} operation, set up the mode line display, then | |
34701 | evaluate any deferred @code{calc-define} properties that have not | |
34702 | been evaluated yet. | |
34703 | @end defvar | |
34704 | ||
34705 | @defvar calc-trail-mode-hook | |
34706 | This hook is called when the Calc Trail buffer is being created. | |
34707 | It is called as the very last step of setting up the Trail buffer. | |
34708 | Like @code{calc-mode-hook}, this will normally happen only once | |
34709 | per Emacs session. | |
34710 | @end defvar | |
34711 | ||
34712 | @defvar calc-end-hook | |
34713 | This hook is called by @code{calc-quit}, generally because the user | |
58547c3e | 34714 | presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will |
d7b8e6c6 EZ |
34715 | be the current buffer. The hook is called as the very first |
34716 | step, before the Calc window is destroyed. | |
34717 | @end defvar | |
34718 | ||
34719 | @defvar calc-window-hook | |
651e237b | 34720 | If this hook is non-@code{nil}, it is called to create the Calc window. |
d7b8e6c6 EZ |
34721 | Upon return, this new Calc window should be the current window. |
34722 | (The Calc buffer will already be the current buffer when the | |
34723 | hook is called.) If the hook is not defined, Calc will | |
34724 | generally use @code{split-window}, @code{set-window-buffer}, | |
34725 | and @code{select-window} to create the Calc window. | |
34726 | @end defvar | |
34727 | ||
34728 | @defvar calc-trail-window-hook | |
651e237b JB |
34729 | If this hook is non-@code{nil}, it is called to create the Calc Trail |
34730 | window. The variable @code{calc-trail-buffer} will contain the buffer | |
34731 | which the window should use. Unlike @code{calc-window-hook}, this hook | |
34732 | must @emph{not} switch into the new window. | |
d7b8e6c6 EZ |
34733 | @end defvar |
34734 | ||
5127c216 JB |
34735 | @defvar calc-embedded-mode-hook |
34736 | This hook is called the first time that Embedded mode is entered. | |
34737 | @end defvar | |
34738 | ||
34739 | @defvar calc-embedded-new-buffer-hook | |
34740 | This hook is called each time that Embedded mode is entered in a | |
34741 | new buffer. | |
34742 | @end defvar | |
34743 | ||
34744 | @defvar calc-embedded-new-formula-hook | |
34745 | This hook is called each time that Embedded mode is enabled for a | |
34746 | new formula. | |
34747 | @end defvar | |
34748 | ||
d7b8e6c6 EZ |
34749 | @defvar calc-edit-mode-hook |
34750 | This hook is called by @code{calc-edit} (and the other ``edit'' | |
34751 | commands) when the temporary editing buffer is being created. | |
34752 | The buffer will have been selected and set up to be in | |
34753 | @code{calc-edit-mode}, but will not yet have been filled with | |
34754 | text. (In fact it may still have leftover text from a previous | |
34755 | @code{calc-edit} command.) | |
34756 | @end defvar | |
34757 | ||
34758 | @defvar calc-mode-save-hook | |
34759 | This hook is called by the @code{calc-save-modes} command, | |
34760 | after Calc's own mode features have been inserted into the | |
3b846359 | 34761 | Calc init file and just before the ``End of mode settings'' |
d7b8e6c6 EZ |
34762 | message is inserted. |
34763 | @end defvar | |
34764 | ||
34765 | @defvar calc-reset-hook | |
58547c3e | 34766 | This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has |
d7b8e6c6 EZ |
34767 | reset all modes. The Calc buffer will be the current buffer. |
34768 | @end defvar | |
34769 | ||
34770 | @defvar calc-other-modes | |
34771 | This variable contains a list of strings. The strings are | |
34772 | concatenated at the end of the modes portion of the Calc | |
34773 | mode line (after standard modes such as ``Deg'', ``Inv'' and | |
34774 | ``Hyp''). Each string should be a short, single word followed | |
34775 | by a space. The variable is @code{nil} by default. | |
34776 | @end defvar | |
34777 | ||
34778 | @defvar calc-mode-map | |
34779 | This is the keymap that is used by Calc mode. The best time | |
34780 | to adjust it is probably in a @code{calc-mode-hook}. If the | |
34781 | Calc extensions package (@file{calc-ext.el}) has not yet been | |
34782 | loaded, many of these keys will be bound to @code{calc-missing-key}, | |
34783 | which is a command that loads the extensions package and | |
34784 | ``retypes'' the key. If your @code{calc-mode-hook} rebinds | |
34785 | one of these keys, it will probably be overridden when the | |
34786 | extensions are loaded. | |
34787 | @end defvar | |
34788 | ||
34789 | @defvar calc-digit-map | |
34790 | This is the keymap that is used during numeric entry. Numeric | |
34791 | entry uses the minibuffer, but this map binds every non-numeric | |
34792 | key to @code{calcDigit-nondigit} which generally calls | |
34793 | @code{exit-minibuffer} and ``retypes'' the key. | |
34794 | @end defvar | |
34795 | ||
34796 | @defvar calc-alg-ent-map | |
34797 | This is the keymap that is used during algebraic entry. This is | |
34798 | mostly a copy of @code{minibuffer-local-map}. | |
34799 | @end defvar | |
34800 | ||
34801 | @defvar calc-store-var-map | |
34802 | This is the keymap that is used during entry of variable names for | |
34803 | commands like @code{calc-store} and @code{calc-recall}. This is | |
34804 | mostly a copy of @code{minibuffer-local-completion-map}. | |
34805 | @end defvar | |
34806 | ||
34807 | @defvar calc-edit-mode-map | |
34808 | This is the (sparse) keymap used by @code{calc-edit} and other | |
34809 | temporary editing commands. It binds @key{RET}, @key{LFD}, | |
34810 | and @kbd{C-c C-c} to @code{calc-edit-finish}. | |
34811 | @end defvar | |
34812 | ||
34813 | @defvar calc-mode-var-list | |
34814 | This is a list of variables which are saved by @code{calc-save-modes}. | |
34815 | Each entry is a list of two items, the variable (as a Lisp symbol) | |
34816 | and its default value. When modes are being saved, each variable | |
34817 | is compared with its default value (using @code{equal}) and any | |
34818 | non-default variables are written out. | |
34819 | @end defvar | |
34820 | ||
34821 | @defvar calc-local-var-list | |
34822 | This is a list of variables which should be buffer-local to the | |
34823 | Calc buffer. Each entry is a variable name (as a Lisp symbol). | |
34824 | These variables also have their default values manipulated by | |
34825 | the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}. | |
34826 | Since @code{calc-mode-hook} is called after this list has been | |
34827 | used the first time, your hook should add a variable to the | |
34828 | list and also call @code{make-local-variable} itself. | |
34829 | @end defvar | |
34830 | ||
58547c3e JB |
34831 | @node Customizing Calc, Reporting Bugs, Programming, Top |
34832 | @appendix Customizing Calc | |
34833 | ||
34834 | The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish | |
34835 | to use a different prefix, you can put | |
b154df16 | 34836 | |
58547c3e JB |
34837 | @example |
34838 | (global-set-key "NEWPREFIX" 'calc-dispatch) | |
34839 | @end example | |
34840 | ||
34841 | @noindent | |
34842 | in your .emacs file. | |
34843 | (@xref{Key Bindings,,Customizing Key Bindings,emacs, | |
34844 | The GNU Emacs Manual}, for more information on binding keys.) | |
34845 | A convenient way to start Calc is with @kbd{C-x * *}; to make it equally | |
34846 | convenient for users who use a different prefix, the prefix can be | |
34847 | followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or | |
34848 | @kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last | |
34849 | character of the prefix can simply be typed twice. | |
34850 | ||
34851 | Calc is controlled by many variables, most of which can be reset | |
b154df16 JB |
34852 | from within Calc. Some variables are less involved with actual |
34853 | calculation, and can be set outside of Calc using Emacs's | |
34854 | customization facilities. These variables are listed below. | |
34855 | Typing @kbd{M-x customize-variable RET @var{variable-name} RET} | |
34856 | will bring up a buffer in which the variable's value can be redefined. | |
34857 | Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which | |
34858 | contains all of Calc's customizable variables. (These variables can | |
34859 | also be reset by putting the appropriate lines in your .emacs file; | |
34860 | @xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.) | |
34861 | ||
34862 | Some of the customizable variables are regular expressions. A regular | |
34863 | expression is basically a pattern that Calc can search for. | |
34864 | See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual} | |
34865 | to see how regular expressions work. | |
d7b8e6c6 | 34866 | |
651e237b | 34867 | @defvar calc-settings-file |
b154df16 JB |
34868 | The variable @code{calc-settings-file} holds the file name in |
34869 | which commands like @kbd{m m} and @kbd{Z P} store ``permanent'' | |
34870 | definitions. | |
34871 | If @code{calc-settings-file} is not your user init file (typically | |
34872 | @file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is | |
34873 | @code{nil}, then Calc will automatically load your settings file (if it | |
34874 | exists) the first time Calc is invoked. | |
34875 | ||
34876 | The default value for this variable is @code{"~/.calc.el"}. | |
651e237b | 34877 | @end defvar |
b154df16 | 34878 | |
651e237b | 34879 | @defvar calc-gnuplot-name |
b154df16 JB |
34880 | See @ref{Graphics}.@* |
34881 | The variable @code{calc-gnuplot-name} should be the name of the | |
34882 | GNUPLOT program (a string). If you have GNUPLOT installed on your | |
34883 | system but Calc is unable to find it, you may need to set this | |
58547c3e | 34884 | variable. (@pxref{Customizing Calc}) |
b154df16 JB |
34885 | You may also need to set some Lisp variables to show Calc how to run |
34886 | GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} . The default value | |
34887 | of @code{calc-gnuplot-name} is @code{"gnuplot"}. | |
651e237b | 34888 | @end defvar |
b154df16 | 34889 | |
651e237b JB |
34890 | @defvar calc-gnuplot-plot-command |
34891 | @defvarx calc-gnuplot-print-command | |
b154df16 JB |
34892 | See @ref{Devices, ,Graphical Devices}.@* |
34893 | The variables @code{calc-gnuplot-plot-command} and | |
34894 | @code{calc-gnuplot-print-command} represent system commands to | |
34895 | display and print the output of GNUPLOT, respectively. These may be | |
34896 | @code{nil} if no command is necessary, or strings which can include | |
34897 | @samp{%s} to signify the name of the file to be displayed or printed. | |
34898 | Or, these variables may contain Lisp expressions which are evaluated | |
34899 | to display or print the output. | |
d7b8e6c6 | 34900 | |
b154df16 JB |
34901 | The default value of @code{calc-gnuplot-plot-command} is @code{nil}, |
34902 | and the default value of @code{calc-gnuplot-print-command} is | |
34903 | @code{"lp %s"}. | |
651e237b | 34904 | @end defvar |
b154df16 | 34905 | |
651e237b | 34906 | @defvar calc-language-alist |
b154df16 JB |
34907 | See @ref{Basic Embedded Mode}.@* |
34908 | The variable @code{calc-language-alist} controls the languages that | |
34909 | Calc will associate with major modes. When Calc embedded mode is | |
34910 | enabled, it will try to use the current major mode to | |
34911 | determine what language should be used. (This can be overridden using | |
34912 | Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.) | |
34913 | The variable @code{calc-language-alist} consists of a list of pairs of | |
5208b407 | 34914 | the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example, |
b154df16 | 34915 | @code{(latex-mode . latex)} is one such pair. If Calc embedded is |
5208b407 JB |
34916 | activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself |
34917 | to use the language @var{LANGUAGE}. | |
b154df16 JB |
34918 | |
34919 | The default value of @code{calc-language-alist} is | |
d7b8e6c6 | 34920 | @example |
b154df16 JB |
34921 | ((latex-mode . latex) |
34922 | (tex-mode . tex) | |
34923 | (plain-tex-mode . tex) | |
34924 | (context-mode . tex) | |
34925 | (nroff-mode . eqn) | |
34926 | (pascal-mode . pascal) | |
34927 | (c-mode . c) | |
34928 | (c++-mode . c) | |
34929 | (fortran-mode . fortran) | |
34930 | (f90-mode . fortran)) | |
d7b8e6c6 | 34931 | @end example |
651e237b | 34932 | @end defvar |
d7b8e6c6 | 34933 | |
651e237b | 34934 | @defvar calc-embedded-announce-formula |
5127c216 | 34935 | @defvarx calc-embedded-announce-formula-alist |
b154df16 JB |
34936 | See @ref{Customizing Embedded Mode}.@* |
34937 | The variable @code{calc-embedded-announce-formula} helps determine | |
58547c3e | 34938 | what formulas @kbd{C-x * a} will activate in a buffer. It is a |
b154df16 | 34939 | regular expression, and when activating embedded formulas with |
58547c3e | 34940 | @kbd{C-x * a}, it will tell Calc that what follows is a formula to be |
b154df16 JB |
34941 | activated. (Calc also uses other patterns to find formulas, such as |
34942 | @samp{=>} and @samp{:=}.) | |
d7b8e6c6 | 34943 | |
b154df16 JB |
34944 | The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks |
34945 | for @samp{%Embed} followed by any number of lines beginning with | |
34946 | @samp{%} and a space. | |
5127c216 JB |
34947 | |
34948 | The variable @code{calc-embedded-announce-formula-alist} is used to | |
34949 | set @code{calc-embedded-announce-formula} to different regular | |
34950 | expressions depending on the major mode of the editing buffer. | |
34951 | It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} . | |
34952 | @var{REGEXP})}, and its default value is | |
34953 | @example | |
34954 | ((c++-mode . "//Embed\n\\(// .*\n\\)*") | |
34955 | (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*") | |
34956 | (f90-mode . "!Embed\n\\(! .*\n\\)*") | |
34957 | (fortran-mode . "C Embed\n\\(C .*\n\\)*") | |
34958 | (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") | |
34959 | (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") | |
34960 | (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*") | |
34961 | (pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*") | |
34962 | (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") | |
34963 | (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") | |
34964 | (texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*")) | |
34965 | @end example | |
34966 | Any major modes added to @code{calc-embedded-announce-formula-alist} | |
34967 | should also be added to @code{calc-embedded-open-close-plain-alist} | |
34968 | and @code{calc-embedded-open-close-mode-alist}. | |
651e237b | 34969 | @end defvar |
d7b8e6c6 | 34970 | |
651e237b JB |
34971 | @defvar calc-embedded-open-formula |
34972 | @defvarx calc-embedded-close-formula | |
5127c216 | 34973 | @defvarx calc-embedded-open-close-formula-alist |
b154df16 JB |
34974 | See @ref{Customizing Embedded Mode}.@* |
34975 | The variables @code{calc-embedded-open-formula} and | |
34976 | @code{calc-embedded-open-formula} control the region that Calc will | |
58547c3e | 34977 | activate as a formula when Embedded mode is entered with @kbd{C-x * e}. |
b154df16 JB |
34978 | They are regular expressions; |
34979 | Calc normally scans backward and forward in the buffer for the | |
34980 | nearest text matching these regular expressions to be the ``formula | |
34981 | delimiters''. | |
34982 | ||
34983 | The simplest delimiters are blank lines. Other delimiters that | |
34984 | Embedded mode understands by default are: | |
34985 | @enumerate | |
34986 | @item | |
34987 | The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$}, | |
34988 | @samp{\[ \]}, and @samp{\( \)}; | |
34989 | @item | |
34990 | Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters); | |
34991 | @item | |
34992 | Lines beginning with @samp{@@} (Texinfo delimiters). | |
34993 | @item | |
34994 | Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters); | |
34995 | @item | |
34996 | Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else. | |
34997 | @end enumerate | |
5127c216 JB |
34998 | |
34999 | The variable @code{calc-embedded-open-close-formula-alist} is used to | |
35000 | set @code{calc-embedded-open-formula} and | |
35001 | @code{calc-embedded-close-formula} to different regular | |
35002 | expressions depending on the major mode of the editing buffer. | |
35003 | It consists of a list of lists of the form | |
35004 | @code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP} | |
35005 | @var{CLOSE-FORMULA-REGEXP})}, and its default value is | |
35006 | @code{nil}. | |
651e237b | 35007 | @end defvar |
d7b8e6c6 | 35008 | |
651e237b JB |
35009 | @defvar calc-embedded-open-word |
35010 | @defvarx calc-embedded-close-word | |
5127c216 | 35011 | @defvarx calc-embedded-open-close-word-alist |
b154df16 JB |
35012 | See @ref{Customizing Embedded Mode}.@* |
35013 | The variables @code{calc-embedded-open-word} and | |
35014 | @code{calc-embedded-close-word} control the region that Calc will | |
58547c3e | 35015 | activate when Embedded mode is entered with @kbd{C-x * w}. They are |
b154df16 | 35016 | regular expressions. |
d7b8e6c6 | 35017 | |
b154df16 JB |
35018 | The default values of @code{calc-embedded-open-word} and |
35019 | @code{calc-embedded-close-word} are @code{"^\\|[^-+0-9.eE]"} and | |
35020 | @code{"$\\|[^-+0-9.eE]"} respectively. | |
5127c216 JB |
35021 | |
35022 | The variable @code{calc-embedded-open-close-word-alist} is used to | |
35023 | set @code{calc-embedded-open-word} and | |
35024 | @code{calc-embedded-close-word} to different regular | |
35025 | expressions depending on the major mode of the editing buffer. | |
35026 | It consists of a list of lists of the form | |
35027 | @code{(@var{MAJOR-MODE} @var{OPEN-WORD-REGEXP} | |
35028 | @var{CLOSE-WORD-REGEXP})}, and its default value is | |
35029 | @code{nil}. | |
651e237b | 35030 | @end defvar |
b154df16 | 35031 | |
651e237b JB |
35032 | @defvar calc-embedded-open-plain |
35033 | @defvarx calc-embedded-close-plain | |
5127c216 | 35034 | @defvarx calc-embedded-open-close-plain-alist |
b154df16 JB |
35035 | See @ref{Customizing Embedded Mode}.@* |
35036 | The variables @code{calc-embedded-open-plain} and | |
35037 | @code{calc-embedded-open-plain} are used to delimit ``plain'' | |
35038 | formulas. Note that these are actual strings, not regular | |
35039 | expressions, because Calc must be able to write these string into a | |
35040 | buffer as well as to recognize them. | |
35041 | ||
35042 | The default string for @code{calc-embedded-open-plain} is | |
35043 | @code{"%%% "}, note the trailing space. The default string for | |
35044 | @code{calc-embedded-close-plain} is @code{" %%%\n"}, without | |
35045 | the trailing newline here, the first line of a Big mode formula | |
35046 | that followed might be shifted over with respect to the other lines. | |
5127c216 JB |
35047 | |
35048 | The variable @code{calc-embedded-open-close-plain-alist} is used to | |
35049 | set @code{calc-embedded-open-plain} and | |
35050 | @code{calc-embedded-close-plain} to different strings | |
35051 | depending on the major mode of the editing buffer. | |
35052 | It consists of a list of lists of the form | |
35053 | @code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING} | |
35054 | @var{CLOSE-PLAIN-STRING})}, and its default value is | |
35055 | @example | |
35056 | ((c++-mode "// %% " " %%\n") | |
35057 | (c-mode "/* %% " " %% */\n") | |
35058 | (f90-mode "! %% " " %%\n") | |
35059 | (fortran-mode "C %% " " %%\n") | |
35060 | (html-helper-mode "<!-- %% " " %% -->\n") | |
35061 | (html-mode "<!-- %% " " %% -->\n") | |
35062 | (nroff-mode "\\\" %% " " %%\n") | |
35063 | (pascal-mode "@{%% " " %%@}\n") | |
35064 | (sgml-mode "<!-- %% " " %% -->\n") | |
35065 | (xml-mode "<!-- %% " " %% -->\n") | |
35066 | (texinfo-mode "@@c %% " " %%\n")) | |
35067 | @end example | |
35068 | Any major modes added to @code{calc-embedded-open-close-plain-alist} | |
35069 | should also be added to @code{calc-embedded-announce-formula-alist} | |
35070 | and @code{calc-embedded-open-close-mode-alist}. | |
651e237b | 35071 | @end defvar |
b154df16 | 35072 | |
651e237b JB |
35073 | @defvar calc-embedded-open-new-formula |
35074 | @defvarx calc-embedded-close-new-formula | |
5127c216 | 35075 | @defvarx calc-embedded-open-close-new-formula-alist |
b154df16 JB |
35076 | See @ref{Customizing Embedded Mode}.@* |
35077 | The variables @code{calc-embedded-open-new-formula} and | |
35078 | @code{calc-embedded-close-new-formula} are strings which are | |
58547c3e | 35079 | inserted before and after a new formula when you type @kbd{C-x * f}. |
b154df16 JB |
35080 | |
35081 | The default value of @code{calc-embedded-open-new-formula} is | |
35082 | @code{"\n\n"}. If this string begins with a newline character and the | |
58547c3e | 35083 | @kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip |
b154df16 JB |
35084 | this first newline to avoid introducing unnecessary blank lines in the |
35085 | file. The default value of @code{calc-embedded-close-new-formula} is | |
58547c3e JB |
35086 | also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}} |
35087 | if typed at the end of a line. (It follows that if @kbd{C-x * f} is | |
b154df16 JB |
35088 | typed on a blank line, both a leading opening newline and a trailing |
35089 | closing newline are omitted.) | |
5127c216 JB |
35090 | |
35091 | The variable @code{calc-embedded-open-close-new-formula-alist} is used to | |
35092 | set @code{calc-embedded-open-new-formula} and | |
35093 | @code{calc-embedded-close-new-formula} to different strings | |
35094 | depending on the major mode of the editing buffer. | |
35095 | It consists of a list of lists of the form | |
35096 | @code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING} | |
35097 | @var{CLOSE-NEW-FORMULA-STRING})}, and its default value is | |
35098 | @code{nil}. | |
651e237b | 35099 | @end defvar |
b154df16 | 35100 | |
651e237b JB |
35101 | @defvar calc-embedded-open-mode |
35102 | @defvarx calc-embedded-close-mode | |
5127c216 | 35103 | @defvarx calc-embedded-open-close-mode-alist |
b154df16 JB |
35104 | See @ref{Customizing Embedded Mode}.@* |
35105 | The variables @code{calc-embedded-open-mode} and | |
35106 | @code{calc-embedded-close-mode} are strings which Calc will place before | |
35107 | and after any mode annotations that it inserts. Calc never scans for | |
35108 | these strings; Calc always looks for the annotation itself, so it is not | |
35109 | necessary to add them to user-written annotations. | |
35110 | ||
35111 | The default value of @code{calc-embedded-open-mode} is @code{"% "} | |
35112 | and the default value of @code{calc-embedded-close-mode} is | |
35113 | @code{"\n"}. | |
35114 | If you change the value of @code{calc-embedded-close-mode}, it is a good | |
35115 | idea still to end with a newline so that mode annotations will appear on | |
35116 | lines by themselves. | |
5127c216 JB |
35117 | |
35118 | The variable @code{calc-embedded-open-close-mode-alist} is used to | |
35119 | set @code{calc-embedded-open-mode} and | |
35120 | @code{calc-embedded-close-mode} to different strings | |
35121 | expressions depending on the major mode of the editing buffer. | |
35122 | It consists of a list of lists of the form | |
35123 | @code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING} | |
35124 | @var{CLOSE-MODE-STRING})}, and its default value is | |
35125 | @example | |
35126 | ((c++-mode "// " "\n") | |
35127 | (c-mode "/* " " */\n") | |
35128 | (f90-mode "! " "\n") | |
35129 | (fortran-mode "C " "\n") | |
35130 | (html-helper-mode "<!-- " " -->\n") | |
35131 | (html-mode "<!-- " " -->\n") | |
35132 | (nroff-mode "\\\" " "\n") | |
35133 | (pascal-mode "@{ " " @}\n") | |
35134 | (sgml-mode "<!-- " " -->\n") | |
35135 | (xml-mode "<!-- " " -->\n") | |
35136 | (texinfo-mode "@@c " "\n")) | |
35137 | @end example | |
35138 | Any major modes added to @code{calc-embedded-open-close-mode-alist} | |
35139 | should also be added to @code{calc-embedded-announce-formula-alist} | |
35140 | and @code{calc-embedded-open-close-plain-alist}. | |
651e237b | 35141 | @end defvar |
b154df16 | 35142 | |
58547c3e | 35143 | @node Reporting Bugs, Summary, Customizing Calc, Top |
d7b8e6c6 EZ |
35144 | @appendix Reporting Bugs |
35145 | ||
35146 | @noindent | |
7b09dd5b | 35147 | If you find a bug in Calc, send e-mail to Jay Belanger, |
d7b8e6c6 EZ |
35148 | |
35149 | @example | |
d4c2c0ef | 35150 | belanger@@truman.edu |
d7b8e6c6 EZ |
35151 | @end example |
35152 | ||
35153 | @noindent | |
ed7899e8 | 35154 | There is an automatic command @kbd{M-x report-calc-bug} which helps |
d7b8e6c6 EZ |
35155 | you to report bugs. This command prompts you for a brief subject |
35156 | line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to | |
35157 | send your mail. Make sure your subject line indicates that you are | |
ed7899e8 CW |
35158 | reporting a Calc bug; this command sends mail to the maintainer's |
35159 | regular mailbox. | |
d7b8e6c6 | 35160 | |
029b2a44 JB |
35161 | If you have suggestions for additional features for Calc, please send |
35162 | them. Some have dared to suggest that Calc is already top-heavy with | |
35163 | features; this obviously cannot be the case, so if you have ideas, send | |
35164 | them right in. | |
d7b8e6c6 EZ |
35165 | |
35166 | At the front of the source file, @file{calc.el}, is a list of ideas for | |
029b2a44 JB |
35167 | future work. If any enthusiastic souls wish to take it upon themselves |
35168 | to work on these, please send a message (using @kbd{M-x report-calc-bug}) | |
35169 | so any efforts can be coordinated. | |
35170 | ||
35171 | The latest version of Calc is available from Savannah, in the Emacs | |
35172 | CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}. | |
d7b8e6c6 EZ |
35173 | |
35174 | @c [summary] | |
35175 | @node Summary, Key Index, Reporting Bugs, Top | |
35176 | @appendix Calc Summary | |
35177 | ||
35178 | @noindent | |
17c5c219 | 35179 | This section includes a complete list of Calc 2.1 keystroke commands. |
d7b8e6c6 EZ |
35180 | Each line lists the stack entries used by the command (top-of-stack |
35181 | last), the keystrokes themselves, the prompts asked by the command, | |
35182 | and the result of the command (also with top-of-stack last). | |
35183 | The result is expressed using the equivalent algebraic function. | |
35184 | Commands which put no results on the stack show the full @kbd{M-x} | |
35185 | command name in that position. Numbers preceding the result or | |
35186 | command name refer to notes at the end. | |
35187 | ||
35188 | Algebraic functions and @kbd{M-x} commands that don't have corresponding | |
35189 | keystrokes are not listed in this summary. | |
35190 | @xref{Command Index}. @xref{Function Index}. | |
35191 | ||
35192 | @iftex | |
35193 | @begingroup | |
35194 | @tex | |
35195 | \vskip-2\baselineskip \null | |
35196 | \gdef\sumrow#1{\sumrowx#1\relax}% | |
35197 | \gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{% | |
35198 | \leavevmode% | |
5d67986c RS |
35199 | {\smallfonts |
35200 | \hbox to5em{\sl\hss#1}% | |
35201 | \hbox to5em{\tt#2\hss}% | |
35202 | \hbox to4em{\sl#3\hss}% | |
35203 | \hbox to5em{\rm\hss#4}% | |
d7b8e6c6 | 35204 | \thinspace% |
5d67986c RS |
35205 | {\tt#5}% |
35206 | {\sl#6}% | |
35207 | }}% | |
35208 | \gdef\sumlpar{{\rm(}}% | |
35209 | \gdef\sumrpar{{\rm)}}% | |
35210 | \gdef\sumcomma{{\rm,\thinspace}}% | |
35211 | \gdef\sumexcl{{\rm!}}% | |
d7b8e6c6 EZ |
35212 | \gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}% |
35213 | \gdef\minus#1{{\tt-}}% | |
35214 | @end tex | |
35215 | @let@:=@sumsep | |
35216 | @let@r=@sumrow | |
35217 | @catcode`@(=@active @let(=@sumlpar | |
35218 | @catcode`@)=@active @let)=@sumrpar | |
35219 | @catcode`@,=@active @let,=@sumcomma | |
35220 | @catcode`@!=@active @let!=@sumexcl | |
35221 | @end iftex | |
35222 | @format | |
35223 | @iftex | |
35224 | @advance@baselineskip-2.5pt | |
d7b8e6c6 EZ |
35225 | @let@c@sumbreak |
35226 | @end iftex | |
58547c3e JB |
35227 | @r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:} |
35228 | @r{ @: C-x * b @: @: @:calc-big-or-small@:} | |
35229 | @r{ @: C-x * c @: @: @:calc@:} | |
35230 | @r{ @: C-x * d @: @: @:calc-embedded-duplicate@:} | |
35231 | @r{ @: C-x * e @: @: 34 @:calc-embedded@:} | |
35232 | @r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:} | |
35233 | @r{ @: C-x * g @: @: 35 @:calc-grab-region@:} | |
35234 | @r{ @: C-x * i @: @: @:calc-info@:} | |
35235 | @r{ @: C-x * j @: @: @:calc-embedded-select@:} | |
35236 | @r{ @: C-x * k @: @: @:calc-keypad@:} | |
35237 | @r{ @: C-x * l @: @: @:calc-load-everything@:} | |
35238 | @r{ @: C-x * m @: @: @:read-kbd-macro@:} | |
35239 | @r{ @: C-x * n @: @: 4 @:calc-embedded-next@:} | |
35240 | @r{ @: C-x * o @: @: @:calc-other-window@:} | |
35241 | @r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:} | |
35242 | @r{ @: C-x * q @:formula @: @:quick-calc@:} | |
35243 | @r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:} | |
35244 | @r{ @: C-x * s @: @: @:calc-info-summary@:} | |
35245 | @r{ @: C-x * t @: @: @:calc-tutorial@:} | |
35246 | @r{ @: C-x * u @: @: @:calc-embedded-update-formula@:} | |
35247 | @r{ @: C-x * w @: @: @:calc-embedded-word@:} | |
35248 | @r{ @: C-x * x @: @: @:calc-quit@:} | |
35249 | @r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:} | |
35250 | @r{ @: C-x * z @: @: @:calc-user-invocation@:} | |
35251 | @r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:} | |
35252 | @r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:} | |
35253 | @r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:} | |
35254 | @r{ @: C-x * 0 @:(zero) @: @:calc-reset@:} | |
177c0ea7 JB |
35255 | |
35256 | @c | |
d7b8e6c6 EZ |
35257 | @r{ @: 0-9 @:number @: @:@:number} |
35258 | @r{ @: . @:number @: @:@:0.number} | |
35259 | @r{ @: _ @:number @: @:-@:number} | |
35260 | @r{ @: e @:number @: @:@:1e number} | |
bd712b70 | 35261 | @r{ @: # @:number @: @:@:current-radix@tfn{#}number} |
d7b8e6c6 EZ |
35262 | @r{ @: P @:(in number) @: @:+/-@:} |
35263 | @r{ @: M @:(in number) @: @:mod@:} | |
35264 | @r{ @: @@ ' " @: (in number)@: @:@:HMS form} | |
35265 | @r{ @: h m s @: (in number)@: @:@:HMS form} | |
35266 | ||
177c0ea7 | 35267 | @c |
d7b8e6c6 EZ |
35268 | @r{ @: ' @:formula @: 37,46 @:@:formula} |
35269 | @r{ @: $ @:formula @: 37,46 @:$@:formula} | |
35270 | @r{ @: " @:string @: 37,46 @:@:string} | |
177c0ea7 JB |
35271 | |
35272 | @c | |
d7b8e6c6 EZ |
35273 | @r{ a b@: + @: @: 2 @:add@:(a,b) a+b} |
35274 | @r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b} | |
35275 | @r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b} | |
35276 | @r{ a b@: / @: @: 2 @:div@:(a,b) a/b} | |
35277 | @r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b} | |
35278 | @r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)} | |
35279 | @r{ a b@: % @: @: 2 @:mod@:(a,b) a%b} | |
35280 | @r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b} | |
35281 | @r{ a b@: : @: @: 2 @:fdiv@:(a,b)} | |
35282 | @r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b} | |
35283 | @r{ a b@: I | @: @: @:vconcat@:(b,a) b|a} | |
35284 | @r{ a b@: H | @: @: 2 @:append@:(a,b)} | |
35285 | @r{ a b@: I H | @: @: @:append@:(b,a)} | |
35286 | @r{ a@: & @: @: 1 @:inv@:(a) 1/a} | |
35287 | @r{ a@: ! @: @: 1 @:fact@:(a) a!} | |
35288 | @r{ a@: = @: @: 1 @:evalv@:(a)} | |
35289 | @r{ a@: M-% @: @: @:percent@:(a) a%} | |
177c0ea7 JB |
35290 | |
35291 | @c | |
5d67986c RS |
35292 | @r{ ... a@: @key{RET} @: @: 1 @:@:... a a} |
35293 | @r{ ... a@: @key{SPC} @: @: 1 @:@:... a a} | |
35294 | @r{... a b@: @key{TAB} @: @: 3 @:@:... b a} | |
35295 | @r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a} | |
35296 | @r{... a b@: @key{LFD} @: @: 1 @:@:... a b a} | |
35297 | @r{ ... a@: @key{DEL} @: @: 1 @:@:...} | |
35298 | @r{... a b@: M-@key{DEL} @: @: 1 @:@:... b} | |
35299 | @r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:} | |
d7b8e6c6 | 35300 | @r{ a@: ` @:editing @: 1,30 @:calc-edit@:} |
177c0ea7 JB |
35301 | |
35302 | @c | |
d7b8e6c6 EZ |
35303 | @r{ ... a@: C-d @: @: 1 @:@:...} |
35304 | @r{ @: C-k @: @: 27 @:calc-kill@:} | |
35305 | @r{ @: C-w @: @: 27 @:calc-kill-region@:} | |
35306 | @r{ @: C-y @: @: @:calc-yank@:} | |
35307 | @r{ @: C-_ @: @: 4 @:calc-undo@:} | |
35308 | @r{ @: M-k @: @: 27 @:calc-copy-as-kill@:} | |
35309 | @r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:} | |
177c0ea7 JB |
35310 | |
35311 | @c | |
d7b8e6c6 EZ |
35312 | @r{ @: [ @: @: @:@:[...} |
35313 | @r{[.. a b@: ] @: @: @:@:[a,b]} | |
35314 | @r{ @: ( @: @: @:@:(...} | |
35315 | @r{(.. a b@: ) @: @: @:@:(a,b)} | |
35316 | @r{ @: , @: @: @:@:vector or rect complex} | |
35317 | @r{ @: ; @: @: @:@:matrix or polar complex} | |
35318 | @r{ @: .. @: @: @:@:interval} | |
35319 | ||
177c0ea7 | 35320 | @c |
d7b8e6c6 EZ |
35321 | @r{ @: ~ @: @: @:calc-num-prefix@:} |
35322 | @r{ @: < @: @: 4 @:calc-scroll-left@:} | |
35323 | @r{ @: > @: @: 4 @:calc-scroll-right@:} | |
35324 | @r{ @: @{ @: @: 4 @:calc-scroll-down@:} | |
35325 | @r{ @: @} @: @: 4 @:calc-scroll-up@:} | |
35326 | @r{ @: ? @: @: @:calc-help@:} | |
177c0ea7 JB |
35327 | |
35328 | @c | |
d7b8e6c6 EZ |
35329 | @r{ a@: n @: @: 1 @:neg@:(a) @minus{}a} |
35330 | @r{ @: o @: @: 4 @:calc-realign@:} | |
35331 | @r{ @: p @:precision @: 31 @:calc-precision@:} | |
35332 | @r{ @: q @: @: @:calc-quit@:} | |
35333 | @r{ @: w @: @: @:calc-why@:} | |
35334 | @r{ @: x @:command @: @:M-x calc-@:command} | |
35335 | @r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:} | |
177c0ea7 JB |
35336 | |
35337 | @c | |
d7b8e6c6 EZ |
35338 | @r{ a@: A @: @: 1 @:abs@:(a)} |
35339 | @r{ a b@: B @: @: 2 @:log@:(a,b)} | |
35340 | @r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a} | |
35341 | @r{ a@: C @: @: 1 @:cos@:(a)} | |
35342 | @r{ a@: I C @: @: 1 @:arccos@:(a)} | |
35343 | @r{ a@: H C @: @: 1 @:cosh@:(a)} | |
35344 | @r{ a@: I H C @: @: 1 @:arccosh@:(a)} | |
35345 | @r{ @: D @: @: 4 @:calc-redo@:} | |
35346 | @r{ a@: E @: @: 1 @:exp@:(a)} | |
35347 | @r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a} | |
35348 | @r{ a@: F @: @: 1,11 @:floor@:(a,d)} | |
35349 | @r{ a@: I F @: @: 1,11 @:ceil@:(a,d)} | |
35350 | @r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)} | |
35351 | @r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)} | |
35352 | @r{ a@: G @: @: 1 @:arg@:(a)} | |
35353 | @r{ @: H @:command @: 32 @:@:Hyperbolic} | |
35354 | @r{ @: I @:command @: 32 @:@:Inverse} | |
35355 | @r{ a@: J @: @: 1 @:conj@:(a)} | |
35356 | @r{ @: K @:command @: 32 @:@:Keep-args} | |
35357 | @r{ a@: L @: @: 1 @:ln@:(a)} | |
35358 | @r{ a@: H L @: @: 1 @:log10@:(a)} | |
35359 | @r{ @: M @: @: @:calc-more-recursion-depth@:} | |
35360 | @r{ @: I M @: @: @:calc-less-recursion-depth@:} | |
35361 | @r{ a@: N @: @: 5 @:evalvn@:(a)} | |
35362 | @r{ @: P @: @: @:@:pi} | |
35363 | @r{ @: I P @: @: @:@:gamma} | |
35364 | @r{ @: H P @: @: @:@:e} | |
35365 | @r{ @: I H P @: @: @:@:phi} | |
35366 | @r{ a@: Q @: @: 1 @:sqrt@:(a)} | |
35367 | @r{ a@: I Q @: @: 1 @:sqr@:(a) a^2} | |
35368 | @r{ a@: R @: @: 1,11 @:round@:(a,d)} | |
35369 | @r{ a@: I R @: @: 1,11 @:trunc@:(a,d)} | |
35370 | @r{ a@: H R @: @: 1,11 @:fround@:(a,d)} | |
35371 | @r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)} | |
35372 | @r{ a@: S @: @: 1 @:sin@:(a)} | |
35373 | @r{ a@: I S @: @: 1 @:arcsin@:(a)} | |
35374 | @r{ a@: H S @: @: 1 @:sinh@:(a)} | |
35375 | @r{ a@: I H S @: @: 1 @:arcsinh@:(a)} | |
35376 | @r{ a@: T @: @: 1 @:tan@:(a)} | |
35377 | @r{ a@: I T @: @: 1 @:arctan@:(a)} | |
35378 | @r{ a@: H T @: @: 1 @:tanh@:(a)} | |
35379 | @r{ a@: I H T @: @: 1 @:arctanh@:(a)} | |
35380 | @r{ @: U @: @: 4 @:calc-undo@:} | |
35381 | @r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:} | |
177c0ea7 JB |
35382 | |
35383 | @c | |
d7b8e6c6 EZ |
35384 | @r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b} |
35385 | @r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b} | |
35386 | @r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b} | |
35387 | @r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b} | |
35388 | @r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b} | |
35389 | @r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b} | |
35390 | @r{ a b@: a @{ @: @: 2 @:in@:(a,b)} | |
35391 | @r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b} | |
35392 | @r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b} | |
35393 | @r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a} | |
35394 | @r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c} | |
35395 | @r{ a@: a . @: @: 1 @:rmeq@:(a)} | |
35396 | @r{ a@: a " @: @: 7,8 @:calc-expand-formula@:} | |
177c0ea7 JB |
35397 | |
35398 | @c | |
d7b8e6c6 EZ |
35399 | @r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)} |
35400 | @r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)} | |
35401 | @r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)} | |
35402 | @r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b} | |
177c0ea7 JB |
35403 | |
35404 | @c | |
d7b8e6c6 EZ |
35405 | @r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)} |
35406 | @r{ a b@: a % @: @: 2 @:prem@:(a,b)} | |
35407 | @r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]} | |
35408 | @r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b} | |
177c0ea7 JB |
35409 | |
35410 | @c | |
d7b8e6c6 EZ |
35411 | @r{ a@: a a @: @: 1 @:apart@:(a)} |
35412 | @r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)} | |
35413 | @r{ a@: a c @:v @: 38 @:collect@:(a,v)} | |
35414 | @r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)} | |
35415 | @r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)} | |
35416 | @r{ a@: a e @: @: @:esimplify@:(a)} | |
35417 | @r{ a@: a f @: @: 1 @:factor@:(a)} | |
35418 | @r{ a@: H a f @: @: 1 @:factors@:(a)} | |
35419 | @r{ a b@: a g @: @: 2 @:pgcd@:(a,b)} | |
35420 | @r{ a@: a i @:v @: 38 @:integ@:(a,v)} | |
35421 | @r{ a@: a m @:pats @: 38 @:match@:(a,pats)} | |
35422 | @r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)} | |
35423 | @r{ data x@: a p @: @: 28 @:polint@:(data,x)} | |
35424 | @r{ data x@: H a p @: @: 28 @:ratint@:(data,x)} | |
35425 | @r{ a@: a n @: @: 1 @:nrat@:(a)} | |
35426 | @r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)} | |
35427 | @r{ a@: a s @: @: @:simplify@:(a)} | |
35428 | @r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)} | |
35429 | @r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:} | |
35430 | @r{ a@: a x @: @: 4,8 @:expand@:(a)} | |
177c0ea7 JB |
35431 | |
35432 | @c | |
d7b8e6c6 EZ |
35433 | @r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)} |
35434 | @r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)} | |
35435 | @r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)} | |
35436 | @r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)} | |
35437 | @r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)} | |
35438 | @r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)} | |
35439 | @r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)} | |
35440 | @r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)} | |
35441 | @r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)} | |
35442 | @r{ a@: a P @:v @: 38 @:roots@:(a,v)} | |
35443 | @r{ a g@: a R @:v @: 38 @:root@:(a,v,g)} | |
35444 | @r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)} | |
35445 | @r{ a@: a S @:v @: 38 @:solve@:(a,v)} | |
35446 | @r{ a@: I a S @:v @: 38 @:finv@:(a,v)} | |
35447 | @r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)} | |
35448 | @r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)} | |
35449 | @r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)} | |
35450 | @r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)} | |
35451 | @r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)} | |
177c0ea7 JB |
35452 | |
35453 | @c | |
d7b8e6c6 EZ |
35454 | @r{ a b@: b a @: @: 9 @:and@:(a,b,w)} |
35455 | @r{ a@: b c @: @: 9 @:clip@:(a,w)} | |
35456 | @r{ a b@: b d @: @: 9 @:diff@:(a,b,w)} | |
35457 | @r{ a@: b l @: @: 10 @:lsh@:(a,n,w)} | |
35458 | @r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)} | |
35459 | @r{ a@: b n @: @: 9 @:not@:(a,w)} | |
35460 | @r{ a b@: b o @: @: 9 @:or@:(a,b,w)} | |
35461 | @r{ v@: b p @: @: 1 @:vpack@:(v)} | |
35462 | @r{ a@: b r @: @: 10 @:rsh@:(a,n,w)} | |
35463 | @r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)} | |
35464 | @r{ a@: b t @: @: 10 @:rot@:(a,n,w)} | |
35465 | @r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)} | |
35466 | @r{ a@: b u @: @: 1 @:vunpack@:(a)} | |
35467 | @r{ @: b w @:w @: 9,50 @:calc-word-size@:} | |
35468 | @r{ a b@: b x @: @: 9 @:xor@:(a,b,w)} | |
177c0ea7 JB |
35469 | |
35470 | @c | |
d7b8e6c6 EZ |
35471 | @r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)} |
35472 | @r{ r n p@: b F @: @: @:fv@:(r,n,p)} | |
35473 | @r{ r n p@: I b F @: @: @:fvb@:(r,n,p)} | |
35474 | @r{ r n p@: H b F @: @: @:fvl@:(r,n,p)} | |
35475 | @r{ v@: b I @: @: 19 @:irr@:(v)} | |
35476 | @r{ v@: I b I @: @: 19 @:irrb@:(v)} | |
35477 | @r{ a@: b L @: @: 10 @:ash@:(a,n,w)} | |
35478 | @r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)} | |
35479 | @r{ r n a@: b M @: @: @:pmt@:(r,n,a)} | |
35480 | @r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)} | |
35481 | @r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)} | |
35482 | @r{ r v@: b N @: @: 19 @:npv@:(r,v)} | |
35483 | @r{ r v@: I b N @: @: 19 @:npvb@:(r,v)} | |
35484 | @r{ r n p@: b P @: @: @:pv@:(r,n,p)} | |
35485 | @r{ r n p@: I b P @: @: @:pvb@:(r,n,p)} | |
35486 | @r{ r n p@: H b P @: @: @:pvl@:(r,n,p)} | |
35487 | @r{ a@: b R @: @: 10 @:rash@:(a,n,w)} | |
35488 | @r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)} | |
35489 | @r{ c s l@: b S @: @: @:sln@:(c,s,l)} | |
35490 | @r{ n p a@: b T @: @: @:rate@:(n,p,a)} | |
35491 | @r{ n p a@: I b T @: @: @:rateb@:(n,p,a)} | |
35492 | @r{ n p a@: H b T @: @: @:ratel@:(n,p,a)} | |
35493 | @r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)} | |
35494 | ||
35495 | @r{ r p a@: b # @: @: @:nper@:(r,p,a)} | |
35496 | @r{ r p a@: I b # @: @: @:nperb@:(r,p,a)} | |
35497 | @r{ r p a@: H b # @: @: @:nperl@:(r,p,a)} | |
35498 | @r{ a b@: b % @: @: @:relch@:(a,b)} | |
177c0ea7 JB |
35499 | |
35500 | @c | |
d7b8e6c6 EZ |
35501 | @r{ a@: c c @: @: 5 @:pclean@:(a,p)} |
35502 | @r{ a@: c 0-9 @: @: @:pclean@:(a,p)} | |
35503 | @r{ a@: H c c @: @: 5 @:clean@:(a,p)} | |
35504 | @r{ a@: H c 0-9 @: @: @:clean@:(a,p)} | |
35505 | @r{ a@: c d @: @: 1 @:deg@:(a)} | |
35506 | @r{ a@: c f @: @: 1 @:pfloat@:(a)} | |
35507 | @r{ a@: H c f @: @: 1 @:float@:(a)} | |
35508 | @r{ a@: c h @: @: 1 @:hms@:(a)} | |
35509 | @r{ a@: c p @: @: @:polar@:(a)} | |
35510 | @r{ a@: I c p @: @: @:rect@:(a)} | |
35511 | @r{ a@: c r @: @: 1 @:rad@:(a)} | |
177c0ea7 JB |
35512 | |
35513 | @c | |
d7b8e6c6 EZ |
35514 | @r{ a@: c F @: @: 5 @:pfrac@:(a,p)} |
35515 | @r{ a@: H c F @: @: 5 @:frac@:(a,p)} | |
177c0ea7 JB |
35516 | |
35517 | @c | |
d7b8e6c6 | 35518 | @r{ a@: c % @: @: @:percent@:(a*100)} |
177c0ea7 JB |
35519 | |
35520 | @c | |
d7b8e6c6 EZ |
35521 | @r{ @: d . @:char @: 50 @:calc-point-char@:} |
35522 | @r{ @: d , @:char @: 50 @:calc-group-char@:} | |
35523 | @r{ @: d < @: @: 13,50 @:calc-left-justify@:} | |
35524 | @r{ @: d = @: @: 13,50 @:calc-center-justify@:} | |
35525 | @r{ @: d > @: @: 13,50 @:calc-right-justify@:} | |
35526 | @r{ @: d @{ @:label @: 50 @:calc-left-label@:} | |
35527 | @r{ @: d @} @:label @: 50 @:calc-right-label@:} | |
35528 | @r{ @: d [ @: @: 4 @:calc-truncate-up@:} | |
35529 | @r{ @: d ] @: @: 4 @:calc-truncate-down@:} | |
35530 | @r{ @: d " @: @: 12,50 @:calc-display-strings@:} | |
5d67986c RS |
35531 | @r{ @: d @key{SPC} @: @: @:calc-refresh@:} |
35532 | @r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:} | |
177c0ea7 JB |
35533 | |
35534 | @c | |
d7b8e6c6 EZ |
35535 | @r{ @: d 0 @: @: 50 @:calc-decimal-radix@:} |
35536 | @r{ @: d 2 @: @: 50 @:calc-binary-radix@:} | |
35537 | @r{ @: d 6 @: @: 50 @:calc-hex-radix@:} | |
35538 | @r{ @: d 8 @: @: 50 @:calc-octal-radix@:} | |
177c0ea7 JB |
35539 | |
35540 | @c | |
d7b8e6c6 EZ |
35541 | @r{ @: d b @: @:12,13,50 @:calc-line-breaking@:} |
35542 | @r{ @: d c @: @: 50 @:calc-complex-notation@:} | |
35543 | @r{ @: d d @:format @: 50 @:calc-date-notation@:} | |
35544 | @r{ @: d e @: @: 5,50 @:calc-eng-notation@:} | |
35545 | @r{ @: d f @:num @: 31,50 @:calc-fix-notation@:} | |
35546 | @r{ @: d g @: @:12,13,50 @:calc-group-digits@:} | |
35547 | @r{ @: d h @:format @: 50 @:calc-hms-notation@:} | |
35548 | @r{ @: d i @: @: 50 @:calc-i-notation@:} | |
35549 | @r{ @: d j @: @: 50 @:calc-j-notation@:} | |
35550 | @r{ @: d l @: @: 12,50 @:calc-line-numbering@:} | |
35551 | @r{ @: d n @: @: 5,50 @:calc-normal-notation@:} | |
35552 | @r{ @: d o @:format @: 50 @:calc-over-notation@:} | |
35553 | @r{ @: d p @: @: 12,50 @:calc-show-plain@:} | |
35554 | @r{ @: d r @:radix @: 31,50 @:calc-radix@:} | |
35555 | @r{ @: d s @: @: 5,50 @:calc-sci-notation@:} | |
35556 | @r{ @: d t @: @: 27 @:calc-truncate-stack@:} | |
35557 | @r{ @: d w @: @: 12,13 @:calc-auto-why@:} | |
35558 | @r{ @: d z @: @: 12,50 @:calc-leading-zeros@:} | |
177c0ea7 JB |
35559 | |
35560 | @c | |
d7b8e6c6 EZ |
35561 | @r{ @: d B @: @: 50 @:calc-big-language@:} |
35562 | @r{ @: d C @: @: 50 @:calc-c-language@:} | |
35563 | @r{ @: d E @: @: 50 @:calc-eqn-language@:} | |
35564 | @r{ @: d F @: @: 50 @:calc-fortran-language@:} | |
35565 | @r{ @: d M @: @: 50 @:calc-mathematica-language@:} | |
35566 | @r{ @: d N @: @: 50 @:calc-normal-language@:} | |
35567 | @r{ @: d O @: @: 50 @:calc-flat-language@:} | |
35568 | @r{ @: d P @: @: 50 @:calc-pascal-language@:} | |
35569 | @r{ @: d T @: @: 50 @:calc-tex-language@:} | |
8ed713c6 | 35570 | @r{ @: d L @: @: 50 @:calc-latex-language@:} |
d7b8e6c6 EZ |
35571 | @r{ @: d U @: @: 50 @:calc-unformatted-language@:} |
35572 | @r{ @: d W @: @: 50 @:calc-maple-language@:} | |
177c0ea7 JB |
35573 | |
35574 | @c | |
d7b8e6c6 EZ |
35575 | @r{ a@: f [ @: @: 4 @:decr@:(a,n)} |
35576 | @r{ a@: f ] @: @: 4 @:incr@:(a,n)} | |
177c0ea7 JB |
35577 | |
35578 | @c | |
d7b8e6c6 EZ |
35579 | @r{ a b@: f b @: @: 2 @:beta@:(a,b)} |
35580 | @r{ a@: f e @: @: 1 @:erf@:(a)} | |
35581 | @r{ a@: I f e @: @: 1 @:erfc@:(a)} | |
35582 | @r{ a@: f g @: @: 1 @:gamma@:(a)} | |
35583 | @r{ a b@: f h @: @: 2 @:hypot@:(a,b)} | |
35584 | @r{ a@: f i @: @: 1 @:im@:(a)} | |
35585 | @r{ n a@: f j @: @: 2 @:besJ@:(n,a)} | |
35586 | @r{ a b@: f n @: @: 2 @:min@:(a,b)} | |
35587 | @r{ a@: f r @: @: 1 @:re@:(a)} | |
35588 | @r{ a@: f s @: @: 1 @:sign@:(a)} | |
35589 | @r{ a b@: f x @: @: 2 @:max@:(a,b)} | |
35590 | @r{ n a@: f y @: @: 2 @:besY@:(n,a)} | |
177c0ea7 JB |
35591 | |
35592 | @c | |
d7b8e6c6 EZ |
35593 | @r{ a@: f A @: @: 1 @:abssqr@:(a)} |
35594 | @r{ x a b@: f B @: @: @:betaI@:(x,a,b)} | |
35595 | @r{ x a b@: H f B @: @: @:betaB@:(x,a,b)} | |
35596 | @r{ a@: f E @: @: 1 @:expm1@:(a)} | |
35597 | @r{ a x@: f G @: @: 2 @:gammaP@:(a,x)} | |
35598 | @r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)} | |
35599 | @r{ a x@: H f G @: @: 2 @:gammag@:(a,x)} | |
35600 | @r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)} | |
35601 | @r{ a b@: f I @: @: 2 @:ilog@:(a,b)} | |
35602 | @r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a} | |
35603 | @r{ a@: f L @: @: 1 @:lnp1@:(a)} | |
35604 | @r{ a@: f M @: @: 1 @:mant@:(a)} | |
35605 | @r{ a@: f Q @: @: 1 @:isqrt@:(a)} | |
35606 | @r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2} | |
35607 | @r{ a n@: f S @: @: 2 @:scf@:(a,n)} | |
35608 | @r{ y x@: f T @: @: @:arctan2@:(y,x)} | |
35609 | @r{ a@: f X @: @: 1 @:xpon@:(a)} | |
177c0ea7 JB |
35610 | |
35611 | @c | |
d7b8e6c6 EZ |
35612 | @r{ x y@: g a @: @: 28,40 @:calc-graph-add@:} |
35613 | @r{ @: g b @: @: 12 @:calc-graph-border@:} | |
35614 | @r{ @: g c @: @: @:calc-graph-clear@:} | |
35615 | @r{ @: g d @: @: 41 @:calc-graph-delete@:} | |
35616 | @r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:} | |
35617 | @r{ @: g g @: @: 12 @:calc-graph-grid@:} | |
35618 | @r{ @: g h @:title @: @:calc-graph-header@:} | |
35619 | @r{ @: g j @: @: 4 @:calc-graph-juggle@:} | |
35620 | @r{ @: g k @: @: 12 @:calc-graph-key@:} | |
35621 | @r{ @: g l @: @: 12 @:calc-graph-log-x@:} | |
35622 | @r{ @: g n @:name @: @:calc-graph-name@:} | |
35623 | @r{ @: g p @: @: 42 @:calc-graph-plot@:} | |
35624 | @r{ @: g q @: @: @:calc-graph-quit@:} | |
35625 | @r{ @: g r @:range @: @:calc-graph-range-x@:} | |
35626 | @r{ @: g s @: @: 12,13 @:calc-graph-line-style@:} | |
35627 | @r{ @: g t @:title @: @:calc-graph-title-x@:} | |
35628 | @r{ @: g v @: @: @:calc-graph-view-commands@:} | |
35629 | @r{ @: g x @:display @: @:calc-graph-display@:} | |
35630 | @r{ @: g z @: @: 12 @:calc-graph-zero-x@:} | |
177c0ea7 JB |
35631 | |
35632 | @c | |
d7b8e6c6 EZ |
35633 | @r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:} |
35634 | @r{ @: g C @:command @: @:calc-graph-command@:} | |
35635 | @r{ @: g D @:device @: 43,44 @:calc-graph-device@:} | |
35636 | @r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:} | |
35637 | @r{ @: g H @: @: 12 @:calc-graph-hide@:} | |
35638 | @r{ @: g K @: @: @:calc-graph-kill@:} | |
35639 | @r{ @: g L @: @: 12 @:calc-graph-log-y@:} | |
35640 | @r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:} | |
35641 | @r{ @: g O @:filename @: 43,44 @:calc-graph-output@:} | |
35642 | @r{ @: g P @: @: 42 @:calc-graph-print@:} | |
35643 | @r{ @: g R @:range @: @:calc-graph-range-y@:} | |
35644 | @r{ @: g S @: @: 12,13 @:calc-graph-point-style@:} | |
35645 | @r{ @: g T @:title @: @:calc-graph-title-y@:} | |
35646 | @r{ @: g V @: @: @:calc-graph-view-trail@:} | |
35647 | @r{ @: g X @:format @: @:calc-graph-geometry@:} | |
35648 | @r{ @: g Z @: @: 12 @:calc-graph-zero-y@:} | |
177c0ea7 JB |
35649 | |
35650 | @c | |
d7b8e6c6 EZ |
35651 | @r{ @: g C-l @: @: 12 @:calc-graph-log-z@:} |
35652 | @r{ @: g C-r @:range @: @:calc-graph-range-z@:} | |
35653 | @r{ @: g C-t @:title @: @:calc-graph-title-z@:} | |
177c0ea7 JB |
35654 | |
35655 | @c | |
d7b8e6c6 EZ |
35656 | @r{ @: h b @: @: @:calc-describe-bindings@:} |
35657 | @r{ @: h c @:key @: @:calc-describe-key-briefly@:} | |
35658 | @r{ @: h f @:function @: @:calc-describe-function@:} | |
35659 | @r{ @: h h @: @: @:calc-full-help@:} | |
35660 | @r{ @: h i @: @: @:calc-info@:} | |
35661 | @r{ @: h k @:key @: @:calc-describe-key@:} | |
35662 | @r{ @: h n @: @: @:calc-view-news@:} | |
35663 | @r{ @: h s @: @: @:calc-info-summary@:} | |
35664 | @r{ @: h t @: @: @:calc-tutorial@:} | |
35665 | @r{ @: h v @:var @: @:calc-describe-variable@:} | |
177c0ea7 JB |
35666 | |
35667 | @c | |
d7b8e6c6 | 35668 | @r{ @: j 1-9 @: @: @:calc-select-part@:} |
5d67986c RS |
35669 | @r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:} |
35670 | @r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:} | |
d7b8e6c6 EZ |
35671 | @r{ @: j ' @:formula @: 27 @:calc-enter-selection@:} |
35672 | @r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:} | |
35673 | @r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:} | |
177c0ea7 JB |
35674 | |
35675 | @c | |
d7b8e6c6 EZ |
35676 | @r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:} |
35677 | @r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:} | |
35678 | @r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:} | |
35679 | @r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:} | |
35680 | @r{ @: j & @: @: 27 @:calc-sel-invert@:} | |
177c0ea7 JB |
35681 | |
35682 | @c | |
d7b8e6c6 EZ |
35683 | @r{ @: j a @: @: 27 @:calc-select-additional@:} |
35684 | @r{ @: j b @: @: 12 @:calc-break-selections@:} | |
35685 | @r{ @: j c @: @: @:calc-clear-selections@:} | |
35686 | @r{ @: j d @: @: 12,50 @:calc-show-selections@:} | |
35687 | @r{ @: j e @: @: 12 @:calc-enable-selections@:} | |
35688 | @r{ @: j l @: @: 4,27 @:calc-select-less@:} | |
35689 | @r{ @: j m @: @: 4,27 @:calc-select-more@:} | |
35690 | @r{ @: j n @: @: 4 @:calc-select-next@:} | |
35691 | @r{ @: j o @: @: 4,27 @:calc-select-once@:} | |
35692 | @r{ @: j p @: @: 4 @:calc-select-previous@:} | |
35693 | @r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:} | |
35694 | @r{ @: j s @: @: 4,27 @:calc-select-here@:} | |
35695 | @r{ @: j u @: @: 27 @:calc-unselect@:} | |
35696 | @r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:} | |
177c0ea7 JB |
35697 | |
35698 | @c | |
d7b8e6c6 EZ |
35699 | @r{ @: j C @: @: 27 @:calc-sel-commute@:} |
35700 | @r{ @: j D @: @: 4,27 @:calc-sel-distribute@:} | |
35701 | @r{ @: j E @: @: 27 @:calc-sel-jump-equals@:} | |
35702 | @r{ @: j I @: @: 27 @:calc-sel-isolate@:} | |
35703 | @r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)} | |
35704 | @r{ @: j L @: @: 4,27 @:calc-commute-left@:} | |
35705 | @r{ @: j M @: @: 27 @:calc-sel-merge@:} | |
35706 | @r{ @: j N @: @: 27 @:calc-sel-negate@:} | |
35707 | @r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:} | |
35708 | @r{ @: j R @: @: 4,27 @:calc-commute-right@:} | |
35709 | @r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:} | |
35710 | @r{ @: j U @: @: 27 @:calc-sel-unpack@:} | |
177c0ea7 JB |
35711 | |
35712 | @c | |
d7b8e6c6 EZ |
35713 | @r{ @: k a @: @: @:calc-random-again@:} |
35714 | @r{ n@: k b @: @: 1 @:bern@:(n)} | |
35715 | @r{ n x@: H k b @: @: 2 @:bern@:(n,x)} | |
35716 | @r{ n m@: k c @: @: 2 @:choose@:(n,m)} | |
35717 | @r{ n m@: H k c @: @: 2 @:perm@:(n,m)} | |
35718 | @r{ n@: k d @: @: 1 @:dfact@:(n) n!!} | |
35719 | @r{ n@: k e @: @: 1 @:euler@:(n)} | |
35720 | @r{ n x@: H k e @: @: 2 @:euler@:(n,x)} | |
35721 | @r{ n@: k f @: @: 4 @:prfac@:(n)} | |
35722 | @r{ n m@: k g @: @: 2 @:gcd@:(n,m)} | |
35723 | @r{ m n@: k h @: @: 14 @:shuffle@:(n,m)} | |
35724 | @r{ n m@: k l @: @: 2 @:lcm@:(n,m)} | |
35725 | @r{ n@: k m @: @: 1 @:moebius@:(n)} | |
35726 | @r{ n@: k n @: @: 4 @:nextprime@:(n)} | |
35727 | @r{ n@: I k n @: @: 4 @:prevprime@:(n)} | |
35728 | @r{ n@: k p @: @: 4,28 @:calc-prime-test@:} | |
35729 | @r{ m@: k r @: @: 14 @:random@:(m)} | |
35730 | @r{ n m@: k s @: @: 2 @:stir1@:(n,m)} | |
35731 | @r{ n m@: H k s @: @: 2 @:stir2@:(n,m)} | |
35732 | @r{ n@: k t @: @: 1 @:totient@:(n)} | |
177c0ea7 JB |
35733 | |
35734 | @c | |
d7b8e6c6 EZ |
35735 | @r{ n p x@: k B @: @: @:utpb@:(x,n,p)} |
35736 | @r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)} | |
35737 | @r{ v x@: k C @: @: @:utpc@:(x,v)} | |
35738 | @r{ v x@: I k C @: @: @:ltpc@:(x,v)} | |
35739 | @r{ n m@: k E @: @: @:egcd@:(n,m)} | |
35740 | @r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)} | |
35741 | @r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)} | |
35742 | @r{ m s x@: k N @: @: @:utpn@:(x,m,s)} | |
35743 | @r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)} | |
35744 | @r{ m x@: k P @: @: @:utpp@:(x,m)} | |
35745 | @r{ m x@: I k P @: @: @:ltpp@:(x,m)} | |
35746 | @r{ v x@: k T @: @: @:utpt@:(x,v)} | |
35747 | @r{ v x@: I k T @: @: @:ltpt@:(x,v)} | |
177c0ea7 JB |
35748 | |
35749 | @c | |
d7b8e6c6 EZ |
35750 | @r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:} |
35751 | @r{ @: m d @: @: @:calc-degrees-mode@:} | |
746539f6 | 35752 | @r{ @: m e @: @: @:calc-embedded-preserve-modes@:} |
d7b8e6c6 EZ |
35753 | @r{ @: m f @: @: 12 @:calc-frac-mode@:} |
35754 | @r{ @: m g @: @: 52 @:calc-get-modes@:} | |
35755 | @r{ @: m h @: @: @:calc-hms-mode@:} | |
35756 | @r{ @: m i @: @: 12,13 @:calc-infinite-mode@:} | |
35757 | @r{ @: m m @: @: @:calc-save-modes@:} | |
35758 | @r{ @: m p @: @: 12 @:calc-polar-mode@:} | |
35759 | @r{ @: m r @: @: @:calc-radians-mode@:} | |
35760 | @r{ @: m s @: @: 12 @:calc-symbolic-mode@:} | |
35761 | @r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:} | |
35762 | @r{ @: m v @: @: 12,13 @:calc-matrix-mode@:} | |
35763 | @r{ @: m w @: @: 13 @:calc-working@:} | |
35764 | @r{ @: m x @: @: @:calc-always-load-extensions@:} | |
177c0ea7 JB |
35765 | |
35766 | @c | |
d7b8e6c6 EZ |
35767 | @r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:} |
35768 | @r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:} | |
35769 | @r{ @: m C @: @: 12 @:calc-auto-recompute@:} | |
35770 | @r{ @: m D @: @: @:calc-default-simplify-mode@:} | |
35771 | @r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:} | |
35772 | @r{ @: m F @:filename @: 13 @:calc-settings-file-name@:} | |
35773 | @r{ @: m N @: @: 12 @:calc-num-simplify-mode@:} | |
35774 | @r{ @: m O @: @: 12 @:calc-no-simplify-mode@:} | |
35775 | @r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:} | |
35776 | @r{ @: m S @: @: 12 @:calc-shift-prefix@:} | |
35777 | @r{ @: m U @: @: 12 @:calc-units-simplify-mode@:} | |
177c0ea7 JB |
35778 | |
35779 | @c | |
d7b8e6c6 EZ |
35780 | @r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:} |
35781 | @r{ @: s d @:var, decl @: @:calc-declare-variable@:} | |
35782 | @r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:} | |
35783 | @r{ @: s i @:buffer @: @:calc-insert-variables@:} | |
6188800e | 35784 | @r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:} |
d7b8e6c6 EZ |
35785 | @r{ a b@: s l @:var @: 29 @:@:a (letting var=b)} |
35786 | @r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:} | |
35787 | @r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)} | |
35788 | @r{ @: s p @:var @: 29 @:calc-permanent-variable@:} | |
35789 | @r{ @: s r @:var @: 29 @:@:v (recalled value)} | |
35790 | @r{ @: r 0-9 @: @: @:calc-recall-quick@:} | |
35791 | @r{ a@: s s @:var @: 28,29 @:calc-store@:} | |
35792 | @r{ a@: s 0-9 @: @: @:calc-store-quick@:} | |
35793 | @r{ a@: s t @:var @: 29 @:calc-store-into@:} | |
35794 | @r{ a@: t 0-9 @: @: @:calc-store-into-quick@:} | |
35795 | @r{ @: s u @:var @: 29 @:calc-unstore@:} | |
35796 | @r{ a@: s x @:var @: 29 @:calc-store-exchange@:} | |
177c0ea7 JB |
35797 | |
35798 | @c | |
d7b8e6c6 EZ |
35799 | @r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:} |
35800 | @r{ @: s D @:editing @: 30 @:calc-edit-Decls@:} | |
35801 | @r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:} | |
35802 | @r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:} | |
35803 | @r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:} | |
35804 | @r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:} | |
35805 | @r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:} | |
35806 | @r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:} | |
35807 | @r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:} | |
35808 | @r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:} | |
35809 | @r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:} | |
35810 | @r{ @: s U @:editing @: 30 @:calc-edit-Units@:} | |
35811 | @r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:} | |
177c0ea7 JB |
35812 | |
35813 | @c | |
d7b8e6c6 EZ |
35814 | @r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)} |
35815 | @r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)} | |
35816 | @r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)} | |
35817 | @r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)} | |
35818 | @r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)} | |
35819 | @r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)} | |
35820 | @r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)} | |
35821 | @r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)} | |
35822 | @r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))} | |
bd712b70 JB |
35823 | @r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b} |
35824 | @r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}} | |
177c0ea7 JB |
35825 | |
35826 | @c | |
d7b8e6c6 EZ |
35827 | @r{ @: t [ @: @: 4 @:calc-trail-first@:} |
35828 | @r{ @: t ] @: @: 4 @:calc-trail-last@:} | |
35829 | @r{ @: t < @: @: 4 @:calc-trail-scroll-left@:} | |
35830 | @r{ @: t > @: @: 4 @:calc-trail-scroll-right@:} | |
35831 | @r{ @: t . @: @: 12 @:calc-full-trail-vectors@:} | |
177c0ea7 JB |
35832 | |
35833 | @c | |
d7b8e6c6 EZ |
35834 | @r{ @: t b @: @: 4 @:calc-trail-backward@:} |
35835 | @r{ @: t d @: @: 12,50 @:calc-trail-display@:} | |
35836 | @r{ @: t f @: @: 4 @:calc-trail-forward@:} | |
35837 | @r{ @: t h @: @: @:calc-trail-here@:} | |
35838 | @r{ @: t i @: @: @:calc-trail-in@:} | |
35839 | @r{ @: t k @: @: 4 @:calc-trail-kill@:} | |
35840 | @r{ @: t m @:string @: @:calc-trail-marker@:} | |
35841 | @r{ @: t n @: @: 4 @:calc-trail-next@:} | |
35842 | @r{ @: t o @: @: @:calc-trail-out@:} | |
35843 | @r{ @: t p @: @: 4 @:calc-trail-previous@:} | |
35844 | @r{ @: t r @:string @: @:calc-trail-isearch-backward@:} | |
35845 | @r{ @: t s @:string @: @:calc-trail-isearch-forward@:} | |
35846 | @r{ @: t y @: @: 4 @:calc-trail-yank@:} | |
177c0ea7 JB |
35847 | |
35848 | @c | |
d7b8e6c6 EZ |
35849 | @r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)} |
35850 | @r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)} | |
35851 | @r{ d@: t D @: @: 15 @:date@:(d)} | |
35852 | @r{ d@: t I @: @: 4 @:incmonth@:(d,n)} | |
35853 | @r{ d@: t J @: @: 16 @:julian@:(d,z)} | |
35854 | @r{ d@: t M @: @: 17 @:newmonth@:(d,n)} | |
35855 | @r{ @: t N @: @: 16 @:now@:(z)} | |
35856 | @r{ d@: t P @:1 @: 31 @:year@:(d)} | |
35857 | @r{ d@: t P @:2 @: 31 @:month@:(d)} | |
35858 | @r{ d@: t P @:3 @: 31 @:day@:(d)} | |
35859 | @r{ d@: t P @:4 @: 31 @:hour@:(d)} | |
35860 | @r{ d@: t P @:5 @: 31 @:minute@:(d)} | |
35861 | @r{ d@: t P @:6 @: 31 @:second@:(d)} | |
35862 | @r{ d@: t P @:7 @: 31 @:weekday@:(d)} | |
35863 | @r{ d@: t P @:8 @: 31 @:yearday@:(d)} | |
35864 | @r{ d@: t P @:9 @: 31 @:time@:(d)} | |
35865 | @r{ d@: t U @: @: 16 @:unixtime@:(d,z)} | |
35866 | @r{ d@: t W @: @: 17 @:newweek@:(d,w)} | |
35867 | @r{ d@: t Y @: @: 17 @:newyear@:(d,n)} | |
177c0ea7 JB |
35868 | |
35869 | @c | |
d7b8e6c6 EZ |
35870 | @r{ a b@: t + @: @: 2 @:badd@:(a,b)} |
35871 | @r{ a b@: t - @: @: 2 @:bsub@:(a,b)} | |
177c0ea7 JB |
35872 | |
35873 | @c | |
d7b8e6c6 EZ |
35874 | @r{ @: u a @: @: 12 @:calc-autorange-units@:} |
35875 | @r{ a@: u b @: @: @:calc-base-units@:} | |
35876 | @r{ a@: u c @:units @: 18 @:calc-convert-units@:} | |
35877 | @r{ defn@: u d @:unit, descr @: @:calc-define-unit@:} | |
35878 | @r{ @: u e @: @: @:calc-explain-units@:} | |
35879 | @r{ @: u g @:unit @: @:calc-get-unit-definition@:} | |
35880 | @r{ @: u p @: @: @:calc-permanent-units@:} | |
35881 | @r{ a@: u r @: @: @:calc-remove-units@:} | |
35882 | @r{ a@: u s @: @: @:usimplify@:(a)} | |
35883 | @r{ a@: u t @:units @: 18 @:calc-convert-temperature@:} | |
35884 | @r{ @: u u @:unit @: @:calc-undefine-unit@:} | |
35885 | @r{ @: u v @: @: @:calc-enter-units-table@:} | |
35886 | @r{ a@: u x @: @: @:calc-extract-units@:} | |
35887 | @r{ a@: u 0-9 @: @: @:calc-quick-units@:} | |
177c0ea7 JB |
35888 | |
35889 | @c | |
d7b8e6c6 EZ |
35890 | @r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)} |
35891 | @r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)} | |
35892 | @r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)} | |
35893 | @r{ v@: u G @: @: 19 @:vgmean@:(v)} | |
35894 | @r{ a b@: H u G @: @: 2 @:agmean@:(a,b)} | |
35895 | @r{ v@: u M @: @: 19 @:vmean@:(v)} | |
35896 | @r{ v@: I u M @: @: 19 @:vmeane@:(v)} | |
35897 | @r{ v@: H u M @: @: 19 @:vmedian@:(v)} | |
35898 | @r{ v@: I H u M @: @: 19 @:vhmean@:(v)} | |
35899 | @r{ v@: u N @: @: 19 @:vmin@:(v)} | |
35900 | @r{ v@: u S @: @: 19 @:vsdev@:(v)} | |
35901 | @r{ v@: I u S @: @: 19 @:vpsdev@:(v)} | |
35902 | @r{ v@: H u S @: @: 19 @:vvar@:(v)} | |
35903 | @r{ v@: I H u S @: @: 19 @:vpvar@:(v)} | |
35904 | @r{ @: u V @: @: @:calc-view-units-table@:} | |
35905 | @r{ v@: u X @: @: 19 @:vmax@:(v)} | |
177c0ea7 JB |
35906 | |
35907 | @c | |
d7b8e6c6 EZ |
35908 | @r{ v@: u + @: @: 19 @:vsum@:(v)} |
35909 | @r{ v@: u * @: @: 19 @:vprod@:(v)} | |
35910 | @r{ v@: u # @: @: 19 @:vcount@:(v)} | |
177c0ea7 JB |
35911 | |
35912 | @c | |
d7b8e6c6 EZ |
35913 | @r{ @: V ( @: @: 50 @:calc-vector-parens@:} |
35914 | @r{ @: V @{ @: @: 50 @:calc-vector-braces@:} | |
35915 | @r{ @: V [ @: @: 50 @:calc-vector-brackets@:} | |
35916 | @r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:} | |
35917 | @r{ @: V , @: @: 50 @:calc-vector-commas@:} | |
35918 | @r{ @: V < @: @: 50 @:calc-matrix-left-justify@:} | |
35919 | @r{ @: V = @: @: 50 @:calc-matrix-center-justify@:} | |
35920 | @r{ @: V > @: @: 50 @:calc-matrix-right-justify@:} | |
35921 | @r{ @: V / @: @: 12,50 @:calc-break-vectors@:} | |
35922 | @r{ @: V . @: @: 12,50 @:calc-full-vectors@:} | |
177c0ea7 JB |
35923 | |
35924 | @c | |
d7b8e6c6 EZ |
35925 | @r{ s t@: V ^ @: @: 2 @:vint@:(s,t)} |
35926 | @r{ s t@: V - @: @: 2 @:vdiff@:(s,t)} | |
35927 | @r{ s@: V ~ @: @: 1 @:vcompl@:(s)} | |
35928 | @r{ s@: V # @: @: 1 @:vcard@:(s)} | |
35929 | @r{ s@: V : @: @: 1 @:vspan@:(s)} | |
35930 | @r{ s@: V + @: @: 1 @:rdup@:(s)} | |
177c0ea7 JB |
35931 | |
35932 | @c | |
d7b8e6c6 | 35933 | @r{ m@: V & @: @: 1 @:inv@:(m) 1/m} |
177c0ea7 JB |
35934 | |
35935 | @c | |
d7b8e6c6 EZ |
35936 | @r{ v@: v a @:n @: @:arrange@:(v,n)} |
35937 | @r{ a@: v b @:n @: @:cvec@:(a,n)} | |
35938 | @r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)} | |
35939 | @r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)} | |
35940 | @r{ m@: v c @:0 @: 31 @:getdiag@:(m)} | |
35941 | @r{ v@: v d @: @: 25 @:diag@:(v,n)} | |
35942 | @r{ v m@: v e @: @: 2 @:vexp@:(v,m)} | |
35943 | @r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)} | |
35944 | @r{ v a@: v f @: @: 26 @:find@:(v,a,n)} | |
35945 | @r{ v@: v h @: @: 1 @:head@:(v)} | |
35946 | @r{ v@: I v h @: @: 1 @:tail@:(v)} | |
35947 | @r{ v@: H v h @: @: 1 @:rhead@:(v)} | |
35948 | @r{ v@: I H v h @: @: 1 @:rtail@:(v)} | |
35949 | @r{ @: v i @:n @: 31 @:idn@:(1,n)} | |
35950 | @r{ @: v i @:0 @: 31 @:idn@:(1)} | |
35951 | @r{ h t@: v k @: @: 2 @:cons@:(h,t)} | |
35952 | @r{ h t@: H v k @: @: 2 @:rcons@:(h,t)} | |
35953 | @r{ v@: v l @: @: 1 @:vlen@:(v)} | |
35954 | @r{ v@: H v l @: @: 1 @:mdims@:(v)} | |
35955 | @r{ v m@: v m @: @: 2 @:vmask@:(v,m)} | |
35956 | @r{ v@: v n @: @: 1 @:rnorm@:(v)} | |
35957 | @r{ a b c@: v p @: @: 24 @:calc-pack@:} | |
35958 | @r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)} | |
35959 | @r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)} | |
35960 | @r{ m@: v r @:0 @: 31 @:getdiag@:(m)} | |
35961 | @r{ v i j@: v s @: @: @:subvec@:(v,i,j)} | |
35962 | @r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)} | |
35963 | @r{ m@: v t @: @: 1 @:trn@:(m)} | |
35964 | @r{ v@: v u @: @: 24 @:calc-unpack@:} | |
35965 | @r{ v@: v v @: @: 1 @:rev@:(v)} | |
35966 | @r{ @: v x @:n @: 31 @:index@:(n)} | |
35967 | @r{ n s i@: C-u v x @: @: @:index@:(n,s,i)} | |
177c0ea7 JB |
35968 | |
35969 | @c | |
d7b8e6c6 EZ |
35970 | @r{ v@: V A @:op @: 22 @:apply@:(op,v)} |
35971 | @r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)} | |
35972 | @r{ m@: V D @: @: 1 @:det@:(m)} | |
35973 | @r{ s@: V E @: @: 1 @:venum@:(s)} | |
35974 | @r{ s@: V F @: @: 1 @:vfloor@:(s)} | |
35975 | @r{ v@: V G @: @: @:grade@:(v)} | |
35976 | @r{ v@: I V G @: @: @:rgrade@:(v)} | |
35977 | @r{ v@: V H @:n @: 31 @:histogram@:(v,n)} | |
35978 | @r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)} | |
35979 | @r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)} | |
35980 | @r{ m@: V J @: @: 1 @:ctrn@:(m)} | |
35981 | @r{ m@: V L @: @: 1 @:lud@:(m)} | |
35982 | @r{ v@: V M @:op @: 22,23 @:map@:(op,v)} | |
35983 | @r{ v@: V N @: @: 1 @:cnorm@:(v)} | |
35984 | @r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)} | |
35985 | @r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)} | |
35986 | @r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)} | |
35987 | @r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)} | |
35988 | @r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)} | |
35989 | @r{ v@: V S @: @: @:sort@:(v)} | |
35990 | @r{ v@: I V S @: @: @:rsort@:(v)} | |
35991 | @r{ m@: V T @: @: 1 @:tr@:(m)} | |
35992 | @r{ v@: V U @:op @: 22 @:accum@:(op,v)} | |
35993 | @r{ v@: I V U @:op @: 22 @:raccum@:(op,v)} | |
35994 | @r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)} | |
35995 | @r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)} | |
35996 | @r{ s t@: V V @: @: 2 @:vunion@:(s,t)} | |
35997 | @r{ s t@: V X @: @: 2 @:vxor@:(s,t)} | |
177c0ea7 JB |
35998 | |
35999 | @c | |
d7b8e6c6 | 36000 | @r{ @: Y @: @: @:@:user commands} |
177c0ea7 JB |
36001 | |
36002 | @c | |
d7b8e6c6 | 36003 | @r{ @: z @: @: @:@:user commands} |
177c0ea7 JB |
36004 | |
36005 | @c | |
d7b8e6c6 EZ |
36006 | @r{ c@: Z [ @: @: 45 @:calc-kbd-if@:} |
36007 | @r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:} | |
36008 | @r{ @: Z : @: @: @:calc-kbd-else@:} | |
36009 | @r{ @: Z ] @: @: @:calc-kbd-end-if@:} | |
177c0ea7 JB |
36010 | |
36011 | @c | |
d7b8e6c6 EZ |
36012 | @r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:} |
36013 | @r{ c@: Z / @: @: 45 @:calc-kbd-break@:} | |
36014 | @r{ @: Z @} @: @: @:calc-kbd-end-loop@:} | |
36015 | @r{ n@: Z < @: @: @:calc-kbd-repeat@:} | |
36016 | @r{ @: Z > @: @: @:calc-kbd-end-repeat@:} | |
36017 | @r{ n m@: Z ( @: @: @:calc-kbd-for@:} | |
36018 | @r{ s@: Z ) @: @: @:calc-kbd-end-for@:} | |
177c0ea7 JB |
36019 | |
36020 | @c | |
d7b8e6c6 | 36021 | @r{ @: Z C-g @: @: @:@:cancel if/loop command} |
177c0ea7 JB |
36022 | |
36023 | @c | |
d7b8e6c6 EZ |
36024 | @r{ @: Z ` @: @: @:calc-kbd-push@:} |
36025 | @r{ @: Z ' @: @: @:calc-kbd-pop@:} | |
faa3b6fc | 36026 | @r{ @: Z # @: @: @:calc-kbd-query@:} |
177c0ea7 JB |
36027 | |
36028 | @c | |
d7b8e6c6 EZ |
36029 | @r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:} |
36030 | @r{ @: Z D @:key, command @: @:calc-user-define@:} | |
36031 | @r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:} | |
36032 | @r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:} | |
36033 | @r{ @: Z G @:key @: @:calc-get-user-defn@:} | |
36034 | @r{ @: Z I @: @: @:calc-user-define-invocation@:} | |
36035 | @r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:} | |
36036 | @r{ @: Z P @:key @: @:calc-user-define-permanent@:} | |
36037 | @r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:} | |
36038 | @r{ @: Z T @: @: 12 @:calc-timing@:} | |
36039 | @r{ @: Z U @:key @: @:calc-user-undefine@:} | |
36040 | ||
36041 | @end format | |
36042 | ||
36043 | @noindent | |
36044 | NOTES | |
36045 | ||
36046 | @enumerate | |
36047 | @c 1 | |
36048 | @item | |
a4231b04 JB |
36049 | Positive prefix arguments apply to @expr{n} stack entries. |
36050 | Negative prefix arguments apply to the @expr{-n}th stack entry. | |
d7b8e6c6 | 36051 | A prefix of zero applies to the entire stack. (For @key{LFD} and |
5d67986c | 36052 | @kbd{M-@key{DEL}}, the meaning of the sign is reversed.) |
d7b8e6c6 EZ |
36053 | |
36054 | @c 2 | |
36055 | @item | |
a4231b04 | 36056 | Positive prefix arguments apply to @expr{n} stack entries. |
d7b8e6c6 | 36057 | Negative prefix arguments apply to the top stack entry |
a4231b04 | 36058 | and the next @expr{-n} stack entries. |
d7b8e6c6 EZ |
36059 | |
36060 | @c 3 | |
36061 | @item | |
a4231b04 JB |
36062 | Positive prefix arguments rotate top @expr{n} stack entries by one. |
36063 | Negative prefix arguments rotate the entire stack by @expr{-n}. | |
d7b8e6c6 EZ |
36064 | A prefix of zero reverses the entire stack. |
36065 | ||
36066 | @c 4 | |
36067 | @item | |
36068 | Prefix argument specifies a repeat count or distance. | |
36069 | ||
36070 | @c 5 | |
36071 | @item | |
a4231b04 JB |
36072 | Positive prefix arguments specify a precision @expr{p}. |
36073 | Negative prefix arguments reduce the current precision by @expr{-p}. | |
d7b8e6c6 EZ |
36074 | |
36075 | @c 6 | |
36076 | @item | |
36077 | A prefix argument is interpreted as an additional step-size parameter. | |
36078 | A plain @kbd{C-u} prefix means to prompt for the step size. | |
36079 | ||
36080 | @c 7 | |
36081 | @item | |
36082 | A prefix argument specifies simplification level and depth. | |
36083 | 1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}. | |
36084 | ||
36085 | @c 8 | |
36086 | @item | |
36087 | A negative prefix operates only on the top level of the input formula. | |
36088 | ||
36089 | @c 9 | |
36090 | @item | |
a4231b04 JB |
36091 | Positive prefix arguments specify a word size of @expr{w} bits, unsigned. |
36092 | Negative prefix arguments specify a word size of @expr{w} bits, signed. | |
d7b8e6c6 EZ |
36093 | |
36094 | @c 10 | |
36095 | @item | |
a4231b04 | 36096 | Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument |
d7b8e6c6 EZ |
36097 | cannot be specified in the keyboard version of this command. |
36098 | ||
36099 | @c 11 | |
36100 | @item | |
a4231b04 | 36101 | From the keyboard, @expr{d} is omitted and defaults to zero. |
d7b8e6c6 EZ |
36102 | |
36103 | @c 12 | |
36104 | @item | |
36105 | Mode is toggled; a positive prefix always sets the mode, and a negative | |
36106 | prefix always clears the mode. | |
36107 | ||
36108 | @c 13 | |
36109 | @item | |
36110 | Some prefix argument values provide special variations of the mode. | |
36111 | ||
36112 | @c 14 | |
36113 | @item | |
a4231b04 JB |
36114 | A prefix argument, if any, is used for @expr{m} instead of taking |
36115 | @expr{m} from the stack. @expr{M} may take any of these values: | |
d7b8e6c6 EZ |
36116 | @iftex |
36117 | {@advance@tableindent10pt | |
36118 | @end iftex | |
36119 | @table @asis | |
36120 | @item Integer | |
a4231b04 | 36121 | Random integer in the interval @expr{[0 .. m)}. |
d7b8e6c6 | 36122 | @item Float |
a4231b04 | 36123 | Random floating-point number in the interval @expr{[0 .. m)}. |
d7b8e6c6 EZ |
36124 | @item 0.0 |
36125 | Gaussian with mean 1 and standard deviation 0. | |
36126 | @item Error form | |
36127 | Gaussian with specified mean and standard deviation. | |
36128 | @item Interval | |
36129 | Random integer or floating-point number in that interval. | |
36130 | @item Vector | |
36131 | Random element from the vector. | |
36132 | @end table | |
36133 | @iftex | |
36134 | } | |
36135 | @end iftex | |
36136 | ||
36137 | @c 15 | |
36138 | @item | |
36139 | A prefix argument from 1 to 6 specifies number of date components | |
36140 | to remove from the stack. @xref{Date Conversions}. | |
36141 | ||
36142 | @c 16 | |
36143 | @item | |
36144 | A prefix argument specifies a time zone; @kbd{C-u} says to take the | |
36145 | time zone number or name from the top of the stack. @xref{Time Zones}. | |
36146 | ||
36147 | @c 17 | |
36148 | @item | |
36149 | A prefix argument specifies a day number (0-6, 0-31, or 0-366). | |
36150 | ||
36151 | @c 18 | |
36152 | @item | |
36153 | If the input has no units, you will be prompted for both the old and | |
36154 | the new units. | |
36155 | ||
36156 | @c 19 | |
36157 | @item | |
36158 | With a prefix argument, collect that many stack entries to form the | |
36159 | input data set. Each entry may be a single value or a vector of values. | |
36160 | ||
36161 | @c 20 | |
36162 | @item | |
a4231b04 | 36163 | With a prefix argument of 1, take a single |
8e04863e JB |
36164 | @texline @var{n}@math{\times2} |
36165 | @infoline @mathit{@var{N}x2} | |
a4231b04 | 36166 | matrix from the stack instead of two separate data vectors. |
d7b8e6c6 EZ |
36167 | |
36168 | @c 21 | |
36169 | @item | |
a4231b04 JB |
36170 | The row or column number @expr{n} may be given as a numeric prefix |
36171 | argument instead. A plain @kbd{C-u} prefix says to take @expr{n} | |
36172 | from the top of the stack. If @expr{n} is a vector or interval, | |
d7b8e6c6 EZ |
36173 | a subvector/submatrix of the input is created. |
36174 | ||
36175 | @c 22 | |
36176 | @item | |
a4231b04 | 36177 | The @expr{op} prompt can be answered with the key sequence for the |
d7b8e6c6 EZ |
36178 | desired function, or with @kbd{x} or @kbd{z} followed by a function name, |
36179 | or with @kbd{$} to take a formula from the top of the stack, or with | |
36180 | @kbd{'} and a typed formula. In the last two cases, the formula may | |
36181 | be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it | |
36182 | may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the | |
36183 | last argument of the created function), or otherwise you will be | |
36184 | prompted for an argument list. The number of vectors popped from the | |
36185 | stack by @kbd{V M} depends on the number of arguments of the function. | |
36186 | ||
36187 | @c 23 | |
36188 | @item | |
36189 | One of the mapping direction keys @kbd{_} (horizontal, i.e., map | |
36190 | by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or | |
36191 | reduce down), or @kbd{=} (map or reduce by rows) may be used before | |
a4231b04 | 36192 | entering @expr{op}; these modify the function name by adding the letter |
d7b8e6c6 EZ |
36193 | @code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,'' |
36194 | or @code{d} for ``down.'' | |
36195 | ||
36196 | @c 24 | |
36197 | @item | |
36198 | The prefix argument specifies a packing mode. A nonnegative mode | |
36199 | is the number of items (for @kbd{v p}) or the number of levels | |
36200 | (for @kbd{v u}). A negative mode is as described below. With no | |
36201 | prefix argument, the mode is taken from the top of the stack and | |
36202 | may be an integer or a vector of integers. | |
36203 | @iftex | |
36204 | {@advance@tableindent-20pt | |
36205 | @end iftex | |
36206 | @table @cite | |
36207 | @item -1 | |
b275eac7 | 36208 | (@var{2}) Rectangular complex number. |
d7b8e6c6 | 36209 | @item -2 |
b275eac7 | 36210 | (@var{2}) Polar complex number. |
d7b8e6c6 | 36211 | @item -3 |
b275eac7 | 36212 | (@var{3}) HMS form. |
d7b8e6c6 | 36213 | @item -4 |
b275eac7 | 36214 | (@var{2}) Error form. |
d7b8e6c6 | 36215 | @item -5 |
b275eac7 | 36216 | (@var{2}) Modulo form. |
d7b8e6c6 | 36217 | @item -6 |
b275eac7 | 36218 | (@var{2}) Closed interval. |
d7b8e6c6 | 36219 | @item -7 |
b275eac7 | 36220 | (@var{2}) Closed .. open interval. |
d7b8e6c6 | 36221 | @item -8 |
b275eac7 | 36222 | (@var{2}) Open .. closed interval. |
d7b8e6c6 | 36223 | @item -9 |
b275eac7 | 36224 | (@var{2}) Open interval. |
d7b8e6c6 | 36225 | @item -10 |
b275eac7 | 36226 | (@var{2}) Fraction. |
d7b8e6c6 | 36227 | @item -11 |
b275eac7 | 36228 | (@var{2}) Float with integer mantissa. |
d7b8e6c6 | 36229 | @item -12 |
a4231b04 | 36230 | (@var{2}) Float with mantissa in @expr{[1 .. 10)}. |
d7b8e6c6 | 36231 | @item -13 |
b275eac7 | 36232 | (@var{1}) Date form (using date numbers). |
d7b8e6c6 | 36233 | @item -14 |
b275eac7 | 36234 | (@var{3}) Date form (using year, month, day). |
d7b8e6c6 | 36235 | @item -15 |
b275eac7 | 36236 | (@var{6}) Date form (using year, month, day, hour, minute, second). |
d7b8e6c6 EZ |
36237 | @end table |
36238 | @iftex | |
36239 | } | |
36240 | @end iftex | |
36241 | ||
36242 | @c 25 | |
36243 | @item | |
a4231b04 JB |
36244 | A prefix argument specifies the size @expr{n} of the matrix. With no |
36245 | prefix argument, @expr{n} is omitted and the size is inferred from | |
d7b8e6c6 EZ |
36246 | the input vector. |
36247 | ||
36248 | @c 26 | |
36249 | @item | |
a4231b04 | 36250 | The prefix argument specifies the starting position @expr{n} (default 1). |
d7b8e6c6 EZ |
36251 | |
36252 | @c 27 | |
36253 | @item | |
36254 | Cursor position within stack buffer affects this command. | |
36255 | ||
36256 | @c 28 | |
36257 | @item | |
36258 | Arguments are not actually removed from the stack by this command. | |
36259 | ||
36260 | @c 29 | |
36261 | @item | |
36262 | Variable name may be a single digit or a full name. | |
36263 | ||
36264 | @c 30 | |
36265 | @item | |
33108698 JB |
36266 | Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or |
36267 | @key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the | |
36268 | buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation | |
d7b8e6c6 EZ |
36269 | of the result of the edit. |
36270 | ||
36271 | @c 31 | |
36272 | @item | |
36273 | The number prompted for can also be provided as a prefix argument. | |
36274 | ||
36275 | @c 32 | |
36276 | @item | |
36277 | Press this key a second time to cancel the prefix. | |
36278 | ||
36279 | @c 33 | |
36280 | @item | |
36281 | With a negative prefix, deactivate all formulas. With a positive | |
36282 | prefix, deactivate and then reactivate from scratch. | |
36283 | ||
36284 | @c 34 | |
36285 | @item | |
36286 | Default is to scan for nearest formula delimiter symbols. With a | |
36287 | prefix of zero, formula is delimited by mark and point. With a | |
36288 | non-zero prefix, formula is delimited by scanning forward or | |
36289 | backward by that many lines. | |
36290 | ||
36291 | @c 35 | |
36292 | @item | |
36293 | Parse the region between point and mark as a vector. A nonzero prefix | |
36294 | parses @var{n} lines before or after point as a vector. A zero prefix | |
36295 | parses the current line as a vector. A @kbd{C-u} prefix parses the | |
36296 | region between point and mark as a single formula. | |
36297 | ||
36298 | @c 36 | |
36299 | @item | |
36300 | Parse the rectangle defined by point and mark as a matrix. A positive | |
36301 | prefix @var{n} divides the rectangle into columns of width @var{n}. | |
36302 | A zero or @kbd{C-u} prefix parses each line as one formula. A negative | |
36303 | prefix suppresses special treatment of bracketed portions of a line. | |
36304 | ||
36305 | @c 37 | |
36306 | @item | |
36307 | A numeric prefix causes the current language mode to be ignored. | |
36308 | ||
36309 | @c 38 | |
36310 | @item | |
36311 | Responding to a prompt with a blank line answers that and all | |
36312 | later prompts by popping additional stack entries. | |
36313 | ||
36314 | @c 39 | |
36315 | @item | |
a4231b04 JB |
36316 | Answer for @expr{v} may also be of the form @expr{v = v_0} or |
36317 | @expr{v - v_0}. | |
d7b8e6c6 EZ |
36318 | |
36319 | @c 40 | |
36320 | @item | |
a4231b04 JB |
36321 | With a positive prefix argument, stack contains many @expr{y}'s and one |
36322 | common @expr{x}. With a zero prefix, stack contains a vector of | |
36323 | @expr{y}s and a common @expr{x}. With a negative prefix, stack | |
36324 | contains many @expr{[x,y]} vectors. (For 3D plots, substitute | |
36325 | @expr{z} for @expr{y} and @expr{x,y} for @expr{x}.) | |
d7b8e6c6 EZ |
36326 | |
36327 | @c 41 | |
36328 | @item | |
36329 | With any prefix argument, all curves in the graph are deleted. | |
36330 | ||
36331 | @c 42 | |
36332 | @item | |
36333 | With a positive prefix, refines an existing plot with more data points. | |
36334 | With a negative prefix, forces recomputation of the plot data. | |
36335 | ||
36336 | @c 43 | |
36337 | @item | |
36338 | With any prefix argument, set the default value instead of the | |
36339 | value for this graph. | |
36340 | ||
36341 | @c 44 | |
36342 | @item | |
36343 | With a negative prefix argument, set the value for the printer. | |
36344 | ||
36345 | @c 45 | |
36346 | @item | |
36347 | Condition is considered ``true'' if it is a nonzero real or complex | |
36348 | number, or a formula whose value is known to be nonzero; it is ``false'' | |
36349 | otherwise. | |
36350 | ||
36351 | @c 46 | |
36352 | @item | |
36353 | Several formulas separated by commas are pushed as multiple stack | |
36354 | entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"} | |
36355 | delimiters may be omitted. The notation @kbd{$$$} refers to the value | |
36356 | in stack level three, and causes the formula to replace the top three | |
36357 | stack levels. The notation @kbd{$3} refers to stack level three without | |
36358 | causing that value to be removed from the stack. Use @key{LFD} in place | |
36359 | of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET} | |
a4231b04 | 36360 | to evaluate variables. |
d7b8e6c6 EZ |
36361 | |
36362 | @c 47 | |
36363 | @item | |
36364 | The variable is replaced by the formula shown on the right. The | |
36365 | Inverse flag reverses the order of the operands, e.g., @kbd{I s - x} | |
a4231b04 | 36366 | assigns |
8e04863e | 36367 | @texline @math{x \coloneq a-x}. |
a4231b04 | 36368 | @infoline @expr{x := a-x}. |
d7b8e6c6 EZ |
36369 | |
36370 | @c 48 | |
36371 | @item | |
36372 | Press @kbd{?} repeatedly to see how to choose a model. Answer the | |
a4231b04 | 36373 | variables prompt with @expr{iv} or @expr{iv;pv} to specify |
d7b8e6c6 | 36374 | independent and parameter variables. A positive prefix argument |
8e04863e | 36375 | takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix |
d7b8e6c6 EZ |
36376 | and a vector from the stack. |
36377 | ||
36378 | @c 49 | |
36379 | @item | |
36380 | With a plain @kbd{C-u} prefix, replace the current region of the | |
36381 | destination buffer with the yanked text instead of inserting. | |
36382 | ||
36383 | @c 50 | |
36384 | @item | |
36385 | All stack entries are reformatted; the @kbd{H} prefix inhibits this. | |
36386 | The @kbd{I} prefix sets the mode temporarily, redraws the top stack | |
36387 | entry, then restores the original setting of the mode. | |
36388 | ||
36389 | @c 51 | |
36390 | @item | |
36391 | A negative prefix sets the default 3D resolution instead of the | |
36392 | default 2D resolution. | |
36393 | ||
36394 | @c 52 | |
36395 | @item | |
36396 | This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize}, | |
36397 | @var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar}, | |
36398 | @var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12 | |
36399 | grabs the @var{n}th mode value only. | |
36400 | @end enumerate | |
36401 | ||
36402 | @iftex | |
36403 | (Space is provided below for you to keep your own written notes.) | |
36404 | @page | |
36405 | @endgroup | |
36406 | @end iftex | |
36407 | ||
36408 | ||
36409 | @c [end-summary] | |
36410 | ||
36411 | @node Key Index, Command Index, Summary, Top | |
36412 | @unnumbered Index of Key Sequences | |
36413 | ||
36414 | @printindex ky | |
36415 | ||
36416 | @node Command Index, Function Index, Key Index, Top | |
36417 | @unnumbered Index of Calculator Commands | |
36418 | ||
36419 | Since all Calculator commands begin with the prefix @samp{calc-}, the | |
36420 | @kbd{x} key has been provided as a variant of @kbd{M-x} which automatically | |
36421 | types @samp{calc-} for you. Thus, @kbd{x last-args} is short for | |
36422 | @kbd{M-x calc-last-args}. | |
36423 | ||
36424 | @printindex pg | |
36425 | ||
36426 | @node Function Index, Concept Index, Command Index, Top | |
36427 | @unnumbered Index of Algebraic Functions | |
36428 | ||
36429 | This is a list of built-in functions and operators usable in algebraic | |
36430 | expressions. Their full Lisp names are derived by adding the prefix | |
36431 | @samp{calcFunc-}, as in @code{calcFunc-sqrt}. | |
36432 | @iftex | |
36433 | All functions except those noted with ``*'' have corresponding | |
36434 | Calc keystrokes and can also be found in the Calc Summary. | |
36435 | @end iftex | |
36436 | ||
36437 | @printindex tp | |
36438 | ||
36439 | @node Concept Index, Variable Index, Function Index, Top | |
36440 | @unnumbered Concept Index | |
36441 | ||
36442 | @printindex cp | |
36443 | ||
36444 | @node Variable Index, Lisp Function Index, Concept Index, Top | |
36445 | @unnumbered Index of Variables | |
36446 | ||
36447 | The variables in this list that do not contain dashes are accessible | |
36448 | as Calc variables. Add a @samp{var-} prefix to get the name of the | |
36449 | corresponding Lisp variable. | |
36450 | ||
36451 | The remaining variables are Lisp variables suitable for @code{setq}ing | |
3b846359 | 36452 | in your Calc init file or @file{.emacs} file. |
d7b8e6c6 EZ |
36453 | |
36454 | @printindex vr | |
36455 | ||
36456 | @node Lisp Function Index, , Variable Index, Top | |
36457 | @unnumbered Index of Lisp Math Functions | |
36458 | ||
36459 | The following functions are meant to be used with @code{defmath}, not | |
36460 | @code{defun} definitions. For names that do not start with @samp{calc-}, | |
36461 | the corresponding full Lisp name is derived by adding a prefix of | |
36462 | @samp{math-}. | |
36463 | ||
36464 | @printindex fn | |
36465 | ||
36466 | @summarycontents | |
36467 | ||
36468 | @c [end] | |
36469 | ||
36470 | @contents | |
36471 | @bye | |
36472 | ||
36473 | ||
ab5796a9 MB |
36474 | @ignore |
36475 | arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0 | |
36476 | @end ignore |