mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-24 10:38:38 +00:00
36476 lines
1.4 MiB
36476 lines
1.4 MiB
\input texinfo @c -*-texinfo-*-
|
|
@comment %**start of header (This is for running Texinfo on a region.)
|
|
@c smallbook
|
|
@setfilename ../info/calc
|
|
@c [title]
|
|
@settitle GNU Emacs Calc 2.1 Manual
|
|
@setchapternewpage odd
|
|
@comment %**end of header (This is for running Texinfo on a region.)
|
|
|
|
@c The following macros are used for conditional output for single lines.
|
|
@c @texline foo
|
|
@c `foo' will appear only in TeX output
|
|
@c @infoline foo
|
|
@c `foo' will appear only in non-TeX output
|
|
|
|
@c @expr{expr} will typeset an expression;
|
|
@c $x$ in TeX, @samp{x} otherwise.
|
|
|
|
@iftex
|
|
@macro texline
|
|
@end macro
|
|
@alias infoline=comment
|
|
@alias expr=math
|
|
@alias tfn=code
|
|
@alias mathit=expr
|
|
@macro cpi{}
|
|
@math{@pi{}}
|
|
@end macro
|
|
@macro cpiover{den}
|
|
@math{@pi/\den\}
|
|
@end macro
|
|
@end iftex
|
|
|
|
@ifnottex
|
|
@alias texline=comment
|
|
@macro infoline{stuff}
|
|
\stuff\
|
|
@end macro
|
|
@alias expr=samp
|
|
@alias tfn=t
|
|
@alias mathit=i
|
|
@macro cpi{}
|
|
@expr{pi}
|
|
@end macro
|
|
@macro cpiover{den}
|
|
@expr{pi/\den\}
|
|
@end macro
|
|
@end ifnottex
|
|
|
|
|
|
@tex
|
|
% Suggested by Karl Berry <karl@@freefriends.org>
|
|
\gdef\!{\mskip-\thinmuskip}
|
|
@end tex
|
|
|
|
@c Fix some other things specifically for this manual.
|
|
@iftex
|
|
@finalout
|
|
@mathcode`@:=`@: @c Make Calc fractions come out right in math mode
|
|
@tex
|
|
\gdef\coloneq{\mathrel{\mathord:\mathord=}}
|
|
|
|
\gdef\beforedisplay{\vskip-10pt}
|
|
\gdef\afterdisplay{\vskip-5pt}
|
|
\gdef\beforedisplayh{\vskip-25pt}
|
|
\gdef\afterdisplayh{\vskip-10pt}
|
|
@end tex
|
|
@newdimen@kyvpos @kyvpos=0pt
|
|
@newdimen@kyhpos @kyhpos=0pt
|
|
@newcount@calcclubpenalty @calcclubpenalty=1000
|
|
@ignore
|
|
@newcount@calcpageno
|
|
@newtoks@calcoldeverypar @calcoldeverypar=@everypar
|
|
@everypar={@calceverypar@the@calcoldeverypar}
|
|
@ifx@turnoffactive@undefinedzzz@def@turnoffactive{}@fi
|
|
@ifx@ninett@undefinedzzz@font@ninett=cmtt9@fi
|
|
@catcode`@\=0 \catcode`\@=11
|
|
\r@ggedbottomtrue
|
|
\catcode`\@=0 @catcode`@\=@active
|
|
@end ignore
|
|
@end iftex
|
|
|
|
@copying
|
|
This file documents Calc, the GNU Emacs calculator.
|
|
|
|
Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
|
|
2005, 2006 Free Software Foundation, Inc.
|
|
|
|
@quotation
|
|
Permission is granted to copy, distribute and/or modify this document
|
|
under the terms of the GNU Free Documentation License, Version 1.2 or
|
|
any later version published by the Free Software Foundation; with the
|
|
Invariant Sections being just ``GNU GENERAL PUBLIC LICENSE'', with the
|
|
Front-Cover texts being ``A GNU Manual,'' and with the Back-Cover
|
|
Texts as in (a) below.
|
|
|
|
(a) The FSF's Back-Cover Text is: ``You have freedom to copy and modify
|
|
this GNU Manual, like GNU software. Copies published by the Free
|
|
Software Foundation raise funds for GNU development.''
|
|
@end quotation
|
|
@end copying
|
|
|
|
@dircategory Emacs
|
|
@direntry
|
|
* Calc: (calc). Advanced desk calculator and mathematical tool.
|
|
@end direntry
|
|
|
|
@titlepage
|
|
@sp 6
|
|
@center @titlefont{Calc Manual}
|
|
@sp 4
|
|
@center GNU Emacs Calc Version 2.1
|
|
@c [volume]
|
|
@sp 1
|
|
@center March 2005
|
|
@sp 5
|
|
@center Dave Gillespie
|
|
@center daveg@@synaptics.com
|
|
@page
|
|
|
|
@vskip 0pt plus 1filll
|
|
Copyright @copyright{} 1990, 1991, 2001, 2002, 2003, 2004,
|
|
2005, 2006 Free Software Foundation, Inc.
|
|
@insertcopying
|
|
@end titlepage
|
|
|
|
@c [begin]
|
|
@ifinfo
|
|
@node Top, , (dir), (dir)
|
|
@chapter The GNU Emacs Calculator
|
|
|
|
@noindent
|
|
@dfn{Calc} is an advanced desk calculator and mathematical tool
|
|
that runs as part of the GNU Emacs environment.
|
|
|
|
This manual is divided into three major parts: ``Getting Started,''
|
|
the ``Calc Tutorial,'' and the ``Calc Reference.'' The Tutorial
|
|
introduces all the major aspects of Calculator use in an easy,
|
|
hands-on way. The remainder of the manual is a complete reference to
|
|
the features of the Calculator.
|
|
|
|
For help in the Emacs Info system (which you are using to read this
|
|
file), type @kbd{?}. (You can also type @kbd{h} to run through a
|
|
longer Info tutorial.)
|
|
|
|
@end ifinfo
|
|
@menu
|
|
* Copying:: How you can copy and share Calc.
|
|
|
|
* Getting Started:: General description and overview.
|
|
* Interactive Tutorial::
|
|
* Tutorial:: A step-by-step introduction for beginners.
|
|
|
|
* Introduction:: Introduction to the Calc reference manual.
|
|
* Data Types:: Types of objects manipulated by Calc.
|
|
* Stack and Trail:: Manipulating the stack and trail buffers.
|
|
* Mode Settings:: Adjusting display format and other modes.
|
|
* Arithmetic:: Basic arithmetic functions.
|
|
* Scientific Functions:: Transcendentals and other scientific functions.
|
|
* Matrix Functions:: Operations on vectors and matrices.
|
|
* Algebra:: Manipulating expressions algebraically.
|
|
* Units:: Operations on numbers with units.
|
|
* Store and Recall:: Storing and recalling variables.
|
|
* Graphics:: Commands for making graphs of data.
|
|
* Kill and Yank:: Moving data into and out of Calc.
|
|
* Keypad Mode:: Operating Calc from a keypad.
|
|
* Embedded Mode:: Working with formulas embedded in a file.
|
|
* Programming:: Calc as a programmable calculator.
|
|
|
|
* Customizing Calc:: Customizing Calc.
|
|
* Reporting Bugs:: How to report bugs and make suggestions.
|
|
|
|
* Summary:: Summary of Calc commands and functions.
|
|
|
|
* Key Index:: The standard Calc key sequences.
|
|
* Command Index:: The interactive Calc commands.
|
|
* Function Index:: Functions (in algebraic formulas).
|
|
* Concept Index:: General concepts.
|
|
* Variable Index:: Variables used by Calc (both user and internal).
|
|
* Lisp Function Index:: Internal Lisp math functions.
|
|
@end menu
|
|
|
|
@node Copying, Getting Started, Top, Top
|
|
@unnumbered GNU GENERAL PUBLIC LICENSE
|
|
@center Version 2, June 1991
|
|
|
|
@c This file is intended to be included in another file.
|
|
|
|
@display
|
|
Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
Everyone is permitted to copy and distribute verbatim copies
|
|
of this license document, but changing it is not allowed.
|
|
@end display
|
|
|
|
@unnumberedsec Preamble
|
|
|
|
The licenses for most software are designed to take away your
|
|
freedom to share and change it. By contrast, the GNU General Public
|
|
License is intended to guarantee your freedom to share and change free
|
|
software---to make sure the software is free for all its users. This
|
|
General Public License applies to most of the Free Software
|
|
Foundation's software and to any other program whose authors commit to
|
|
using it. (Some other Free Software Foundation software is covered by
|
|
the GNU Library General Public License instead.) You can apply it to
|
|
your programs, too.
|
|
|
|
When we speak of free software, we are referring to freedom, not
|
|
price. Our General Public Licenses are designed to make sure that you
|
|
have the freedom to distribute copies of free software (and charge for
|
|
this service if you wish), that you receive source code or can get it
|
|
if you want it, that you can change the software or use pieces of it
|
|
in new free programs; and that you know you can do these things.
|
|
|
|
To protect your rights, we need to make restrictions that forbid
|
|
anyone to deny you these rights or to ask you to surrender the rights.
|
|
These restrictions translate to certain responsibilities for you if you
|
|
distribute copies of the software, or if you modify it.
|
|
|
|
For example, if you distribute copies of such a program, whether
|
|
gratis or for a fee, you must give the recipients all the rights that
|
|
you have. You must make sure that they, too, receive or can get the
|
|
source code. And you must show them these terms so they know their
|
|
rights.
|
|
|
|
We protect your rights with two steps: (1) copyright the software, and
|
|
(2) offer you this license which gives you legal permission to copy,
|
|
distribute and/or modify the software.
|
|
|
|
Also, for each author's protection and ours, we want to make certain
|
|
that everyone understands that there is no warranty for this free
|
|
software. If the software is modified by someone else and passed on, we
|
|
want its recipients to know that what they have is not the original, so
|
|
that any problems introduced by others will not reflect on the original
|
|
authors' reputations.
|
|
|
|
Finally, any free program is threatened constantly by software
|
|
patents. We wish to avoid the danger that redistributors of a free
|
|
program will individually obtain patent licenses, in effect making the
|
|
program proprietary. To prevent this, we have made it clear that any
|
|
patent must be licensed for everyone's free use or not licensed at all.
|
|
|
|
The precise terms and conditions for copying, distribution and
|
|
modification follow.
|
|
|
|
@iftex
|
|
@unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
|
@end iftex
|
|
@ifinfo
|
|
@center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
|
@end ifinfo
|
|
|
|
@enumerate 0
|
|
@item
|
|
This License applies to any program or other work which contains
|
|
a notice placed by the copyright holder saying it may be distributed
|
|
under the terms of this General Public License. The ``Program'', below,
|
|
refers to any such program or work, and a ``work based on the Program''
|
|
means either the Program or any derivative work under copyright law:
|
|
that is to say, a work containing the Program or a portion of it,
|
|
either verbatim or with modifications and/or translated into another
|
|
language. (Hereinafter, translation is included without limitation in
|
|
the term ``modification''.) Each licensee is addressed as ``you''.
|
|
|
|
Activities other than copying, distribution and modification are not
|
|
covered by this License; they are outside its scope. The act of
|
|
running the Program is not restricted, and the output from the Program
|
|
is covered only if its contents constitute a work based on the
|
|
Program (independent of having been made by running the Program).
|
|
Whether that is true depends on what the Program does.
|
|
|
|
@item
|
|
You may copy and distribute verbatim copies of the Program's
|
|
source code as you receive it, in any medium, provided that you
|
|
conspicuously and appropriately publish on each copy an appropriate
|
|
copyright notice and disclaimer of warranty; keep intact all the
|
|
notices that refer to this License and to the absence of any warranty;
|
|
and give any other recipients of the Program a copy of this License
|
|
along with the Program.
|
|
|
|
You may charge a fee for the physical act of transferring a copy, and
|
|
you may at your option offer warranty protection in exchange for a fee.
|
|
|
|
@item
|
|
You may modify your copy or copies of the Program or any portion
|
|
of it, thus forming a work based on the Program, and copy and
|
|
distribute such modifications or work under the terms of Section 1
|
|
above, provided that you also meet all of these conditions:
|
|
|
|
@enumerate a
|
|
@item
|
|
You must cause the modified files to carry prominent notices
|
|
stating that you changed the files and the date of any change.
|
|
|
|
@item
|
|
You must cause any work that you distribute or publish, that in
|
|
whole or in part contains or is derived from the Program or any
|
|
part thereof, to be licensed as a whole at no charge to all third
|
|
parties under the terms of this License.
|
|
|
|
@item
|
|
If the modified program normally reads commands interactively
|
|
when run, you must cause it, when started running for such
|
|
interactive use in the most ordinary way, to print or display an
|
|
announcement including an appropriate copyright notice and a
|
|
notice that there is no warranty (or else, saying that you provide
|
|
a warranty) and that users may redistribute the program under
|
|
these conditions, and telling the user how to view a copy of this
|
|
License. (Exception: if the Program itself is interactive but
|
|
does not normally print such an announcement, your work based on
|
|
the Program is not required to print an announcement.)
|
|
@end enumerate
|
|
|
|
These requirements apply to the modified work as a whole. If
|
|
identifiable sections of that work are not derived from the Program,
|
|
and can be reasonably considered independent and separate works in
|
|
themselves, then this License, and its terms, do not apply to those
|
|
sections when you distribute them as separate works. But when you
|
|
distribute the same sections as part of a whole which is a work based
|
|
on the Program, the distribution of the whole must be on the terms of
|
|
this License, whose permissions for other licensees extend to the
|
|
entire whole, and thus to each and every part regardless of who wrote it.
|
|
|
|
Thus, it is not the intent of this section to claim rights or contest
|
|
your rights to work written entirely by you; rather, the intent is to
|
|
exercise the right to control the distribution of derivative or
|
|
collective works based on the Program.
|
|
|
|
In addition, mere aggregation of another work not based on the Program
|
|
with the Program (or with a work based on the Program) on a volume of
|
|
a storage or distribution medium does not bring the other work under
|
|
the scope of this License.
|
|
|
|
@item
|
|
You may copy and distribute the Program (or a work based on it,
|
|
under Section 2) in object code or executable form under the terms of
|
|
Sections 1 and 2 above provided that you also do one of the following:
|
|
|
|
@enumerate a
|
|
@item
|
|
Accompany it with the complete corresponding machine-readable
|
|
source code, which must be distributed under the terms of Sections
|
|
1 and 2 above on a medium customarily used for software interchange; or,
|
|
|
|
@item
|
|
Accompany it with a written offer, valid for at least three
|
|
years, to give any third party, for a charge no more than your
|
|
cost of physically performing source distribution, a complete
|
|
machine-readable copy of the corresponding source code, to be
|
|
distributed under the terms of Sections 1 and 2 above on a medium
|
|
customarily used for software interchange; or,
|
|
|
|
@item
|
|
Accompany it with the information you received as to the offer
|
|
to distribute corresponding source code. (This alternative is
|
|
allowed only for noncommercial distribution and only if you
|
|
received the program in object code or executable form with such
|
|
an offer, in accord with Subsection b above.)
|
|
@end enumerate
|
|
|
|
The source code for a work means the preferred form of the work for
|
|
making modifications to it. For an executable work, complete source
|
|
code means all the source code for all modules it contains, plus any
|
|
associated interface definition files, plus the scripts used to
|
|
control compilation and installation of the executable. However, as a
|
|
special exception, the source code distributed need not include
|
|
anything that is normally distributed (in either source or binary
|
|
form) with the major components (compiler, kernel, and so on) of the
|
|
operating system on which the executable runs, unless that component
|
|
itself accompanies the executable.
|
|
|
|
If distribution of executable or object code is made by offering
|
|
access to copy from a designated place, then offering equivalent
|
|
access to copy the source code from the same place counts as
|
|
distribution of the source code, even though third parties are not
|
|
compelled to copy the source along with the object code.
|
|
|
|
@item
|
|
You may not copy, modify, sublicense, or distribute the Program
|
|
except as expressly provided under this License. Any attempt
|
|
otherwise to copy, modify, sublicense or distribute the Program is
|
|
void, and will automatically terminate your rights under this License.
|
|
However, parties who have received copies, or rights, from you under
|
|
this License will not have their licenses terminated so long as such
|
|
parties remain in full compliance.
|
|
|
|
@item
|
|
You are not required to accept this License, since you have not
|
|
signed it. However, nothing else grants you permission to modify or
|
|
distribute the Program or its derivative works. These actions are
|
|
prohibited by law if you do not accept this License. Therefore, by
|
|
modifying or distributing the Program (or any work based on the
|
|
Program), you indicate your acceptance of this License to do so, and
|
|
all its terms and conditions for copying, distributing or modifying
|
|
the Program or works based on it.
|
|
|
|
@item
|
|
Each time you redistribute the Program (or any work based on the
|
|
Program), the recipient automatically receives a license from the
|
|
original licensor to copy, distribute or modify the Program subject to
|
|
these terms and conditions. You may not impose any further
|
|
restrictions on the recipients' exercise of the rights granted herein.
|
|
You are not responsible for enforcing compliance by third parties to
|
|
this License.
|
|
|
|
@item
|
|
If, as a consequence of a court judgment or allegation of patent
|
|
infringement or for any other reason (not limited to patent issues),
|
|
conditions are imposed on you (whether by court order, agreement or
|
|
otherwise) that contradict the conditions of this License, they do not
|
|
excuse you from the conditions of this License. If you cannot
|
|
distribute so as to satisfy simultaneously your obligations under this
|
|
License and any other pertinent obligations, then as a consequence you
|
|
may not distribute the Program at all. For example, if a patent
|
|
license would not permit royalty-free redistribution of the Program by
|
|
all those who receive copies directly or indirectly through you, then
|
|
the only way you could satisfy both it and this License would be to
|
|
refrain entirely from distribution of the Program.
|
|
|
|
If any portion of this section is held invalid or unenforceable under
|
|
any particular circumstance, the balance of the section is intended to
|
|
apply and the section as a whole is intended to apply in other
|
|
circumstances.
|
|
|
|
It is not the purpose of this section to induce you to infringe any
|
|
patents or other property right claims or to contest validity of any
|
|
such claims; this section has the sole purpose of protecting the
|
|
integrity of the free software distribution system, which is
|
|
implemented by public license practices. Many people have made
|
|
generous contributions to the wide range of software distributed
|
|
through that system in reliance on consistent application of that
|
|
system; it is up to the author/donor to decide if he or she is willing
|
|
to distribute software through any other system and a licensee cannot
|
|
impose that choice.
|
|
|
|
This section is intended to make thoroughly clear what is believed to
|
|
be a consequence of the rest of this License.
|
|
|
|
@item
|
|
If the distribution and/or use of the Program is restricted in
|
|
certain countries either by patents or by copyrighted interfaces, the
|
|
original copyright holder who places the Program under this License
|
|
may add an explicit geographical distribution limitation excluding
|
|
those countries, so that distribution is permitted only in or among
|
|
countries not thus excluded. In such case, this License incorporates
|
|
the limitation as if written in the body of this License.
|
|
|
|
@item
|
|
The Free Software Foundation may publish revised and/or new versions
|
|
of the General Public License from time to time. Such new versions will
|
|
be similar in spirit to the present version, but may differ in detail to
|
|
address new problems or concerns.
|
|
|
|
Each version is given a distinguishing version number. If the Program
|
|
specifies a version number of this License which applies to it and ``any
|
|
later version'', you have the option of following the terms and conditions
|
|
either of that version or of any later version published by the Free
|
|
Software Foundation. If the Program does not specify a version number of
|
|
this License, you may choose any version ever published by the Free Software
|
|
Foundation.
|
|
|
|
@item
|
|
If you wish to incorporate parts of the Program into other free
|
|
programs whose distribution conditions are different, write to the author
|
|
to ask for permission. For software which is copyrighted by the Free
|
|
Software Foundation, write to the Free Software Foundation; we sometimes
|
|
make exceptions for this. Our decision will be guided by the two goals
|
|
of preserving the free status of all derivatives of our free software and
|
|
of promoting the sharing and reuse of software generally.
|
|
|
|
@iftex
|
|
@heading NO WARRANTY
|
|
@end iftex
|
|
@ifinfo
|
|
@center NO WARRANTY
|
|
@end ifinfo
|
|
|
|
@item
|
|
BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
|
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
|
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
|
PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
|
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
|
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
|
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
|
REPAIR OR CORRECTION.
|
|
|
|
@item
|
|
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
|
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
|
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
|
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
|
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
|
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
|
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
|
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGES.
|
|
@end enumerate
|
|
|
|
@iftex
|
|
@heading END OF TERMS AND CONDITIONS
|
|
@end iftex
|
|
@ifinfo
|
|
@center END OF TERMS AND CONDITIONS
|
|
@end ifinfo
|
|
|
|
@page
|
|
@unnumberedsec Appendix: How to Apply These Terms to Your New Programs
|
|
|
|
If you develop a new program, and you want it to be of the greatest
|
|
possible use to the public, the best way to achieve this is to make it
|
|
free software which everyone can redistribute and change under these terms.
|
|
|
|
To do so, attach the following notices to the program. It is safest
|
|
to attach them to the start of each source file to most effectively
|
|
convey the exclusion of warranty; and each file should have at least
|
|
the ``copyright'' line and a pointer to where the full notice is found.
|
|
|
|
@smallexample
|
|
@var{one line to give the program's name and a brief idea of what it does.}
|
|
Copyright (C) @var{yyyy} @var{name of author}
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
@end smallexample
|
|
|
|
Also add information on how to contact you by electronic and paper mail.
|
|
|
|
If the program is interactive, make it output a short notice like this
|
|
when it starts in an interactive mode:
|
|
|
|
@smallexample
|
|
Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
|
|
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
|
This is free software, and you are welcome to redistribute it
|
|
under certain conditions; type `show c' for details.
|
|
@end smallexample
|
|
|
|
The hypothetical commands @samp{show w} and @samp{show c} should show
|
|
the appropriate parts of the General Public License. Of course, the
|
|
commands you use may be called something other than @samp{show w} and
|
|
@samp{show c}; they could even be mouse-clicks or menu items---whatever
|
|
suits your program.
|
|
|
|
You should also get your employer (if you work as a programmer) or your
|
|
school, if any, to sign a ``copyright disclaimer'' for the program, if
|
|
necessary. Here is a sample; alter the names:
|
|
|
|
@example
|
|
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
|
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
|
|
|
@var{signature of Ty Coon}, 1 April 1989
|
|
Ty Coon, President of Vice
|
|
@end example
|
|
|
|
This General Public License does not permit incorporating your program into
|
|
proprietary programs. If your program is a subroutine library, you may
|
|
consider it more useful to permit linking proprietary applications with the
|
|
library. If this is what you want to do, use the GNU Library General
|
|
Public License instead of this License.
|
|
|
|
@node Getting Started, Tutorial, Copying, Top
|
|
@chapter Getting Started
|
|
@noindent
|
|
This chapter provides a general overview of Calc, the GNU Emacs
|
|
Calculator: What it is, how to start it and how to exit from it,
|
|
and what are the various ways that it can be used.
|
|
|
|
@menu
|
|
* What is Calc::
|
|
* About This Manual::
|
|
* Notations Used in This Manual::
|
|
* Demonstration of Calc::
|
|
* Using Calc::
|
|
* History and Acknowledgements::
|
|
@end menu
|
|
|
|
@node What is Calc, About This Manual, Getting Started, Getting Started
|
|
@section What is Calc?
|
|
|
|
@noindent
|
|
@dfn{Calc} is an advanced calculator and mathematical tool that runs as
|
|
part of the GNU Emacs environment. Very roughly based on the HP-28/48
|
|
series of calculators, its many features include:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Choice of algebraic or RPN (stack-based) entry of calculations.
|
|
|
|
@item
|
|
Arbitrary precision integers and floating-point numbers.
|
|
|
|
@item
|
|
Arithmetic on rational numbers, complex numbers (rectangular and polar),
|
|
error forms with standard deviations, open and closed intervals, vectors
|
|
and matrices, dates and times, infinities, sets, quantities with units,
|
|
and algebraic formulas.
|
|
|
|
@item
|
|
Mathematical operations such as logarithms and trigonometric functions.
|
|
|
|
@item
|
|
Programmer's features (bitwise operations, non-decimal numbers).
|
|
|
|
@item
|
|
Financial functions such as future value and internal rate of return.
|
|
|
|
@item
|
|
Number theoretical features such as prime factorization and arithmetic
|
|
modulo @var{m} for any @var{m}.
|
|
|
|
@item
|
|
Algebraic manipulation features, including symbolic calculus.
|
|
|
|
@item
|
|
Moving data to and from regular editing buffers.
|
|
|
|
@item
|
|
Embedded mode for manipulating Calc formulas and data directly
|
|
inside any editing buffer.
|
|
|
|
@item
|
|
Graphics using GNUPLOT, a versatile (and free) plotting program.
|
|
|
|
@item
|
|
Easy programming using keyboard macros, algebraic formulas,
|
|
algebraic rewrite rules, or extended Emacs Lisp.
|
|
@end itemize
|
|
|
|
Calc tries to include a little something for everyone; as a result it is
|
|
large and might be intimidating to the first-time user. If you plan to
|
|
use Calc only as a traditional desk calculator, all you really need to
|
|
read is the ``Getting Started'' chapter of this manual and possibly the
|
|
first few sections of the tutorial. As you become more comfortable with
|
|
the program you can learn its additional features. Calc does not
|
|
have the scope and depth of a fully-functional symbolic math package,
|
|
but Calc has the advantages of convenience, portability, and freedom.
|
|
|
|
@node About This Manual, Notations Used in This Manual, What is Calc, Getting Started
|
|
@section About This Manual
|
|
|
|
@noindent
|
|
This document serves as a complete description of the GNU Emacs
|
|
Calculator. It works both as an introduction for novices, and as
|
|
a reference for experienced users. While it helps to have some
|
|
experience with GNU Emacs in order to get the most out of Calc,
|
|
this manual ought to be readable even if you don't know or use Emacs
|
|
regularly.
|
|
|
|
@ifinfo
|
|
The manual is divided into three major parts:@: the ``Getting
|
|
Started'' chapter you are reading now, the Calc tutorial (chapter 2),
|
|
and the Calc reference manual (the remaining chapters and appendices).
|
|
@end ifinfo
|
|
@iftex
|
|
The manual is divided into three major parts:@: the ``Getting
|
|
Started'' chapter you are reading now, the Calc tutorial (chapter 2),
|
|
and the Calc reference manual (the remaining chapters and appendices).
|
|
@c [when-split]
|
|
@c This manual has been printed in two volumes, the @dfn{Tutorial} and the
|
|
@c @dfn{Reference}. Both volumes include a copy of the ``Getting Started''
|
|
@c chapter.
|
|
@end iftex
|
|
|
|
If you are in a hurry to use Calc, there is a brief ``demonstration''
|
|
below which illustrates the major features of Calc in just a couple of
|
|
pages. If you don't have time to go through the full tutorial, this
|
|
will show you everything you need to know to begin.
|
|
@xref{Demonstration of Calc}.
|
|
|
|
The tutorial chapter walks you through the various parts of Calc
|
|
with lots of hands-on examples and explanations. If you are new
|
|
to Calc and you have some time, try going through at least the
|
|
beginning of the tutorial. The tutorial includes about 70 exercises
|
|
with answers. These exercises give you some guided practice with
|
|
Calc, as well as pointing out some interesting and unusual ways
|
|
to use its features.
|
|
|
|
The reference section discusses Calc in complete depth. You can read
|
|
the reference from start to finish if you want to learn every aspect
|
|
of Calc. Or, you can look in the table of contents or the Concept
|
|
Index to find the parts of the manual that discuss the things you
|
|
need to know.
|
|
|
|
@cindex Marginal notes
|
|
Every Calc keyboard command is listed in the Calc Summary, and also
|
|
in the Key Index. Algebraic functions, @kbd{M-x} commands, and
|
|
variables also have their own indices.
|
|
@texline Each
|
|
@infoline In the printed manual, each
|
|
paragraph that is referenced in the Key or Function Index is marked
|
|
in the margin with its index entry.
|
|
|
|
@c [fix-ref Help Commands]
|
|
You can access this manual on-line at any time within Calc by
|
|
pressing the @kbd{h i} key sequence. Outside of the Calc window,
|
|
you can press @kbd{C-x * i} to read the manual on-line. Also, you
|
|
can jump directly to the Tutorial by pressing @kbd{h t} or @kbd{C-x * t},
|
|
or to the Summary by pressing @kbd{h s} or @kbd{C-x * s}. Within Calc,
|
|
you can also go to the part of the manual describing any Calc key,
|
|
function, or variable using @w{@kbd{h k}}, @kbd{h f}, or @kbd{h v},
|
|
respectively. @xref{Help Commands}.
|
|
|
|
The Calc manual can be printed, but because the manual is so large, you
|
|
should only make a printed copy if you really need it. To print the
|
|
manual, you will need the @TeX{} typesetting program (this is a free
|
|
program by Donald Knuth at Stanford University) as well as the
|
|
@file{texindex} program and @file{texinfo.tex} file, both of which can
|
|
be obtained from the FSF as part of the @code{texinfo} package.
|
|
To print the Calc manual in one huge tome, you will need the
|
|
source code to this manual, @file{calc.texi}, available as part of the
|
|
Emacs source. Once you have this file, type @kbd{texi2dvi calc.texi}.
|
|
Alternatively, change to the @file{man} subdirectory of the Emacs
|
|
source distribution, and type @kbd{make calc.dvi}. (Don't worry if you
|
|
get some ``overfull box'' warnings while @TeX{} runs.)
|
|
The result will be a device-independent output file called
|
|
@file{calc.dvi}, which you must print in whatever way is right
|
|
for your system. On many systems, the command is
|
|
|
|
@example
|
|
lpr -d calc.dvi
|
|
@end example
|
|
|
|
@noindent
|
|
or
|
|
|
|
@example
|
|
dvips calc.dvi
|
|
@end example
|
|
|
|
@c Printed copies of this manual are also available from the Free Software
|
|
@c Foundation.
|
|
|
|
@node Notations Used in This Manual, Demonstration of Calc, About This Manual, Getting Started
|
|
@section Notations Used in This Manual
|
|
|
|
@noindent
|
|
This section describes the various notations that are used
|
|
throughout the Calc manual.
|
|
|
|
In keystroke sequences, uppercase letters mean you must hold down
|
|
the shift key while typing the letter. Keys pressed with Control
|
|
held down are shown as @kbd{C-x}. Keys pressed with Meta held down
|
|
are shown as @kbd{M-x}. Other notations are @key{RET} for the
|
|
Return key, @key{SPC} for the space bar, @key{TAB} for the Tab key,
|
|
@key{DEL} for the Delete key, and @key{LFD} for the Line-Feed key.
|
|
The @key{DEL} key is called Backspace on some keyboards, it is
|
|
whatever key you would use to correct a simple typing error when
|
|
regularly using Emacs.
|
|
|
|
(If you don't have the @key{LFD} or @key{TAB} keys on your keyboard,
|
|
the @kbd{C-j} and @kbd{C-i} keys are equivalent to them, respectively.
|
|
If you don't have a Meta key, look for Alt or Extend Char. You can
|
|
also press @key{ESC} or @kbd{C-[} first to get the same effect, so
|
|
that @kbd{M-x}, @kbd{@key{ESC} x}, and @kbd{C-[ x} are all equivalent.)
|
|
|
|
Sometimes the @key{RET} key is not shown when it is ``obvious''
|
|
that you must press @key{RET} to proceed. For example, the @key{RET}
|
|
is usually omitted in key sequences like @kbd{M-x calc-keypad @key{RET}}.
|
|
|
|
Commands are generally shown like this: @kbd{p} (@code{calc-precision})
|
|
or @kbd{C-x * k} (@code{calc-keypad}). This means that the command is
|
|
normally used by pressing the @kbd{p} key or @kbd{C-x * k} key sequence,
|
|
but it also has the full-name equivalent shown, e.g., @kbd{M-x calc-precision}.
|
|
|
|
Commands that correspond to functions in algebraic notation
|
|
are written: @kbd{C} (@code{calc-cos}) [@code{cos}]. This means
|
|
the @kbd{C} key is equivalent to @kbd{M-x calc-cos}, and that
|
|
the corresponding function in an algebraic-style formula would
|
|
be @samp{cos(@var{x})}.
|
|
|
|
A few commands don't have key equivalents: @code{calc-sincos}
|
|
[@code{sincos}].
|
|
|
|
@node Demonstration of Calc, Using Calc, Notations Used in This Manual, Getting Started
|
|
@section A Demonstration of Calc
|
|
|
|
@noindent
|
|
@cindex Demonstration of Calc
|
|
This section will show some typical small problems being solved with
|
|
Calc. The focus is more on demonstration than explanation, but
|
|
everything you see here will be covered more thoroughly in the
|
|
Tutorial.
|
|
|
|
To begin, start Emacs if necessary (usually the command @code{emacs}
|
|
does this), and type @kbd{C-x * c} to start the
|
|
Calculator. (You can also use @kbd{M-x calc} if this doesn't work.
|
|
@xref{Starting Calc}, for various ways of starting the Calculator.)
|
|
|
|
Be sure to type all the sample input exactly, especially noting the
|
|
difference between lower-case and upper-case letters. Remember,
|
|
@key{RET}, @key{TAB}, @key{DEL}, and @key{SPC} are the Return, Tab,
|
|
Delete, and Space keys.
|
|
|
|
@strong{RPN calculation.} In RPN, you type the input number(s) first,
|
|
then the command to operate on the numbers.
|
|
|
|
@noindent
|
|
Type @kbd{2 @key{RET} 3 + Q} to compute
|
|
@texline @math{\sqrt{2+3} = 2.2360679775}.
|
|
@infoline the square root of 2+3, which is 2.2360679775.
|
|
|
|
@noindent
|
|
Type @kbd{P 2 ^} to compute
|
|
@texline @math{\pi^2 = 9.86960440109}.
|
|
@infoline the value of `pi' squared, 9.86960440109.
|
|
|
|
@noindent
|
|
Type @key{TAB} to exchange the order of these two results.
|
|
|
|
@noindent
|
|
Type @kbd{- I H S} to subtract these results and compute the Inverse
|
|
Hyperbolic sine of the difference, 2.72996136574.
|
|
|
|
@noindent
|
|
Type @key{DEL} to erase this result.
|
|
|
|
@strong{Algebraic calculation.} You can also enter calculations using
|
|
conventional ``algebraic'' notation. To enter an algebraic formula,
|
|
use the apostrophe key.
|
|
|
|
@noindent
|
|
Type @kbd{' sqrt(2+3) @key{RET}} to compute
|
|
@texline @math{\sqrt{2+3}}.
|
|
@infoline the square root of 2+3.
|
|
|
|
@noindent
|
|
Type @kbd{' pi^2 @key{RET}} to enter
|
|
@texline @math{\pi^2}.
|
|
@infoline `pi' squared.
|
|
To evaluate this symbolic formula as a number, type @kbd{=}.
|
|
|
|
@noindent
|
|
Type @kbd{' arcsinh($ - $$) @key{RET}} to subtract the second-most-recent
|
|
result from the most-recent and compute the Inverse Hyperbolic sine.
|
|
|
|
@strong{Keypad mode.} If you are using the X window system, press
|
|
@w{@kbd{C-x * k}} to get Keypad mode. (If you don't use X, skip to
|
|
the next section.)
|
|
|
|
@noindent
|
|
Click on the @key{2}, @key{ENTER}, @key{3}, @key{+}, and @key{SQRT}
|
|
``buttons'' using your left mouse button.
|
|
|
|
@noindent
|
|
Click on @key{PI}, @key{2}, and @tfn{y^x}.
|
|
|
|
@noindent
|
|
Click on @key{INV}, then @key{ENTER} to swap the two results.
|
|
|
|
@noindent
|
|
Click on @key{-}, @key{INV}, @key{HYP}, and @key{SIN}.
|
|
|
|
@noindent
|
|
Click on @key{<-} to erase the result, then click @key{OFF} to turn
|
|
the Keypad Calculator off.
|
|
|
|
@strong{Grabbing data.} Type @kbd{C-x * x} if necessary to exit Calc.
|
|
Now select the following numbers as an Emacs region: ``Mark'' the
|
|
front of the list by typing @kbd{C-@key{SPC}} or @kbd{C-@@} there,
|
|
then move to the other end of the list. (Either get this list from
|
|
the on-line copy of this manual, accessed by @w{@kbd{C-x * i}}, or just
|
|
type these numbers into a scratch file.) Now type @kbd{C-x * g} to
|
|
``grab'' these numbers into Calc.
|
|
|
|
@example
|
|
@group
|
|
1.23 1.97
|
|
1.6 2
|
|
1.19 1.08
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
The result @samp{[1.23, 1.97, 1.6, 2, 1.19, 1.08]} is a Calc ``vector.''
|
|
Type @w{@kbd{V R +}} to compute the sum of these numbers.
|
|
|
|
@noindent
|
|
Type @kbd{U} to Undo this command, then type @kbd{V R *} to compute
|
|
the product of the numbers.
|
|
|
|
@noindent
|
|
You can also grab data as a rectangular matrix. Place the cursor on
|
|
the upper-leftmost @samp{1} and set the mark, then move to just after
|
|
the lower-right @samp{8} and press @kbd{C-x * r}.
|
|
|
|
@noindent
|
|
Type @kbd{v t} to transpose this
|
|
@texline @math{3\times2}
|
|
@infoline 3x2
|
|
matrix into a
|
|
@texline @math{2\times3}
|
|
@infoline 2x3
|
|
matrix. Type @w{@kbd{v u}} to unpack the rows into two separate
|
|
vectors. Now type @w{@kbd{V R + @key{TAB} V R +}} to compute the sums
|
|
of the two original columns. (There is also a special
|
|
grab-and-sum-columns command, @kbd{C-x * :}.)
|
|
|
|
@strong{Units conversion.} Units are entered algebraically.
|
|
Type @w{@kbd{' 43 mi/hr @key{RET}}} to enter the quantity 43 miles-per-hour.
|
|
Type @w{@kbd{u c km/hr @key{RET}}}. Type @w{@kbd{u c m/s @key{RET}}}.
|
|
|
|
@strong{Date arithmetic.} Type @kbd{t N} to get the current date and
|
|
time. Type @kbd{90 +} to find the date 90 days from now. Type
|
|
@kbd{' <25 dec 87> @key{RET}} to enter a date, then @kbd{- 7 /} to see how
|
|
many weeks have passed since then.
|
|
|
|
@strong{Algebra.} Algebraic entries can also include formulas
|
|
or equations involving variables. Type @kbd{@w{' [x + y} = a, x y = 1] @key{RET}}
|
|
to enter a pair of equations involving three variables.
|
|
(Note the leading apostrophe in this example; also, note that the space
|
|
between @samp{x y} is required.) Type @w{@kbd{a S x,y @key{RET}}} to solve
|
|
these equations for the variables @expr{x} and @expr{y}.
|
|
|
|
@noindent
|
|
Type @kbd{d B} to view the solutions in more readable notation.
|
|
Type @w{@kbd{d C}} to view them in C language notation, @kbd{d T}
|
|
to view them in the notation for the @TeX{} typesetting system,
|
|
and @kbd{d L} to view them in the notation for the La@TeX{} typesetting
|
|
system. Type @kbd{d N} to return to normal notation.
|
|
|
|
@noindent
|
|
Type @kbd{7.5}, then @kbd{s l a @key{RET}} to let @expr{a = 7.5} in these formulas.
|
|
(That's a letter @kbd{l}, not a numeral @kbd{1}.)
|
|
|
|
@iftex
|
|
@strong{Help functions.} You can read about any command in the on-line
|
|
manual. Type @kbd{C-x * c} to return to Calc after each of these
|
|
commands: @kbd{h k t N} to read about the @kbd{t N} command,
|
|
@kbd{h f sqrt @key{RET}} to read about the @code{sqrt} function, and
|
|
@kbd{h s} to read the Calc summary.
|
|
@end iftex
|
|
@ifinfo
|
|
@strong{Help functions.} You can read about any command in the on-line
|
|
manual. Remember to type the letter @kbd{l}, then @kbd{C-x * c}, to
|
|
return here after each of these commands: @w{@kbd{h k t N}} to read
|
|
about the @w{@kbd{t N}} command, @kbd{h f sqrt @key{RET}} to read about the
|
|
@code{sqrt} function, and @kbd{h s} to read the Calc summary.
|
|
@end ifinfo
|
|
|
|
Press @key{DEL} repeatedly to remove any leftover results from the stack.
|
|
To exit from Calc, press @kbd{q} or @kbd{C-x * c} again.
|
|
|
|
@node Using Calc, History and Acknowledgements, Demonstration of Calc, Getting Started
|
|
@section Using Calc
|
|
|
|
@noindent
|
|
Calc has several user interfaces that are specialized for
|
|
different kinds of tasks. As well as Calc's standard interface,
|
|
there are Quick mode, Keypad mode, and Embedded mode.
|
|
|
|
@menu
|
|
* Starting Calc::
|
|
* The Standard Interface::
|
|
* Quick Mode Overview::
|
|
* Keypad Mode Overview::
|
|
* Standalone Operation::
|
|
* Embedded Mode Overview::
|
|
* Other C-x * Commands::
|
|
@end menu
|
|
|
|
@node Starting Calc, The Standard Interface, Using Calc, Using Calc
|
|
@subsection Starting Calc
|
|
|
|
@noindent
|
|
On most systems, you can type @kbd{C-x *} to start the Calculator.
|
|
The key sequence @kbd{C-x *} is bound to the command @code{calc-dispatch},
|
|
which can be rebound if convenient (@pxref{Customizing Calc}).
|
|
|
|
When you press @kbd{C-x *}, Emacs waits for you to press a second key to
|
|
complete the command. In this case, you will follow @kbd{C-x *} with a
|
|
letter (upper- or lower-case, it doesn't matter for @kbd{C-x *}) that says
|
|
which Calc interface you want to use.
|
|
|
|
To get Calc's standard interface, type @kbd{C-x * c}. To get
|
|
Keypad mode, type @kbd{C-x * k}. Type @kbd{C-x * ?} to get a brief
|
|
list of the available options, and type a second @kbd{?} to get
|
|
a complete list.
|
|
|
|
To ease typing, @kbd{C-x * *} also works to start Calc. It starts the
|
|
same interface (either @kbd{C-x * c} or @w{@kbd{C-x * k}}) that you last
|
|
used, selecting the @kbd{C-x * c} interface by default.
|
|
|
|
If @kbd{C-x *} doesn't work for you, you can always type explicit
|
|
commands like @kbd{M-x calc} (for the standard user interface) or
|
|
@w{@kbd{M-x calc-keypad}} (for Keypad mode). First type @kbd{M-x}
|
|
(that's Meta with the letter @kbd{x}), then, at the prompt,
|
|
type the full command (like @kbd{calc-keypad}) and press Return.
|
|
|
|
The same commands (like @kbd{C-x * c} or @kbd{C-x * *}) that start
|
|
the Calculator also turn it off if it is already on.
|
|
|
|
@node The Standard Interface, Quick Mode Overview, Starting Calc, Using Calc
|
|
@subsection The Standard Calc Interface
|
|
|
|
@noindent
|
|
@cindex Standard user interface
|
|
Calc's standard interface acts like a traditional RPN calculator,
|
|
operated by the normal Emacs keyboard. When you type @kbd{C-x * c}
|
|
to start the Calculator, the Emacs screen splits into two windows
|
|
with the file you were editing on top and Calc on the bottom.
|
|
|
|
@smallexample
|
|
@group
|
|
|
|
...
|
|
--**-Emacs: myfile (Fundamental)----All----------------------
|
|
--- Emacs Calculator Mode --- |Emacs Calc Mode v2.1 ...
|
|
2: 17.3 | 17.3
|
|
1: -5 | 3
|
|
. | 2
|
|
| 4
|
|
| * 8
|
|
| ->-5
|
|
|
|
|
--%%-Calc: 12 Deg (Calculator)----All----- --%%-Emacs: *Calc Trail*
|
|
@end group
|
|
@end smallexample
|
|
|
|
In this figure, the mode-line for @file{myfile} has moved up and the
|
|
``Calculator'' window has appeared below it. As you can see, Calc
|
|
actually makes two windows side-by-side. The lefthand one is
|
|
called the @dfn{stack window} and the righthand one is called the
|
|
@dfn{trail window.} The stack holds the numbers involved in the
|
|
calculation you are currently performing. The trail holds a complete
|
|
record of all calculations you have done. In a desk calculator with
|
|
a printer, the trail corresponds to the paper tape that records what
|
|
you do.
|
|
|
|
In this case, the trail shows that four numbers (17.3, 3, 2, and 4)
|
|
were first entered into the Calculator, then the 2 and 4 were
|
|
multiplied to get 8, then the 3 and 8 were subtracted to get @mathit{-5}.
|
|
(The @samp{>} symbol shows that this was the most recent calculation.)
|
|
The net result is the two numbers 17.3 and @mathit{-5} sitting on the stack.
|
|
|
|
Most Calculator commands deal explicitly with the stack only, but
|
|
there is a set of commands that allow you to search back through
|
|
the trail and retrieve any previous result.
|
|
|
|
Calc commands use the digits, letters, and punctuation keys.
|
|
Shifted (i.e., upper-case) letters are different from lowercase
|
|
letters. Some letters are @dfn{prefix} keys that begin two-letter
|
|
commands. For example, @kbd{e} means ``enter exponent'' and shifted
|
|
@kbd{E} means @expr{e^x}. With the @kbd{d} (``display modes'') prefix
|
|
the letter ``e'' takes on very different meanings: @kbd{d e} means
|
|
``engineering notation'' and @kbd{d E} means ``@dfn{eqn} language mode.''
|
|
|
|
There is nothing stopping you from switching out of the Calc
|
|
window and back into your editing window, say by using the Emacs
|
|
@w{@kbd{C-x o}} (@code{other-window}) command. When the cursor is
|
|
inside a regular window, Emacs acts just like normal. When the
|
|
cursor is in the Calc stack or trail windows, keys are interpreted
|
|
as Calc commands.
|
|
|
|
When you quit by pressing @kbd{C-x * c} a second time, the Calculator
|
|
windows go away but the actual Stack and Trail are not gone, just
|
|
hidden. When you press @kbd{C-x * c} once again you will get the
|
|
same stack and trail contents you had when you last used the
|
|
Calculator.
|
|
|
|
The Calculator does not remember its state between Emacs sessions.
|
|
Thus if you quit Emacs and start it again, @kbd{C-x * c} will give you
|
|
a fresh stack and trail. There is a command (@kbd{m m}) that lets
|
|
you save your favorite mode settings between sessions, though.
|
|
One of the things it saves is which user interface (standard or
|
|
Keypad) you last used; otherwise, a freshly started Emacs will
|
|
always treat @kbd{C-x * *} the same as @kbd{C-x * c}.
|
|
|
|
The @kbd{q} key is another equivalent way to turn the Calculator off.
|
|
|
|
If you type @kbd{C-x * b} first and then @kbd{C-x * c}, you get a
|
|
full-screen version of Calc (@code{full-calc}) in which the stack and
|
|
trail windows are still side-by-side but are now as tall as the whole
|
|
Emacs screen. When you press @kbd{q} or @kbd{C-x * c} again to quit,
|
|
the file you were editing before reappears. The @kbd{C-x * b} key
|
|
switches back and forth between ``big'' full-screen mode and the
|
|
normal partial-screen mode.
|
|
|
|
Finally, @kbd{C-x * o} (@code{calc-other-window}) is like @kbd{C-x * c}
|
|
except that the Calc window is not selected. The buffer you were
|
|
editing before remains selected instead. @kbd{C-x * o} is a handy
|
|
way to switch out of Calc momentarily to edit your file; type
|
|
@kbd{C-x * c} to switch back into Calc when you are done.
|
|
|
|
@node Quick Mode Overview, Keypad Mode Overview, The Standard Interface, Using Calc
|
|
@subsection Quick Mode (Overview)
|
|
|
|
@noindent
|
|
@dfn{Quick mode} is a quick way to use Calc when you don't need the
|
|
full complexity of the stack and trail. To use it, type @kbd{C-x * q}
|
|
(@code{quick-calc}) in any regular editing buffer.
|
|
|
|
Quick mode is very simple: It prompts you to type any formula in
|
|
standard algebraic notation (like @samp{4 - 2/3}) and then displays
|
|
the result at the bottom of the Emacs screen (@mathit{3.33333333333}
|
|
in this case). You are then back in the same editing buffer you
|
|
were in before, ready to continue editing or to type @kbd{C-x * q}
|
|
again to do another quick calculation. The result of the calculation
|
|
will also be in the Emacs ``kill ring'' so that a @kbd{C-y} command
|
|
at this point will yank the result into your editing buffer.
|
|
|
|
Calc mode settings affect Quick mode, too, though you will have to
|
|
go into regular Calc (with @kbd{C-x * c}) to change the mode settings.
|
|
|
|
@c [fix-ref Quick Calculator mode]
|
|
@xref{Quick Calculator}, for further information.
|
|
|
|
@node Keypad Mode Overview, Standalone Operation, Quick Mode Overview, Using Calc
|
|
@subsection Keypad Mode (Overview)
|
|
|
|
@noindent
|
|
@dfn{Keypad mode} is a mouse-based interface to the Calculator.
|
|
It is designed for use with terminals that support a mouse. If you
|
|
don't have a mouse, you will have to operate Keypad mode with your
|
|
arrow keys (which is probably more trouble than it's worth).
|
|
|
|
Type @kbd{C-x * k} to turn Keypad mode on or off. Once again you
|
|
get two new windows, this time on the righthand side of the screen
|
|
instead of at the bottom. The upper window is the familiar Calc
|
|
Stack; the lower window is a picture of a typical calculator keypad.
|
|
|
|
@tex
|
|
\dimen0=\pagetotal%
|
|
\advance \dimen0 by 24\baselineskip%
|
|
\ifdim \dimen0>\pagegoal \vfill\eject \fi%
|
|
\medskip
|
|
@end tex
|
|
@smallexample
|
|
@group
|
|
|--- Emacs Calculator Mode ---
|
|
|2: 17.3
|
|
|1: -5
|
|
| .
|
|
|--%%-Calc: 12 Deg (Calcul
|
|
|----+-----Calc 2.1------+----1
|
|
|FLR |CEIL|RND |TRNC|CLN2|FLT |
|
|
|----+----+----+----+----+----|
|
|
| LN |EXP | |ABS |IDIV|MOD |
|
|
|----+----+----+----+----+----|
|
|
|SIN |COS |TAN |SQRT|y^x |1/x |
|
|
|----+----+----+----+----+----|
|
|
| ENTER |+/- |EEX |UNDO| <- |
|
|
|-----+---+-+--+--+-+---++----|
|
|
| INV | 7 | 8 | 9 | / |
|
|
|-----+-----+-----+-----+-----|
|
|
| HYP | 4 | 5 | 6 | * |
|
|
|-----+-----+-----+-----+-----|
|
|
|EXEC | 1 | 2 | 3 | - |
|
|
|-----+-----+-----+-----+-----|
|
|
| OFF | 0 | . | PI | + |
|
|
|-----+-----+-----+-----+-----+
|
|
@end group
|
|
@end smallexample
|
|
|
|
Keypad mode is much easier for beginners to learn, because there
|
|
is no need to memorize lots of obscure key sequences. But not all
|
|
commands in regular Calc are available on the Keypad. You can
|
|
always switch the cursor into the Calc stack window to use
|
|
standard Calc commands if you need. Serious Calc users, though,
|
|
often find they prefer the standard interface over Keypad mode.
|
|
|
|
To operate the Calculator, just click on the ``buttons'' of the
|
|
keypad using your left mouse button. To enter the two numbers
|
|
shown here you would click @w{@kbd{1 7 .@: 3 ENTER 5 +/- ENTER}}; to
|
|
add them together you would then click @kbd{+} (to get 12.3 on
|
|
the stack).
|
|
|
|
If you click the right mouse button, the top three rows of the
|
|
keypad change to show other sets of commands, such as advanced
|
|
math functions, vector operations, and operations on binary
|
|
numbers.
|
|
|
|
Because Keypad mode doesn't use the regular keyboard, Calc leaves
|
|
the cursor in your original editing buffer. You can type in
|
|
this buffer in the usual way while also clicking on the Calculator
|
|
keypad. One advantage of Keypad mode is that you don't need an
|
|
explicit command to switch between editing and calculating.
|
|
|
|
If you press @kbd{C-x * b} first, you get a full-screen Keypad mode
|
|
(@code{full-calc-keypad}) with three windows: The keypad in the lower
|
|
left, the stack in the lower right, and the trail on top.
|
|
|
|
@c [fix-ref Keypad Mode]
|
|
@xref{Keypad Mode}, for further information.
|
|
|
|
@node Standalone Operation, Embedded Mode Overview, Keypad Mode Overview, Using Calc
|
|
@subsection Standalone Operation
|
|
|
|
@noindent
|
|
@cindex Standalone Operation
|
|
If you are not in Emacs at the moment but you wish to use Calc,
|
|
you must start Emacs first. If all you want is to run Calc, you
|
|
can give the commands:
|
|
|
|
@example
|
|
emacs -f full-calc
|
|
@end example
|
|
|
|
@noindent
|
|
or
|
|
|
|
@example
|
|
emacs -f full-calc-keypad
|
|
@end example
|
|
|
|
@noindent
|
|
which run a full-screen Calculator (as if by @kbd{C-x * b C-x * c}) or
|
|
a full-screen X-based Calculator (as if by @kbd{C-x * b C-x * k}).
|
|
In standalone operation, quitting the Calculator (by pressing
|
|
@kbd{q} or clicking on the keypad @key{EXIT} button) quits Emacs
|
|
itself.
|
|
|
|
@node Embedded Mode Overview, Other C-x * Commands, Standalone Operation, Using Calc
|
|
@subsection Embedded Mode (Overview)
|
|
|
|
@noindent
|
|
@dfn{Embedded mode} is a way to use Calc directly from inside an
|
|
editing buffer. Suppose you have a formula written as part of a
|
|
document like this:
|
|
|
|
@smallexample
|
|
@group
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
is
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
and you wish to have Calc compute and format the derivative for
|
|
you and store this derivative in the buffer automatically. To
|
|
do this with Embedded mode, first copy the formula down to where
|
|
you want the result to be:
|
|
|
|
@smallexample
|
|
@group
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
is
|
|
|
|
ln(ln(x))
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now, move the cursor onto this new formula and press @kbd{C-x * e}.
|
|
Calc will read the formula (using the surrounding blank lines to
|
|
tell how much text to read), then push this formula (invisibly)
|
|
onto the Calc stack. The cursor will stay on the formula in the
|
|
editing buffer, but the buffer's mode line will change to look
|
|
like the Calc mode line (with mode indicators like @samp{12 Deg}
|
|
and so on). Even though you are still in your editing buffer,
|
|
the keyboard now acts like the Calc keyboard, and any new result
|
|
you get is copied from the stack back into the buffer. To take
|
|
the derivative, you would type @kbd{a d x @key{RET}}.
|
|
|
|
@smallexample
|
|
@group
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
is
|
|
|
|
1 / ln(x) x
|
|
@end group
|
|
@end smallexample
|
|
|
|
To make this look nicer, you might want to press @kbd{d =} to center
|
|
the formula, and even @kbd{d B} to use Big display mode.
|
|
|
|
@smallexample
|
|
@group
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
is
|
|
% [calc-mode: justify: center]
|
|
% [calc-mode: language: big]
|
|
|
|
1
|
|
-------
|
|
ln(x) x
|
|
@end group
|
|
@end smallexample
|
|
|
|
Calc has added annotations to the file to help it remember the modes
|
|
that were used for this formula. They are formatted like comments
|
|
in the @TeX{} typesetting language, just in case you are using @TeX{} or
|
|
La@TeX{}. (In this example @TeX{} is not being used, so you might want
|
|
to move these comments up to the top of the file or otherwise put them
|
|
out of the way.)
|
|
|
|
As an extra flourish, we can add an equation number using a
|
|
righthand label: Type @kbd{d @} (1) @key{RET}}.
|
|
|
|
@smallexample
|
|
@group
|
|
% [calc-mode: justify: center]
|
|
% [calc-mode: language: big]
|
|
% [calc-mode: right-label: " (1)"]
|
|
|
|
1
|
|
------- (1)
|
|
ln(x) x
|
|
@end group
|
|
@end smallexample
|
|
|
|
To leave Embedded mode, type @kbd{C-x * e} again. The mode line
|
|
and keyboard will revert to the way they were before.
|
|
|
|
The related command @kbd{C-x * w} operates on a single word, which
|
|
generally means a single number, inside text. It uses any
|
|
non-numeric characters rather than blank lines to delimit the
|
|
formula it reads. Here's an example of its use:
|
|
|
|
@smallexample
|
|
A slope of one-third corresponds to an angle of 1 degrees.
|
|
@end smallexample
|
|
|
|
Place the cursor on the @samp{1}, then type @kbd{C-x * w} to enable
|
|
Embedded mode on that number. Now type @kbd{3 /} (to get one-third),
|
|
and @kbd{I T} (the Inverse Tangent converts a slope into an angle),
|
|
then @w{@kbd{C-x * w}} again to exit Embedded mode.
|
|
|
|
@smallexample
|
|
A slope of one-third corresponds to an angle of 18.4349488229 degrees.
|
|
@end smallexample
|
|
|
|
@c [fix-ref Embedded Mode]
|
|
@xref{Embedded Mode}, for full details.
|
|
|
|
@node Other C-x * Commands, , Embedded Mode Overview, Using Calc
|
|
@subsection Other @kbd{C-x *} Commands
|
|
|
|
@noindent
|
|
Two more Calc-related commands are @kbd{C-x * g} and @kbd{C-x * r},
|
|
which ``grab'' data from a selected region of a buffer into the
|
|
Calculator. The region is defined in the usual Emacs way, by
|
|
a ``mark'' placed at one end of the region, and the Emacs
|
|
cursor or ``point'' placed at the other.
|
|
|
|
The @kbd{C-x * g} command reads the region in the usual left-to-right,
|
|
top-to-bottom order. The result is packaged into a Calc vector
|
|
of numbers and placed on the stack. Calc (in its standard
|
|
user interface) is then started. Type @kbd{v u} if you want
|
|
to unpack this vector into separate numbers on the stack. Also,
|
|
@kbd{C-u C-x * g} interprets the region as a single number or
|
|
formula.
|
|
|
|
The @kbd{C-x * r} command reads a rectangle, with the point and
|
|
mark defining opposite corners of the rectangle. The result
|
|
is a matrix of numbers on the Calculator stack.
|
|
|
|
Complementary to these is @kbd{C-x * y}, which ``yanks'' the
|
|
value at the top of the Calc stack back into an editing buffer.
|
|
If you type @w{@kbd{C-x * y}} while in such a buffer, the value is
|
|
yanked at the current position. If you type @kbd{C-x * y} while
|
|
in the Calc buffer, Calc makes an educated guess as to which
|
|
editing buffer you want to use. The Calc window does not have
|
|
to be visible in order to use this command, as long as there
|
|
is something on the Calc stack.
|
|
|
|
Here, for reference, is the complete list of @kbd{C-x *} commands.
|
|
The shift, control, and meta keys are ignored for the keystroke
|
|
following @kbd{C-x *}.
|
|
|
|
@noindent
|
|
Commands for turning Calc on and off:
|
|
|
|
@table @kbd
|
|
@item *
|
|
Turn Calc on or off, employing the same user interface as last time.
|
|
|
|
@item =, +, -, /, \, &, #
|
|
Alternatives for @kbd{*}.
|
|
|
|
@item C
|
|
Turn Calc on or off using its standard bottom-of-the-screen
|
|
interface. If Calc is already turned on but the cursor is not
|
|
in the Calc window, move the cursor into the window.
|
|
|
|
@item O
|
|
Same as @kbd{C}, but don't select the new Calc window. If
|
|
Calc is already turned on and the cursor is in the Calc window,
|
|
move it out of that window.
|
|
|
|
@item B
|
|
Control whether @kbd{C-x * c} and @kbd{C-x * k} use the full screen.
|
|
|
|
@item Q
|
|
Use Quick mode for a single short calculation.
|
|
|
|
@item K
|
|
Turn Calc Keypad mode on or off.
|
|
|
|
@item E
|
|
Turn Calc Embedded mode on or off at the current formula.
|
|
|
|
@item J
|
|
Turn Calc Embedded mode on or off, select the interesting part.
|
|
|
|
@item W
|
|
Turn Calc Embedded mode on or off at the current word (number).
|
|
|
|
@item Z
|
|
Turn Calc on in a user-defined way, as defined by a @kbd{Z I} command.
|
|
|
|
@item X
|
|
Quit Calc; turn off standard, Keypad, or Embedded mode if on.
|
|
(This is like @kbd{q} or @key{OFF} inside of Calc.)
|
|
@end table
|
|
@iftex
|
|
@sp 2
|
|
@end iftex
|
|
|
|
@noindent
|
|
Commands for moving data into and out of the Calculator:
|
|
|
|
@table @kbd
|
|
@item G
|
|
Grab the region into the Calculator as a vector.
|
|
|
|
@item R
|
|
Grab the rectangular region into the Calculator as a matrix.
|
|
|
|
@item :
|
|
Grab the rectangular region and compute the sums of its columns.
|
|
|
|
@item _
|
|
Grab the rectangular region and compute the sums of its rows.
|
|
|
|
@item Y
|
|
Yank a value from the Calculator into the current editing buffer.
|
|
@end table
|
|
@iftex
|
|
@sp 2
|
|
@end iftex
|
|
|
|
@noindent
|
|
Commands for use with Embedded mode:
|
|
|
|
@table @kbd
|
|
@item A
|
|
``Activate'' the current buffer. Locate all formulas that
|
|
contain @samp{:=} or @samp{=>} symbols and record their locations
|
|
so that they can be updated automatically as variables are changed.
|
|
|
|
@item D
|
|
Duplicate the current formula immediately below and select
|
|
the duplicate.
|
|
|
|
@item F
|
|
Insert a new formula at the current point.
|
|
|
|
@item N
|
|
Move the cursor to the next active formula in the buffer.
|
|
|
|
@item P
|
|
Move the cursor to the previous active formula in the buffer.
|
|
|
|
@item U
|
|
Update (i.e., as if by the @kbd{=} key) the formula at the current point.
|
|
|
|
@item `
|
|
Edit (as if by @code{calc-edit}) the formula at the current point.
|
|
@end table
|
|
@iftex
|
|
@sp 2
|
|
@end iftex
|
|
|
|
@noindent
|
|
Miscellaneous commands:
|
|
|
|
@table @kbd
|
|
@item I
|
|
Run the Emacs Info system to read the Calc manual.
|
|
(This is the same as @kbd{h i} inside of Calc.)
|
|
|
|
@item T
|
|
Run the Emacs Info system to read the Calc Tutorial.
|
|
|
|
@item S
|
|
Run the Emacs Info system to read the Calc Summary.
|
|
|
|
@item L
|
|
Load Calc entirely into memory. (Normally the various parts
|
|
are loaded only as they are needed.)
|
|
|
|
@item M
|
|
Read a region of written keystroke names (like @kbd{C-n a b c @key{RET}})
|
|
and record them as the current keyboard macro.
|
|
|
|
@item 0
|
|
(This is the ``zero'' digit key.) Reset the Calculator to
|
|
its initial state: Empty stack, and initial mode settings.
|
|
@end table
|
|
|
|
@node History and Acknowledgements, , Using Calc, Getting Started
|
|
@section History and Acknowledgements
|
|
|
|
@noindent
|
|
Calc was originally started as a two-week project to occupy a lull
|
|
in the author's schedule. Basically, a friend asked if I remembered
|
|
the value of
|
|
@texline @math{2^{32}}.
|
|
@infoline @expr{2^32}.
|
|
I didn't offhand, but I said, ``that's easy, just call up an
|
|
@code{xcalc}.'' @code{Xcalc} duly reported that the answer to our
|
|
question was @samp{4.294967e+09}---with no way to see the full ten
|
|
digits even though we knew they were there in the program's memory! I
|
|
was so annoyed, I vowed to write a calculator of my own, once and for
|
|
all.
|
|
|
|
I chose Emacs Lisp, a) because I had always been curious about it
|
|
and b) because, being only a text editor extension language after
|
|
all, Emacs Lisp would surely reach its limits long before the project
|
|
got too far out of hand.
|
|
|
|
To make a long story short, Emacs Lisp turned out to be a distressingly
|
|
solid implementation of Lisp, and the humble task of calculating
|
|
turned out to be more open-ended than one might have expected.
|
|
|
|
Emacs Lisp doesn't have built-in floating point math, so it had to be
|
|
simulated in software. In fact, Emacs integers will only comfortably
|
|
fit six decimal digits or so---not enough for a decent calculator. So
|
|
I had to write my own high-precision integer code as well, and once I had
|
|
this I figured that arbitrary-size integers were just as easy as large
|
|
integers. Arbitrary floating-point precision was the logical next step.
|
|
Also, since the large integer arithmetic was there anyway it seemed only
|
|
fair to give the user direct access to it, which in turn made it practical
|
|
to support fractions as well as floats. All these features inspired me
|
|
to look around for other data types that might be worth having.
|
|
|
|
Around this time, my friend Rick Koshi showed me his nifty new HP-28
|
|
calculator. It allowed the user to manipulate formulas as well as
|
|
numerical quantities, and it could also operate on matrices. I
|
|
decided that these would be good for Calc to have, too. And once
|
|
things had gone this far, I figured I might as well take a look at
|
|
serious algebra systems for further ideas. Since these systems did
|
|
far more than I could ever hope to implement, I decided to focus on
|
|
rewrite rules and other programming features so that users could
|
|
implement what they needed for themselves.
|
|
|
|
Rick complained that matrices were hard to read, so I put in code to
|
|
format them in a 2D style. Once these routines were in place, Big mode
|
|
was obligatory. Gee, what other language modes would be useful?
|
|
|
|
Scott Hemphill and Allen Knutson, two friends with a strong mathematical
|
|
bent, contributed ideas and algorithms for a number of Calc features
|
|
including modulo forms, primality testing, and float-to-fraction conversion.
|
|
|
|
Units were added at the eager insistence of Mass Sivilotti. Later,
|
|
Ulrich Mueller at CERN and Przemek Klosowski at NIST provided invaluable
|
|
expert assistance with the units table. As far as I can remember, the
|
|
idea of using algebraic formulas and variables to represent units dates
|
|
back to an ancient article in Byte magazine about muMath, an early
|
|
algebra system for microcomputers.
|
|
|
|
Many people have contributed to Calc by reporting bugs and suggesting
|
|
features, large and small. A few deserve special mention: Tim Peters,
|
|
who helped develop the ideas that led to the selection commands, rewrite
|
|
rules, and many other algebra features;
|
|
@texline Fran\c{c}ois
|
|
@infoline Francois
|
|
Pinard, who contributed an early prototype of the Calc Summary appendix
|
|
as well as providing valuable suggestions in many other areas of Calc;
|
|
Carl Witty, whose eagle eyes discovered many typographical and factual
|
|
errors in the Calc manual; Tim Kay, who drove the development of
|
|
Embedded mode; Ove Ewerlid, who made many suggestions relating to the
|
|
algebra commands and contributed some code for polynomial operations;
|
|
Randal Schwartz, who suggested the @code{calc-eval} function; Robert
|
|
J. Chassell, who suggested the Calc Tutorial and exercises; and Juha
|
|
Sarlin, who first worked out how to split Calc into quickly-loading
|
|
parts. Bob Weiner helped immensely with the Lucid Emacs port.
|
|
|
|
@cindex Bibliography
|
|
@cindex Knuth, Art of Computer Programming
|
|
@cindex Numerical Recipes
|
|
@c Should these be expanded into more complete references?
|
|
Among the books used in the development of Calc were Knuth's @emph{Art
|
|
of Computer Programming} (especially volume II, @emph{Seminumerical
|
|
Algorithms}); @emph{Numerical Recipes} by Press, Flannery, Teukolsky,
|
|
and Vetterling; Bevington's @emph{Data Reduction and Error Analysis
|
|
for the Physical Sciences}; @emph{Concrete Mathematics} by Graham,
|
|
Knuth, and Patashnik; Steele's @emph{Common Lisp, the Language}; the
|
|
@emph{CRC Standard Math Tables} (William H. Beyer, ed.); and
|
|
Abramowitz and Stegun's venerable @emph{Handbook of Mathematical
|
|
Functions}. Also, of course, Calc could not have been written without
|
|
the excellent @emph{GNU Emacs Lisp Reference Manual}, by Bil Lewis and
|
|
Dan LaLiberte.
|
|
|
|
Final thanks go to Richard Stallman, without whose fine implementations
|
|
of the Emacs editor, language, and environment, Calc would have been
|
|
finished in two weeks.
|
|
|
|
@c [tutorial]
|
|
|
|
@ifinfo
|
|
@c This node is accessed by the `C-x * t' command.
|
|
@node Interactive Tutorial, , , Top
|
|
@chapter Tutorial
|
|
|
|
@noindent
|
|
Some brief instructions on using the Emacs Info system for this tutorial:
|
|
|
|
Press the space bar and Delete keys to go forward and backward in a
|
|
section by screenfuls (or use the regular Emacs scrolling commands
|
|
for this).
|
|
|
|
Press @kbd{n} or @kbd{p} to go to the Next or Previous section.
|
|
If the section has a @dfn{menu}, press a digit key like @kbd{1}
|
|
or @kbd{2} to go to a sub-section from the menu. Press @kbd{u} to
|
|
go back up from a sub-section to the menu it is part of.
|
|
|
|
Exercises in the tutorial all have cross-references to the
|
|
appropriate page of the ``answers'' section. Press @kbd{f}, then
|
|
the exercise number, to see the answer to an exercise. After
|
|
you have followed a cross-reference, you can press the letter
|
|
@kbd{l} to return to where you were before.
|
|
|
|
You can press @kbd{?} at any time for a brief summary of Info commands.
|
|
|
|
Press @kbd{1} now to enter the first section of the Tutorial.
|
|
|
|
@menu
|
|
* Tutorial::
|
|
@end menu
|
|
@end ifinfo
|
|
|
|
@node Tutorial, Introduction, Getting Started, Top
|
|
@chapter Tutorial
|
|
|
|
@noindent
|
|
This chapter explains how to use Calc and its many features, in
|
|
a step-by-step, tutorial way. You are encouraged to run Calc and
|
|
work along with the examples as you read (@pxref{Starting Calc}).
|
|
If you are already familiar with advanced calculators, you may wish
|
|
@c [not-split]
|
|
to skip on to the rest of this manual.
|
|
@c [when-split]
|
|
@c to skip on to volume II of this manual, the @dfn{Calc Reference}.
|
|
|
|
@c [fix-ref Embedded Mode]
|
|
This tutorial describes the standard user interface of Calc only.
|
|
The Quick mode and Keypad mode interfaces are fairly
|
|
self-explanatory. @xref{Embedded Mode}, for a description of
|
|
the Embedded mode interface.
|
|
|
|
@ifinfo
|
|
The easiest way to read this tutorial on-line is to have two windows on
|
|
your Emacs screen, one with Calc and one with the Info system. (If you
|
|
have a printed copy of the manual you can use that instead.) Press
|
|
@kbd{C-x * c} to turn Calc on or to switch into the Calc window, and
|
|
press @kbd{C-x * i} to start the Info system or to switch into its window.
|
|
Or, you may prefer to use the tutorial in printed form.
|
|
@end ifinfo
|
|
@iftex
|
|
The easiest way to read this tutorial on-line is to have two windows on
|
|
your Emacs screen, one with Calc and one with the Info system. (If you
|
|
have a printed copy of the manual you can use that instead.) Press
|
|
@kbd{C-x * c} to turn Calc on or to switch into the Calc window, and
|
|
press @kbd{C-x * i} to start the Info system or to switch into its window.
|
|
@end iftex
|
|
|
|
This tutorial is designed to be done in sequence. But the rest of this
|
|
manual does not assume you have gone through the tutorial. The tutorial
|
|
does not cover everything in the Calculator, but it touches on most
|
|
general areas.
|
|
|
|
@ifinfo
|
|
You may wish to print out a copy of the Calc Summary and keep notes on
|
|
it as you learn Calc. @xref{About This Manual}, to see how to make a
|
|
printed summary. @xref{Summary}.
|
|
@end ifinfo
|
|
@iftex
|
|
The Calc Summary at the end of the reference manual includes some blank
|
|
space for your own use. You may wish to keep notes there as you learn
|
|
Calc.
|
|
@end iftex
|
|
|
|
@menu
|
|
* Basic Tutorial::
|
|
* Arithmetic Tutorial::
|
|
* Vector/Matrix Tutorial::
|
|
* Types Tutorial::
|
|
* Algebra Tutorial::
|
|
* Programming Tutorial::
|
|
|
|
* Answers to Exercises::
|
|
@end menu
|
|
|
|
@node Basic Tutorial, Arithmetic Tutorial, Tutorial, Tutorial
|
|
@section Basic Tutorial
|
|
|
|
@noindent
|
|
In this section, we learn how RPN and algebraic-style calculations
|
|
work, how to undo and redo an operation done by mistake, and how
|
|
to control various modes of the Calculator.
|
|
|
|
@menu
|
|
* RPN Tutorial:: Basic operations with the stack.
|
|
* Algebraic Tutorial:: Algebraic entry; variables.
|
|
* Undo Tutorial:: If you make a mistake: Undo and the trail.
|
|
* Modes Tutorial:: Common mode-setting commands.
|
|
@end menu
|
|
|
|
@node RPN Tutorial, Algebraic Tutorial, Basic Tutorial, Basic Tutorial
|
|
@subsection RPN Calculations and the Stack
|
|
|
|
@cindex RPN notation
|
|
@ifinfo
|
|
@noindent
|
|
Calc normally uses RPN notation. You may be familiar with the RPN
|
|
system from Hewlett-Packard calculators, FORTH, or PostScript.
|
|
(Reverse Polish Notation, RPN, is named after the Polish mathematician
|
|
Jan Lukasiewicz.)
|
|
@end ifinfo
|
|
@tex
|
|
\noindent
|
|
Calc normally uses RPN notation. You may be familiar with the RPN
|
|
system from Hewlett-Packard calculators, FORTH, or PostScript.
|
|
(Reverse Polish Notation, RPN, is named after the Polish mathematician
|
|
Jan \L ukasiewicz.)
|
|
@end tex
|
|
|
|
The central component of an RPN calculator is the @dfn{stack}. A
|
|
calculator stack is like a stack of dishes. New dishes (numbers) are
|
|
added at the top of the stack, and numbers are normally only removed
|
|
from the top of the stack.
|
|
|
|
@cindex Operators
|
|
@cindex Operands
|
|
In an operation like @expr{2+3}, the 2 and 3 are called the @dfn{operands}
|
|
and the @expr{+} is the @dfn{operator}. In an RPN calculator you always
|
|
enter the operands first, then the operator. Each time you type a
|
|
number, Calc adds or @dfn{pushes} it onto the top of the Stack.
|
|
When you press an operator key like @kbd{+}, Calc @dfn{pops} the appropriate
|
|
number of operands from the stack and pushes back the result.
|
|
|
|
Thus we could add the numbers 2 and 3 in an RPN calculator by typing:
|
|
@kbd{2 @key{RET} 3 @key{RET} +}. (The @key{RET} key, Return, corresponds to
|
|
the @key{ENTER} key on traditional RPN calculators.) Try this now if
|
|
you wish; type @kbd{C-x * c} to switch into the Calc window (you can type
|
|
@kbd{C-x * c} again or @kbd{C-x * o} to switch back to the Tutorial window).
|
|
The first four keystrokes ``push'' the numbers 2 and 3 onto the stack.
|
|
The @kbd{+} key ``pops'' the top two numbers from the stack, adds them,
|
|
and pushes the result (5) back onto the stack. Here's how the stack
|
|
will look at various points throughout the calculation:
|
|
|
|
@smallexample
|
|
@group
|
|
. 1: 2 2: 2 1: 5 .
|
|
. 1: 3 .
|
|
.
|
|
|
|
C-x * c 2 @key{RET} 3 @key{RET} + @key{DEL}
|
|
@end group
|
|
@end smallexample
|
|
|
|
The @samp{.} symbol is a marker that represents the top of the stack.
|
|
Note that the ``top'' of the stack is really shown at the bottom of
|
|
the Stack window. This may seem backwards, but it turns out to be
|
|
less distracting in regular use.
|
|
|
|
@cindex Stack levels
|
|
@cindex Levels of stack
|
|
The numbers @samp{1:} and @samp{2:} on the left are @dfn{stack level
|
|
numbers}. Old RPN calculators always had four stack levels called
|
|
@expr{x}, @expr{y}, @expr{z}, and @expr{t}. Calc's stack can grow
|
|
as large as you like, so it uses numbers instead of letters. Some
|
|
stack-manipulation commands accept a numeric argument that says
|
|
which stack level to work on. Normal commands like @kbd{+} always
|
|
work on the top few levels of the stack.
|
|
|
|
@c [fix-ref Truncating the Stack]
|
|
The Stack buffer is just an Emacs buffer, and you can move around in
|
|
it using the regular Emacs motion commands. But no matter where the
|
|
cursor is, even if you have scrolled the @samp{.} marker out of
|
|
view, most Calc commands always move the cursor back down to level 1
|
|
before doing anything. It is possible to move the @samp{.} marker
|
|
upwards through the stack, temporarily ``hiding'' some numbers from
|
|
commands like @kbd{+}. This is called @dfn{stack truncation} and
|
|
we will not cover it in this tutorial; @pxref{Truncating the Stack},
|
|
if you are interested.
|
|
|
|
You don't really need the second @key{RET} in @kbd{2 @key{RET} 3
|
|
@key{RET} +}. That's because if you type any operator name or
|
|
other non-numeric key when you are entering a number, the Calculator
|
|
automatically enters that number and then does the requested command.
|
|
Thus @kbd{2 @key{RET} 3 +} will work just as well.
|
|
|
|
Examples in this tutorial will often omit @key{RET} even when the
|
|
stack displays shown would only happen if you did press @key{RET}:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 2: 2 1: 5
|
|
. 1: 3 .
|
|
.
|
|
|
|
2 @key{RET} 3 +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here, after pressing @kbd{3} the stack would really show @samp{1: 2}
|
|
with @samp{Calc:@: 3} in the minibuffer. In these situations, you can
|
|
press the optional @key{RET} to see the stack as the figure shows.
|
|
|
|
(@bullet{}) @strong{Exercise 1.} (This tutorial will include exercises
|
|
at various points. Try them if you wish. Answers to all the exercises
|
|
are located at the end of the Tutorial chapter. Each exercise will
|
|
include a cross-reference to its particular answer. If you are
|
|
reading with the Emacs Info system, press @kbd{f} and the
|
|
exercise number to go to the answer, then the letter @kbd{l} to
|
|
return to where you were.)
|
|
|
|
@noindent
|
|
Here's the first exercise: What will the keystrokes @kbd{1 @key{RET} 2
|
|
@key{RET} 3 @key{RET} 4 + * -} compute? (@samp{*} is the symbol for
|
|
multiplication.) Figure it out by hand, then try it with Calc to see
|
|
if you're right. @xref{RPN Answer 1, 1}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Compute
|
|
@texline @math{(2\times4) + (7\times9.4) + {5\over4}}
|
|
@infoline @expr{2*4 + 7*9.5 + 5/4}
|
|
using the stack. @xref{RPN Answer 2, 2}. (@bullet{})
|
|
|
|
The @key{DEL} key is called Backspace on some keyboards. It is
|
|
whatever key you would use to correct a simple typing error when
|
|
regularly using Emacs. The @key{DEL} key pops and throws away the
|
|
top value on the stack. (You can still get that value back from
|
|
the Trail if you should need it later on.) There are many places
|
|
in this tutorial where we assume you have used @key{DEL} to erase the
|
|
results of the previous example at the beginning of a new example.
|
|
In the few places where it is really important to use @key{DEL} to
|
|
clear away old results, the text will remind you to do so.
|
|
|
|
(It won't hurt to let things accumulate on the stack, except that
|
|
whenever you give a display-mode-changing command Calc will have to
|
|
spend a long time reformatting such a large stack.)
|
|
|
|
Since the @kbd{-} key is also an operator (it subtracts the top two
|
|
stack elements), how does one enter a negative number? Calc uses
|
|
the @kbd{_} (underscore) key to act like the minus sign in a number.
|
|
So, typing @kbd{-5 @key{RET}} won't work because the @kbd{-} key
|
|
will try to do a subtraction, but @kbd{_5 @key{RET}} works just fine.
|
|
|
|
You can also press @kbd{n}, which means ``change sign.'' It changes
|
|
the number at the top of the stack (or the number being entered)
|
|
from positive to negative or vice-versa: @kbd{5 n @key{RET}}.
|
|
|
|
@cindex Duplicating a stack entry
|
|
If you press @key{RET} when you're not entering a number, the effect
|
|
is to duplicate the top number on the stack. Consider this calculation:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3 2: 3 1: 9 2: 9 1: 81
|
|
. 1: 3 . 1: 9 .
|
|
. .
|
|
|
|
3 @key{RET} @key{RET} * @key{RET} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Of course, an easier way to do this would be @kbd{3 @key{RET} 4 ^},
|
|
to raise 3 to the fourth power.)
|
|
|
|
The space-bar key (denoted @key{SPC} here) performs the same function
|
|
as @key{RET}; you could replace all three occurrences of @key{RET} in
|
|
the above example with @key{SPC} and the effect would be the same.
|
|
|
|
@cindex Exchanging stack entries
|
|
Another stack manipulation key is @key{TAB}. This exchanges the top
|
|
two stack entries. Suppose you have computed @kbd{2 @key{RET} 3 +}
|
|
to get 5, and then you realize what you really wanted to compute
|
|
was @expr{20 / (2+3)}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 5 2: 5 2: 20 1: 4
|
|
. 1: 20 1: 5 .
|
|
. .
|
|
|
|
2 @key{RET} 3 + 20 @key{TAB} /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Planning ahead, the calculation would have gone like this:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 20 2: 20 3: 20 2: 20 1: 4
|
|
. 1: 2 2: 2 1: 5 .
|
|
. 1: 3 .
|
|
.
|
|
|
|
20 @key{RET} 2 @key{RET} 3 + /
|
|
@end group
|
|
@end smallexample
|
|
|
|
A related stack command is @kbd{M-@key{TAB}} (hold @key{META} and type
|
|
@key{TAB}). It rotates the top three elements of the stack upward,
|
|
bringing the object in level 3 to the top.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10 2: 10 3: 10 3: 20 3: 30
|
|
. 1: 20 2: 20 2: 30 2: 10
|
|
. 1: 30 1: 10 1: 20
|
|
. . .
|
|
|
|
10 @key{RET} 20 @key{RET} 30 @key{RET} M-@key{TAB} M-@key{TAB}
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 3.} Suppose the numbers 10, 20, and 30 are
|
|
on the stack. Figure out how to add one to the number in level 2
|
|
without affecting the rest of the stack. Also figure out how to add
|
|
one to the number in level 3. @xref{RPN Answer 3, 3}. (@bullet{})
|
|
|
|
Operations like @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/}, and @kbd{^} pop two
|
|
arguments from the stack and push a result. Operations like @kbd{n} and
|
|
@kbd{Q} (square root) pop a single number and push the result. You can
|
|
think of them as simply operating on the top element of the stack.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3 1: 9 2: 9 1: 25 1: 5
|
|
. . 1: 16 . .
|
|
.
|
|
|
|
3 @key{RET} @key{RET} * 4 @key{RET} @key{RET} * + Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Note that capital @kbd{Q} means to hold down the Shift key while
|
|
typing @kbd{q}. Remember, plain unshifted @kbd{q} is the Quit command.)
|
|
|
|
@cindex Pythagorean Theorem
|
|
Here we've used the Pythagorean Theorem to determine the hypotenuse of a
|
|
right triangle. Calc actually has a built-in command for that called
|
|
@kbd{f h}, but let's suppose we can't remember the necessary keystrokes.
|
|
We can still enter it by its full name using @kbd{M-x} notation:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3 2: 3 1: 5
|
|
. 1: 4 .
|
|
.
|
|
|
|
3 @key{RET} 4 @key{RET} M-x calc-hypot
|
|
@end group
|
|
@end smallexample
|
|
|
|
All Calculator commands begin with the word @samp{calc-}. Since it
|
|
gets tiring to type this, Calc provides an @kbd{x} key which is just
|
|
like the regular Emacs @kbd{M-x} key except that it types the @samp{calc-}
|
|
prefix for you:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3 2: 3 1: 5
|
|
. 1: 4 .
|
|
.
|
|
|
|
3 @key{RET} 4 @key{RET} x hypot
|
|
@end group
|
|
@end smallexample
|
|
|
|
What happens if you take the square root of a negative number?
|
|
|
|
@smallexample
|
|
@group
|
|
1: 4 1: -4 1: (0, 2)
|
|
. . .
|
|
|
|
4 @key{RET} n Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The notation @expr{(a, b)} represents a complex number.
|
|
Complex numbers are more traditionally written @expr{a + b i};
|
|
Calc can display in this format, too, but for now we'll stick to the
|
|
@expr{(a, b)} notation.
|
|
|
|
If you don't know how complex numbers work, you can safely ignore this
|
|
feature. Complex numbers only arise from operations that would be
|
|
errors in a calculator that didn't have complex numbers. (For example,
|
|
taking the square root or logarithm of a negative number produces a
|
|
complex result.)
|
|
|
|
Complex numbers are entered in the notation shown. The @kbd{(} and
|
|
@kbd{,} and @kbd{)} keys manipulate ``incomplete complex numbers.''
|
|
|
|
@smallexample
|
|
@group
|
|
1: ( ... 2: ( ... 1: (2, ... 1: (2, ... 1: (2, 3)
|
|
. 1: 2 . 3 .
|
|
. .
|
|
|
|
( 2 , 3 )
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can perform calculations while entering parts of incomplete objects.
|
|
However, an incomplete object cannot actually participate in a calculation:
|
|
|
|
@smallexample
|
|
@group
|
|
1: ( ... 2: ( ... 3: ( ... 1: ( ... 1: ( ...
|
|
. 1: 2 2: 2 5 5
|
|
. 1: 3 . .
|
|
.
|
|
(error)
|
|
( 2 @key{RET} 3 + +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Adding 5 to an incomplete object makes no sense, so the last command
|
|
produces an error message and leaves the stack the same.
|
|
|
|
Incomplete objects can't participate in arithmetic, but they can be
|
|
moved around by the regular stack commands.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 2 3: 2 3: 3 1: ( ... 1: (2, 3)
|
|
1: 3 2: 3 2: ( ... 2 .
|
|
. 1: ( ... 1: 2 3
|
|
. . .
|
|
|
|
2 @key{RET} 3 @key{RET} ( M-@key{TAB} M-@key{TAB} )
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that the @kbd{,} (comma) key did not have to be used here.
|
|
When you press @kbd{)} all the stack entries between the incomplete
|
|
entry and the top are collected, so there's never really a reason
|
|
to use the comma. It's up to you.
|
|
|
|
(@bullet{}) @strong{Exercise 4.} To enter the complex number @expr{(2, 3)},
|
|
your friend Joe typed @kbd{( 2 , @key{SPC} 3 )}. What happened?
|
|
(Joe thought of a clever way to correct his mistake in only two
|
|
keystrokes, but it didn't quite work. Try it to find out why.)
|
|
@xref{RPN Answer 4, 4}. (@bullet{})
|
|
|
|
Vectors are entered the same way as complex numbers, but with square
|
|
brackets in place of parentheses. We'll meet vectors again later in
|
|
the tutorial.
|
|
|
|
Any Emacs command can be given a @dfn{numeric prefix argument} by
|
|
typing a series of @key{META}-digits beforehand. If @key{META} is
|
|
awkward for you, you can instead type @kbd{C-u} followed by the
|
|
necessary digits. Numeric prefix arguments can be negative, as in
|
|
@kbd{M-- M-3 M-5} or @w{@kbd{C-u - 3 5}}. Calc commands use numeric
|
|
prefix arguments in a variety of ways. For example, a numeric prefix
|
|
on the @kbd{+} operator adds any number of stack entries at once:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10 2: 10 3: 10 3: 10 1: 60
|
|
. 1: 20 2: 20 2: 20 .
|
|
. 1: 30 1: 30
|
|
. .
|
|
|
|
10 @key{RET} 20 @key{RET} 30 @key{RET} C-u 3 +
|
|
@end group
|
|
@end smallexample
|
|
|
|
For stack manipulation commands like @key{RET}, a positive numeric
|
|
prefix argument operates on the top @var{n} stack entries at once. A
|
|
negative argument operates on the entry in level @var{n} only. An
|
|
argument of zero operates on the entire stack. In this example, we copy
|
|
the second-to-top element of the stack:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10 2: 10 3: 10 3: 10 4: 10
|
|
. 1: 20 2: 20 2: 20 3: 20
|
|
. 1: 30 1: 30 2: 30
|
|
. . 1: 20
|
|
.
|
|
|
|
10 @key{RET} 20 @key{RET} 30 @key{RET} C-u -2 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Clearing the stack
|
|
@cindex Emptying the stack
|
|
Another common idiom is @kbd{M-0 @key{DEL}}, which clears the stack.
|
|
(The @kbd{M-0} numeric prefix tells @key{DEL} to operate on the
|
|
entire stack.)
|
|
|
|
@node Algebraic Tutorial, Undo Tutorial, RPN Tutorial, Basic Tutorial
|
|
@subsection Algebraic-Style Calculations
|
|
|
|
@noindent
|
|
If you are not used to RPN notation, you may prefer to operate the
|
|
Calculator in Algebraic mode, which is closer to the way
|
|
non-RPN calculators work. In Algebraic mode, you enter formulas
|
|
in traditional @expr{2+3} notation.
|
|
|
|
You don't really need any special ``mode'' to enter algebraic formulas.
|
|
You can enter a formula at any time by pressing the apostrophe (@kbd{'})
|
|
key. Answer the prompt with the desired formula, then press @key{RET}.
|
|
The formula is evaluated and the result is pushed onto the RPN stack.
|
|
If you don't want to think in RPN at all, you can enter your whole
|
|
computation as a formula, read the result from the stack, then press
|
|
@key{DEL} to delete it from the stack.
|
|
|
|
Try pressing the apostrophe key, then @kbd{2+3+4}, then @key{RET}.
|
|
The result should be the number 9.
|
|
|
|
Algebraic formulas use the operators @samp{+}, @samp{-}, @samp{*},
|
|
@samp{/}, and @samp{^}. You can use parentheses to make the order
|
|
of evaluation clear. In the absence of parentheses, @samp{^} is
|
|
evaluated first, then @samp{*}, then @samp{/}, then finally
|
|
@samp{+} and @samp{-}. For example, the expression
|
|
|
|
@example
|
|
2 + 3*4*5 / 6*7^8 - 9
|
|
@end example
|
|
|
|
@noindent
|
|
is equivalent to
|
|
|
|
@example
|
|
2 + ((3*4*5) / (6*(7^8)) - 9
|
|
@end example
|
|
|
|
@noindent
|
|
or, in large mathematical notation,
|
|
|
|
@ifinfo
|
|
@example
|
|
@group
|
|
3 * 4 * 5
|
|
2 + --------- - 9
|
|
8
|
|
6 * 7
|
|
@end group
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ 2 + { 3 \times 4 \times 5 \over 6 \times 7^8 } - 9 $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
The result of this expression will be the number @mathit{-6.99999826533}.
|
|
|
|
Calc's order of evaluation is the same as for most computer languages,
|
|
except that @samp{*} binds more strongly than @samp{/}, as the above
|
|
example shows. As in normal mathematical notation, the @samp{*} symbol
|
|
can often be omitted: @samp{2 a} is the same as @samp{2*a}.
|
|
|
|
Operators at the same level are evaluated from left to right, except
|
|
that @samp{^} is evaluated from right to left. Thus, @samp{2-3-4} is
|
|
equivalent to @samp{(2-3)-4} or @mathit{-5}, whereas @samp{2^3^4} is equivalent
|
|
to @samp{2^(3^4)} (a very large integer; try it!).
|
|
|
|
If you tire of typing the apostrophe all the time, there is
|
|
Algebraic mode, where Calc automatically senses
|
|
when you are about to type an algebraic expression. To enter this
|
|
mode, press the two letters @w{@kbd{m a}}. (An @samp{Alg} indicator
|
|
should appear in the Calc window's mode line.)
|
|
|
|
Press @kbd{m a}, then @kbd{2+3+4} with no apostrophe, then @key{RET}.
|
|
|
|
In Algebraic mode, when you press any key that would normally begin
|
|
entering a number (such as a digit, a decimal point, or the @kbd{_}
|
|
key), or if you press @kbd{(} or @kbd{[}, Calc automatically begins
|
|
an algebraic entry.
|
|
|
|
Functions which do not have operator symbols like @samp{+} and @samp{*}
|
|
must be entered in formulas using function-call notation. For example,
|
|
the function name corresponding to the square-root key @kbd{Q} is
|
|
@code{sqrt}. To compute a square root in a formula, you would use
|
|
the notation @samp{sqrt(@var{x})}.
|
|
|
|
Press the apostrophe, then type @kbd{sqrt(5*2) - 3}. The result should
|
|
be @expr{0.16227766017}.
|
|
|
|
Note that if the formula begins with a function name, you need to use
|
|
the apostrophe even if you are in Algebraic mode. If you type @kbd{arcsin}
|
|
out of the blue, the @kbd{a r} will be taken as an Algebraic Rewrite
|
|
command, and the @kbd{csin} will be taken as the name of the rewrite
|
|
rule to use!
|
|
|
|
Some people prefer to enter complex numbers and vectors in algebraic
|
|
form because they find RPN entry with incomplete objects to be too
|
|
distracting, even though they otherwise use Calc as an RPN calculator.
|
|
|
|
Still in Algebraic mode, type:
|
|
|
|
@smallexample
|
|
@group
|
|
1: (2, 3) 2: (2, 3) 1: (8, -1) 2: (8, -1) 1: (9, -1)
|
|
. 1: (1, -2) . 1: 1 .
|
|
. .
|
|
|
|
(2,3) @key{RET} (1,-2) @key{RET} * 1 @key{RET} +
|
|
@end group
|
|
@end smallexample
|
|
|
|
Algebraic mode allows us to enter complex numbers without pressing
|
|
an apostrophe first, but it also means we need to press @key{RET}
|
|
after every entry, even for a simple number like @expr{1}.
|
|
|
|
(You can type @kbd{C-u m a} to enable a special Incomplete Algebraic
|
|
mode in which the @kbd{(} and @kbd{[} keys use algebraic entry even
|
|
though regular numeric keys still use RPN numeric entry. There is also
|
|
Total Algebraic mode, started by typing @kbd{m t}, in which all
|
|
normal keys begin algebraic entry. You must then use the @key{META} key
|
|
to type Calc commands: @kbd{M-m t} to get back out of Total Algebraic
|
|
mode, @kbd{M-q} to quit, etc.)
|
|
|
|
If you're still in Algebraic mode, press @kbd{m a} again to turn it off.
|
|
|
|
Actual non-RPN calculators use a mixture of algebraic and RPN styles.
|
|
In general, operators of two numbers (like @kbd{+} and @kbd{*})
|
|
use algebraic form, but operators of one number (like @kbd{n} and @kbd{Q})
|
|
use RPN form. Also, a non-RPN calculator allows you to see the
|
|
intermediate results of a calculation as you go along. You can
|
|
accomplish this in Calc by performing your calculation as a series
|
|
of algebraic entries, using the @kbd{$} sign to tie them together.
|
|
In an algebraic formula, @kbd{$} represents the number on the top
|
|
of the stack. Here, we perform the calculation
|
|
@texline @math{\sqrt{2\times4+1}},
|
|
@infoline @expr{sqrt(2*4+1)},
|
|
which on a traditional calculator would be done by pressing
|
|
@kbd{2 * 4 + 1 =} and then the square-root key.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 8 1: 9 1: 3
|
|
. . .
|
|
|
|
' 2*4 @key{RET} $+1 @key{RET} Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice that we didn't need to press an apostrophe for the @kbd{$+1},
|
|
because the dollar sign always begins an algebraic entry.
|
|
|
|
(@bullet{}) @strong{Exercise 1.} How could you get the same effect as
|
|
pressing @kbd{Q} but using an algebraic entry instead? How about
|
|
if the @kbd{Q} key on your keyboard were broken?
|
|
@xref{Algebraic Answer 1, 1}. (@bullet{})
|
|
|
|
The notations @kbd{$$}, @kbd{$$$}, and so on stand for higher stack
|
|
entries. For example, @kbd{' $$+$ @key{RET}} is just like typing @kbd{+}.
|
|
|
|
Algebraic formulas can include @dfn{variables}. To store in a
|
|
variable, press @kbd{s s}, then type the variable name, then press
|
|
@key{RET}. (There are actually two flavors of store command:
|
|
@kbd{s s} stores a number in a variable but also leaves the number
|
|
on the stack, while @w{@kbd{s t}} removes a number from the stack and
|
|
stores it in the variable.) A variable name should consist of one
|
|
or more letters or digits, beginning with a letter.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 . 1: a + a^2 1: 306
|
|
. . .
|
|
|
|
17 s t a @key{RET} ' a+a^2 @key{RET} =
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @kbd{=} key @dfn{evaluates} a formula by replacing all its
|
|
variables by the values that were stored in them.
|
|
|
|
For RPN calculations, you can recall a variable's value on the
|
|
stack either by entering its name as a formula and pressing @kbd{=},
|
|
or by using the @kbd{s r} command.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 2: 17 3: 17 2: 17 1: 306
|
|
. 1: 17 2: 17 1: 289 .
|
|
. 1: 2 .
|
|
.
|
|
|
|
s r a @key{RET} ' a @key{RET} = 2 ^ +
|
|
@end group
|
|
@end smallexample
|
|
|
|
If you press a single digit for a variable name (as in @kbd{s t 3}, you
|
|
get one of ten @dfn{quick variables} @code{q0} through @code{q9}.
|
|
They are ``quick'' simply because you don't have to type the letter
|
|
@code{q} or the @key{RET} after their names. In fact, you can type
|
|
simply @kbd{s 3} as a shorthand for @kbd{s s 3}, and likewise for
|
|
@kbd{t 3} and @w{@kbd{r 3}}.
|
|
|
|
Any variables in an algebraic formula for which you have not stored
|
|
values are left alone, even when you evaluate the formula.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 a + 2 b 1: 34 + 2 b
|
|
. .
|
|
|
|
' 2a+2b @key{RET} =
|
|
@end group
|
|
@end smallexample
|
|
|
|
Calls to function names which are undefined in Calc are also left
|
|
alone, as are calls for which the value is undefined.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 + log10(0) + log10(x) + log10(5, 6) + foo(3)
|
|
.
|
|
|
|
' log10(100) + log10(0) + log10(x) + log10(5,6) + foo(3) @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In this example, the first call to @code{log10} works, but the other
|
|
calls are not evaluated. In the second call, the logarithm is
|
|
undefined for that value of the argument; in the third, the argument
|
|
is symbolic, and in the fourth, there are too many arguments. In the
|
|
fifth case, there is no function called @code{foo}. You will see a
|
|
``Wrong number of arguments'' message referring to @samp{log10(5,6)}.
|
|
Press the @kbd{w} (``why'') key to see any other messages that may
|
|
have arisen from the last calculation. In this case you will get
|
|
``logarithm of zero,'' then ``number expected: @code{x}''. Calc
|
|
automatically displays the first message only if the message is
|
|
sufficiently important; for example, Calc considers ``wrong number
|
|
of arguments'' and ``logarithm of zero'' to be important enough to
|
|
report automatically, while a message like ``number expected: @code{x}''
|
|
will only show up if you explicitly press the @kbd{w} key.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Joe entered the formula @samp{2 x y},
|
|
stored 5 in @code{x}, pressed @kbd{=}, and got the expected result,
|
|
@samp{10 y}. He then tried the same for the formula @samp{2 x (1+y)},
|
|
expecting @samp{10 (1+y)}, but it didn't work. Why not?
|
|
@xref{Algebraic Answer 2, 2}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 3.} What result would you expect
|
|
@kbd{1 @key{RET} 0 /} to give? What if you then type @kbd{0 *}?
|
|
@xref{Algebraic Answer 3, 3}. (@bullet{})
|
|
|
|
One interesting way to work with variables is to use the
|
|
@dfn{evaluates-to} (@samp{=>}) operator. It works like this:
|
|
Enter a formula algebraically in the usual way, but follow
|
|
the formula with an @samp{=>} symbol. (There is also an @kbd{s =}
|
|
command which builds an @samp{=>} formula using the stack.) On
|
|
the stack, you will see two copies of the formula with an @samp{=>}
|
|
between them. The lefthand formula is exactly like you typed it;
|
|
the righthand formula has been evaluated as if by typing @kbd{=}.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 2 + 3 => 5 2: 2 + 3 => 5
|
|
1: 2 a + 2 b => 34 + 2 b 1: 2 a + 2 b => 20 + 2 b
|
|
. .
|
|
|
|
' 2+3 => @key{RET} ' 2a+2b @key{RET} s = 10 s t a @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice that the instant we stored a new value in @code{a}, all
|
|
@samp{=>} operators already on the stack that referred to @expr{a}
|
|
were updated to use the new value. With @samp{=>}, you can push a
|
|
set of formulas on the stack, then change the variables experimentally
|
|
to see the effects on the formulas' values.
|
|
|
|
You can also ``unstore'' a variable when you are through with it:
|
|
|
|
@smallexample
|
|
@group
|
|
2: 2 + 5 => 5
|
|
1: 2 a + 2 b => 2 a + 2 b
|
|
.
|
|
|
|
s u a @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
We will encounter formulas involving variables and functions again
|
|
when we discuss the algebra and calculus features of the Calculator.
|
|
|
|
@node Undo Tutorial, Modes Tutorial, Algebraic Tutorial, Basic Tutorial
|
|
@subsection Undo and Redo
|
|
|
|
@noindent
|
|
If you make a mistake, you can usually correct it by pressing shift-@kbd{U},
|
|
the ``undo'' command. First, clear the stack (@kbd{M-0 @key{DEL}}) and exit
|
|
and restart Calc (@kbd{C-x * * C-x * *}) to make sure things start off
|
|
with a clean slate. Now:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 2: 2 1: 8 2: 2 1: 6
|
|
. 1: 3 . 1: 3 .
|
|
. .
|
|
|
|
2 @key{RET} 3 ^ U *
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can undo any number of times. Calc keeps a complete record of
|
|
all you have done since you last opened the Calc window. After the
|
|
above example, you could type:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 6 2: 2 1: 2 . .
|
|
. 1: 3 .
|
|
.
|
|
(error)
|
|
U U U U
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can also type @kbd{D} to ``redo'' a command that you have undone
|
|
mistakenly.
|
|
|
|
@smallexample
|
|
@group
|
|
. 1: 2 2: 2 1: 6 1: 6
|
|
. 1: 3 . .
|
|
.
|
|
(error)
|
|
D D D D
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
It was not possible to redo past the @expr{6}, since that was placed there
|
|
by something other than an undo command.
|
|
|
|
@cindex Time travel
|
|
You can think of undo and redo as a sort of ``time machine.'' Press
|
|
@kbd{U} to go backward in time, @kbd{D} to go forward. If you go
|
|
backward and do something (like @kbd{*}) then, as any science fiction
|
|
reader knows, you have changed your future and you cannot go forward
|
|
again. Thus, the inability to redo past the @expr{6} even though there
|
|
was an earlier undo command.
|
|
|
|
You can always recall an earlier result using the Trail. We've ignored
|
|
the trail so far, but it has been faithfully recording everything we
|
|
did since we loaded the Calculator. If the Trail is not displayed,
|
|
press @kbd{t d} now to turn it on.
|
|
|
|
Let's try grabbing an earlier result. The @expr{8} we computed was
|
|
undone by a @kbd{U} command, and was lost even to Redo when we pressed
|
|
@kbd{*}, but it's still there in the trail. There should be a little
|
|
@samp{>} arrow (the @dfn{trail pointer}) resting on the last trail
|
|
entry. If there isn't, press @kbd{t ]} to reset the trail pointer.
|
|
Now, press @w{@kbd{t p}} to move the arrow onto the line containing
|
|
@expr{8}, and press @w{@kbd{t y}} to ``yank'' that number back onto the
|
|
stack.
|
|
|
|
If you press @kbd{t ]} again, you will see that even our Yank command
|
|
went into the trail.
|
|
|
|
Let's go further back in time. Earlier in the tutorial we computed
|
|
a huge integer using the formula @samp{2^3^4}. We don't remember
|
|
what it was, but the first digits were ``241''. Press @kbd{t r}
|
|
(which stands for trail-search-reverse), then type @kbd{241}.
|
|
The trail cursor will jump back to the next previous occurrence of
|
|
the string ``241'' in the trail. This is just a regular Emacs
|
|
incremental search; you can now press @kbd{C-s} or @kbd{C-r} to
|
|
continue the search forwards or backwards as you like.
|
|
|
|
To finish the search, press @key{RET}. This halts the incremental
|
|
search and leaves the trail pointer at the thing we found. Now we
|
|
can type @kbd{t y} to yank that number onto the stack. If we hadn't
|
|
remembered the ``241'', we could simply have searched for @kbd{2^3^4},
|
|
then pressed @kbd{@key{RET} t n} to halt and then move to the next item.
|
|
|
|
You may have noticed that all the trail-related commands begin with
|
|
the letter @kbd{t}. (The store-and-recall commands, on the other hand,
|
|
all began with @kbd{s}.) Calc has so many commands that there aren't
|
|
enough keys for all of them, so various commands are grouped into
|
|
two-letter sequences where the first letter is called the @dfn{prefix}
|
|
key. If you type a prefix key by accident, you can press @kbd{C-g}
|
|
to cancel it. (In fact, you can press @kbd{C-g} to cancel almost
|
|
anything in Emacs.) To get help on a prefix key, press that key
|
|
followed by @kbd{?}. Some prefixes have several lines of help,
|
|
so you need to press @kbd{?} repeatedly to see them all.
|
|
You can also type @kbd{h h} to see all the help at once.
|
|
|
|
Try pressing @kbd{t ?} now. You will see a line of the form,
|
|
|
|
@smallexample
|
|
trail/time: Display; Fwd, Back; Next, Prev, Here, [, ]; Yank: [MORE] t-
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The word ``trail'' indicates that the @kbd{t} prefix key contains
|
|
trail-related commands. Each entry on the line shows one command,
|
|
with a single capital letter showing which letter you press to get
|
|
that command. We have used @kbd{t n}, @kbd{t p}, @kbd{t ]}, and
|
|
@kbd{t y} so far. The @samp{[MORE]} means you can press @kbd{?}
|
|
again to see more @kbd{t}-prefix commands. Notice that the commands
|
|
are roughly divided (by semicolons) into related groups.
|
|
|
|
When you are in the help display for a prefix key, the prefix is
|
|
still active. If you press another key, like @kbd{y} for example,
|
|
it will be interpreted as a @kbd{t y} command. If all you wanted
|
|
was to look at the help messages, press @kbd{C-g} afterwards to cancel
|
|
the prefix.
|
|
|
|
One more way to correct an error is by editing the stack entries.
|
|
The actual Stack buffer is marked read-only and must not be edited
|
|
directly, but you can press @kbd{`} (the backquote or accent grave)
|
|
to edit a stack entry.
|
|
|
|
Try entering @samp{3.141439} now. If this is supposed to represent
|
|
@cpi{}, it's got several errors. Press @kbd{`} to edit this number.
|
|
Now use the normal Emacs cursor motion and editing keys to change
|
|
the second 4 to a 5, and to transpose the 3 and the 9. When you
|
|
press @key{RET}, the number on the stack will be replaced by your
|
|
new number. This works for formulas, vectors, and all other types
|
|
of values you can put on the stack. The @kbd{`} key also works
|
|
during entry of a number or algebraic formula.
|
|
|
|
@node Modes Tutorial, , Undo Tutorial, Basic Tutorial
|
|
@subsection Mode-Setting Commands
|
|
|
|
@noindent
|
|
Calc has many types of @dfn{modes} that affect the way it interprets
|
|
your commands or the way it displays data. We have already seen one
|
|
mode, namely Algebraic mode. There are many others, too; we'll
|
|
try some of the most common ones here.
|
|
|
|
Perhaps the most fundamental mode in Calc is the current @dfn{precision}.
|
|
Notice the @samp{12} on the Calc window's mode line:
|
|
|
|
@smallexample
|
|
--%%-Calc: 12 Deg (Calculator)----All------
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Most of the symbols there are Emacs things you don't need to worry
|
|
about, but the @samp{12} and the @samp{Deg} are mode indicators.
|
|
The @samp{12} means that calculations should always be carried to
|
|
12 significant figures. That is why, when we type @kbd{1 @key{RET} 7 /},
|
|
we get @expr{0.142857142857} with exactly 12 digits, not counting
|
|
leading and trailing zeros.
|
|
|
|
You can set the precision to anything you like by pressing @kbd{p},
|
|
then entering a suitable number. Try pressing @kbd{p 30 @key{RET}},
|
|
then doing @kbd{1 @key{RET} 7 /} again:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.142857142857
|
|
2: 0.142857142857142857142857142857
|
|
.
|
|
@end group
|
|
@end smallexample
|
|
|
|
Although the precision can be set arbitrarily high, Calc always
|
|
has to have @emph{some} value for the current precision. After
|
|
all, the true value @expr{1/7} is an infinitely repeating decimal;
|
|
Calc has to stop somewhere.
|
|
|
|
Of course, calculations are slower the more digits you request.
|
|
Press @w{@kbd{p 12}} now to set the precision back down to the default.
|
|
|
|
Calculations always use the current precision. For example, even
|
|
though we have a 30-digit value for @expr{1/7} on the stack, if
|
|
we use it in a calculation in 12-digit mode it will be rounded
|
|
down to 12 digits before it is used. Try it; press @key{RET} to
|
|
duplicate the number, then @w{@kbd{1 +}}. Notice that the @key{RET}
|
|
key didn't round the number, because it doesn't do any calculation.
|
|
But the instant we pressed @kbd{+}, the number was rounded down.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.142857142857
|
|
2: 0.142857142857142857142857142857
|
|
3: 1.14285714286
|
|
.
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In fact, since we added a digit on the left, we had to lose one
|
|
digit on the right from even the 12-digit value of @expr{1/7}.
|
|
|
|
How did we get more than 12 digits when we computed @samp{2^3^4}? The
|
|
answer is that Calc makes a distinction between @dfn{integers} and
|
|
@dfn{floating-point} numbers, or @dfn{floats}. An integer is a number
|
|
that does not contain a decimal point. There is no such thing as an
|
|
``infinitely repeating fraction integer,'' so Calc doesn't have to limit
|
|
itself. If you asked for @samp{2^10000} (don't try this!), you would
|
|
have to wait a long time but you would eventually get an exact answer.
|
|
If you ask for @samp{2.^10000}, you will quickly get an answer which is
|
|
correct only to 12 places. The decimal point tells Calc that it should
|
|
use floating-point arithmetic to get the answer, not exact integer
|
|
arithmetic.
|
|
|
|
You can use the @kbd{F} (@code{calc-floor}) command to convert a
|
|
floating-point value to an integer, and @kbd{c f} (@code{calc-float})
|
|
to convert an integer to floating-point form.
|
|
|
|
Let's try entering that last calculation:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2. 2: 2. 1: 1.99506311689e3010
|
|
. 1: 10000 .
|
|
.
|
|
|
|
2.0 @key{RET} 10000 @key{RET} ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
@cindex Scientific notation, entry of
|
|
Notice the letter @samp{e} in there. It represents ``times ten to the
|
|
power of,'' and is used by Calc automatically whenever writing the
|
|
number out fully would introduce more extra zeros than you probably
|
|
want to see. You can enter numbers in this notation, too.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2. 2: 2. 1: 1.99506311678e3010
|
|
. 1: 10000. .
|
|
.
|
|
|
|
2.0 @key{RET} 1e4 @key{RET} ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Round-off errors
|
|
@noindent
|
|
Hey, the answer is different! Look closely at the middle columns
|
|
of the two examples. In the first, the stack contained the
|
|
exact integer @expr{10000}, but in the second it contained
|
|
a floating-point value with a decimal point. When you raise a
|
|
number to an integer power, Calc uses repeated squaring and
|
|
multiplication to get the answer. When you use a floating-point
|
|
power, Calc uses logarithms and exponentials. As you can see,
|
|
a slight error crept in during one of these methods. Which
|
|
one should we trust? Let's raise the precision a bit and find
|
|
out:
|
|
|
|
@smallexample
|
|
@group
|
|
. 1: 2. 2: 2. 1: 1.995063116880828e3010
|
|
. 1: 10000. .
|
|
.
|
|
|
|
p 16 @key{RET} 2. @key{RET} 1e4 ^ p 12 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
@cindex Guard digits
|
|
Presumably, it doesn't matter whether we do this higher-precision
|
|
calculation using an integer or floating-point power, since we
|
|
have added enough ``guard digits'' to trust the first 12 digits
|
|
no matter what. And the verdict is@dots{} Integer powers were more
|
|
accurate; in fact, the result was only off by one unit in the
|
|
last place.
|
|
|
|
@cindex Guard digits
|
|
Calc does many of its internal calculations to a slightly higher
|
|
precision, but it doesn't always bump the precision up enough.
|
|
In each case, Calc added about two digits of precision during
|
|
its calculation and then rounded back down to 12 digits
|
|
afterward. In one case, it was enough; in the other, it
|
|
wasn't. If you really need @var{x} digits of precision, it
|
|
never hurts to do the calculation with a few extra guard digits.
|
|
|
|
What if we want guard digits but don't want to look at them?
|
|
We can set the @dfn{float format}. Calc supports four major
|
|
formats for floating-point numbers, called @dfn{normal},
|
|
@dfn{fixed-point}, @dfn{scientific notation}, and @dfn{engineering
|
|
notation}. You get them by pressing @w{@kbd{d n}}, @kbd{d f},
|
|
@kbd{d s}, and @kbd{d e}, respectively. In each case, you can
|
|
supply a numeric prefix argument which says how many digits
|
|
should be displayed. As an example, let's put a few numbers
|
|
onto the stack and try some different display modes. First,
|
|
use @kbd{M-0 @key{DEL}} to clear the stack, then enter the four
|
|
numbers shown here:
|
|
|
|
@smallexample
|
|
@group
|
|
4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
|
|
3: 12345. 3: 12300. 3: 1.2345e4 3: 1.23e4 3: 12345.000
|
|
2: 123.45 2: 123. 2: 1.2345e2 2: 1.23e2 2: 123.450
|
|
1: 12.345 1: 12.3 1: 1.2345e1 1: 1.23e1 1: 12.345
|
|
. . . . .
|
|
|
|
d n M-3 d n d s M-3 d s M-3 d f
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice that when we typed @kbd{M-3 d n}, the numbers were rounded down
|
|
to three significant digits, but then when we typed @kbd{d s} all
|
|
five significant figures reappeared. The float format does not
|
|
affect how numbers are stored, it only affects how they are
|
|
displayed. Only the current precision governs the actual rounding
|
|
of numbers in the Calculator's memory.
|
|
|
|
Engineering notation, not shown here, is like scientific notation
|
|
except the exponent (the power-of-ten part) is always adjusted to be
|
|
a multiple of three (as in ``kilo,'' ``micro,'' etc.). As a result
|
|
there will be one, two, or three digits before the decimal point.
|
|
|
|
Whenever you change a display-related mode, Calc redraws everything
|
|
in the stack. This may be slow if there are many things on the stack,
|
|
so Calc allows you to type shift-@kbd{H} before any mode command to
|
|
prevent it from updating the stack. Anything Calc displays after the
|
|
mode-changing command will appear in the new format.
|
|
|
|
@smallexample
|
|
@group
|
|
4: 12345 4: 12345 4: 12345 4: 12345 4: 12345
|
|
3: 12345.000 3: 12345.000 3: 12345.000 3: 1.2345e4 3: 12345.
|
|
2: 123.450 2: 123.450 2: 1.2345e1 2: 1.2345e1 2: 123.45
|
|
1: 12.345 1: 1.2345e1 1: 1.2345e2 1: 1.2345e2 1: 12.345
|
|
. . . . .
|
|
|
|
H d s @key{DEL} U @key{TAB} d @key{SPC} d n
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here the @kbd{H d s} command changes to scientific notation but without
|
|
updating the screen. Deleting the top stack entry and undoing it back
|
|
causes it to show up in the new format; swapping the top two stack
|
|
entries reformats both entries. The @kbd{d @key{SPC}} command refreshes the
|
|
whole stack. The @kbd{d n} command changes back to the normal float
|
|
format; since it doesn't have an @kbd{H} prefix, it also updates all
|
|
the stack entries to be in @kbd{d n} format.
|
|
|
|
Notice that the integer @expr{12345} was not affected by any
|
|
of the float formats. Integers are integers, and are always
|
|
displayed exactly.
|
|
|
|
@cindex Large numbers, readability
|
|
Large integers have their own problems. Let's look back at
|
|
the result of @kbd{2^3^4}.
|
|
|
|
@example
|
|
2417851639229258349412352
|
|
@end example
|
|
|
|
@noindent
|
|
Quick---how many digits does this have? Try typing @kbd{d g}:
|
|
|
|
@example
|
|
2,417,851,639,229,258,349,412,352
|
|
@end example
|
|
|
|
@noindent
|
|
Now how many digits does this have? It's much easier to tell!
|
|
We can actually group digits into clumps of any size. Some
|
|
people prefer @kbd{M-5 d g}:
|
|
|
|
@example
|
|
24178,51639,22925,83494,12352
|
|
@end example
|
|
|
|
Let's see what happens to floating-point numbers when they are grouped.
|
|
First, type @kbd{p 25 @key{RET}} to make sure we have enough precision
|
|
to get ourselves into trouble. Now, type @kbd{1e13 /}:
|
|
|
|
@example
|
|
24,17851,63922.9258349412352
|
|
@end example
|
|
|
|
@noindent
|
|
The integer part is grouped but the fractional part isn't. Now try
|
|
@kbd{M-- M-5 d g} (that's meta-minus-sign, meta-five):
|
|
|
|
@example
|
|
24,17851,63922.92583,49412,352
|
|
@end example
|
|
|
|
If you find it hard to tell the decimal point from the commas, try
|
|
changing the grouping character to a space with @kbd{d , @key{SPC}}:
|
|
|
|
@example
|
|
24 17851 63922.92583 49412 352
|
|
@end example
|
|
|
|
Type @kbd{d , ,} to restore the normal grouping character, then
|
|
@kbd{d g} again to turn grouping off. Also, press @kbd{p 12} to
|
|
restore the default precision.
|
|
|
|
Press @kbd{U} enough times to get the original big integer back.
|
|
(Notice that @kbd{U} does not undo each mode-setting command; if
|
|
you want to undo a mode-setting command, you have to do it yourself.)
|
|
Now, type @kbd{d r 16 @key{RET}}:
|
|
|
|
@example
|
|
16#200000000000000000000
|
|
@end example
|
|
|
|
@noindent
|
|
The number is now displayed in @dfn{hexadecimal}, or ``base-16'' form.
|
|
Suddenly it looks pretty simple; this should be no surprise, since we
|
|
got this number by computing a power of two, and 16 is a power of 2.
|
|
In fact, we can use @w{@kbd{d r 2 @key{RET}}} to see it in actual binary
|
|
form:
|
|
|
|
@example
|
|
2#1000000000000000000000000000000000000000000000000000000 @dots{}
|
|
@end example
|
|
|
|
@noindent
|
|
We don't have enough space here to show all the zeros! They won't
|
|
fit on a typical screen, either, so you will have to use horizontal
|
|
scrolling to see them all. Press @kbd{<} and @kbd{>} to scroll the
|
|
stack window left and right by half its width. Another way to view
|
|
something large is to press @kbd{`} (back-quote) to edit the top of
|
|
stack in a separate window. (Press @kbd{C-c C-c} when you are done.)
|
|
|
|
You can enter non-decimal numbers using the @kbd{#} symbol, too.
|
|
Let's see what the hexadecimal number @samp{5FE} looks like in
|
|
binary. Type @kbd{16#5FE} (the letters can be typed in upper or
|
|
lower case; they will always appear in upper case). It will also
|
|
help to turn grouping on with @kbd{d g}:
|
|
|
|
@example
|
|
2#101,1111,1110
|
|
@end example
|
|
|
|
Notice that @kbd{d g} groups by fours by default if the display radix
|
|
is binary or hexadecimal, but by threes if it is decimal, octal, or any
|
|
other radix.
|
|
|
|
Now let's see that number in decimal; type @kbd{d r 10}:
|
|
|
|
@example
|
|
1,534
|
|
@end example
|
|
|
|
Numbers are not @emph{stored} with any particular radix attached. They're
|
|
just numbers; they can be entered in any radix, and are always displayed
|
|
in whatever radix you've chosen with @kbd{d r}. The current radix applies
|
|
to integers, fractions, and floats.
|
|
|
|
@cindex Roundoff errors, in non-decimal numbers
|
|
(@bullet{}) @strong{Exercise 1.} Your friend Joe tried to enter one-third
|
|
as @samp{3#0.1} in @kbd{d r 3} mode with a precision of 12. He got
|
|
@samp{3#0.0222222...} (with 25 2's) in the display. When he multiplied
|
|
that by three, he got @samp{3#0.222222...} instead of the expected
|
|
@samp{3#1}. Next, Joe entered @samp{3#0.2} and, to his great relief,
|
|
saw @samp{3#0.2} on the screen. But when he typed @kbd{2 /}, he got
|
|
@samp{3#0.10000001} (some zeros omitted). What's going on here?
|
|
@xref{Modes Answer 1, 1}. (@bullet{})
|
|
|
|
@cindex Scientific notation, in non-decimal numbers
|
|
(@bullet{}) @strong{Exercise 2.} Scientific notation works in non-decimal
|
|
modes in the natural way (the exponent is a power of the radix instead of
|
|
a power of ten, although the exponent itself is always written in decimal).
|
|
Thus @samp{8#1.23e3 = 8#1230.0}. Suppose we have the hexadecimal number
|
|
@samp{f.e8f} times 16 to the 15th power: We write @samp{16#f.e8fe15}.
|
|
What is wrong with this picture? What could we write instead that would
|
|
work better? @xref{Modes Answer 2, 2}. (@bullet{})
|
|
|
|
The @kbd{m} prefix key has another set of modes, relating to the way
|
|
Calc interprets your inputs and does computations. Whereas @kbd{d}-prefix
|
|
modes generally affect the way things look, @kbd{m}-prefix modes affect
|
|
the way they are actually computed.
|
|
|
|
The most popular @kbd{m}-prefix mode is the @dfn{angular mode}. Notice
|
|
the @samp{Deg} indicator in the mode line. This means that if you use
|
|
a command that interprets a number as an angle, it will assume the
|
|
angle is measured in degrees. For example,
|
|
|
|
@smallexample
|
|
@group
|
|
1: 45 1: 0.707106781187 1: 0.500000000001 1: 0.5
|
|
. . . .
|
|
|
|
45 S 2 ^ c 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The shift-@kbd{S} command computes the sine of an angle. The sine
|
|
of 45 degrees is
|
|
@texline @math{\sqrt{2}/2};
|
|
@infoline @expr{sqrt(2)/2};
|
|
squaring this yields @expr{2/4 = 0.5}. However, there has been a slight
|
|
roundoff error because the representation of
|
|
@texline @math{\sqrt{2}/2}
|
|
@infoline @expr{sqrt(2)/2}
|
|
wasn't exact. The @kbd{c 1} command is a handy way to clean up numbers
|
|
in this case; it temporarily reduces the precision by one digit while it
|
|
re-rounds the number on the top of the stack.
|
|
|
|
@cindex Roundoff errors, examples
|
|
(@bullet{}) @strong{Exercise 3.} Your friend Joe computed the sine
|
|
of 45 degrees as shown above, then, hoping to avoid an inexact
|
|
result, he increased the precision to 16 digits before squaring.
|
|
What happened? @xref{Modes Answer 3, 3}. (@bullet{})
|
|
|
|
To do this calculation in radians, we would type @kbd{m r} first.
|
|
(The indicator changes to @samp{Rad}.) 45 degrees corresponds to
|
|
@cpiover{4} radians. To get @cpi{}, press the @kbd{P} key. (Once
|
|
again, this is a shifted capital @kbd{P}. Remember, unshifted
|
|
@kbd{p} sets the precision.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3.14159265359 1: 0.785398163398 1: 0.707106781187
|
|
. . .
|
|
|
|
P 4 / m r S
|
|
@end group
|
|
@end smallexample
|
|
|
|
Likewise, inverse trigonometric functions generate results in
|
|
either radians or degrees, depending on the current angular mode.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.707106781187 1: 0.785398163398 1: 45.
|
|
. . .
|
|
|
|
.5 Q m r I S m d U I S
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we compute the Inverse Sine of
|
|
@texline @math{\sqrt{0.5}},
|
|
@infoline @expr{sqrt(0.5)},
|
|
first in radians, then in degrees.
|
|
|
|
Use @kbd{c d} and @kbd{c r} to convert a number from radians to degrees
|
|
and vice-versa.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 45 1: 0.785398163397 1: 45.
|
|
. . .
|
|
|
|
45 c r c d
|
|
@end group
|
|
@end smallexample
|
|
|
|
Another interesting mode is @dfn{Fraction mode}. Normally,
|
|
dividing two integers produces a floating-point result if the
|
|
quotient can't be expressed as an exact integer. Fraction mode
|
|
causes integer division to produce a fraction, i.e., a rational
|
|
number, instead.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 12 1: 1.33333333333 1: 4:3
|
|
1: 9 . .
|
|
.
|
|
|
|
12 @key{RET} 9 / m f U / m f
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In the first case, we get an approximate floating-point result.
|
|
In the second case, we get an exact fractional result (four-thirds).
|
|
|
|
You can enter a fraction at any time using @kbd{:} notation.
|
|
(Calc uses @kbd{:} instead of @kbd{/} as the fraction separator
|
|
because @kbd{/} is already used to divide the top two stack
|
|
elements.) Calculations involving fractions will always
|
|
produce exact fractional results; Fraction mode only says
|
|
what to do when dividing two integers.
|
|
|
|
@cindex Fractions vs. floats
|
|
@cindex Floats vs. fractions
|
|
(@bullet{}) @strong{Exercise 4.} If fractional arithmetic is exact,
|
|
why would you ever use floating-point numbers instead?
|
|
@xref{Modes Answer 4, 4}. (@bullet{})
|
|
|
|
Typing @kbd{m f} doesn't change any existing values in the stack.
|
|
In the above example, we had to Undo the division and do it over
|
|
again when we changed to Fraction mode. But if you use the
|
|
evaluates-to operator you can get commands like @kbd{m f} to
|
|
recompute for you.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 12 / 9 => 1.33333333333 1: 12 / 9 => 1.333 1: 12 / 9 => 4:3
|
|
. . .
|
|
|
|
' 12/9 => @key{RET} p 4 @key{RET} m f
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In this example, the righthand side of the @samp{=>} operator
|
|
on the stack is recomputed when we change the precision, then
|
|
again when we change to Fraction mode. All @samp{=>} expressions
|
|
on the stack are recomputed every time you change any mode that
|
|
might affect their values.
|
|
|
|
@node Arithmetic Tutorial, Vector/Matrix Tutorial, Basic Tutorial, Tutorial
|
|
@section Arithmetic Tutorial
|
|
|
|
@noindent
|
|
In this section, we explore the arithmetic and scientific functions
|
|
available in the Calculator.
|
|
|
|
The standard arithmetic commands are @kbd{+}, @kbd{-}, @kbd{*}, @kbd{/},
|
|
and @kbd{^}. Each normally takes two numbers from the top of the stack
|
|
and pushes back a result. The @kbd{n} and @kbd{&} keys perform
|
|
change-sign and reciprocal operations, respectively.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
|
|
. . . . .
|
|
|
|
5 & & n n
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Binary operators
|
|
You can apply a ``binary operator'' like @kbd{+} across any number of
|
|
stack entries by giving it a numeric prefix. You can also apply it
|
|
pairwise to several stack elements along with the top one if you use
|
|
a negative prefix.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 2 1: 9 3: 2 4: 2 3: 12
|
|
2: 3 . 2: 3 3: 3 2: 13
|
|
1: 4 1: 4 2: 4 1: 14
|
|
. . 1: 10 .
|
|
.
|
|
|
|
2 @key{RET} 3 @key{RET} 4 M-3 + U 10 M-- M-3 +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Unary operators
|
|
You can apply a ``unary operator'' like @kbd{&} to the top @var{n}
|
|
stack entries with a numeric prefix, too.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 2 3: 0.5 3: 0.5
|
|
2: 3 2: 0.333333333333 2: 3.
|
|
1: 4 1: 0.25 1: 4.
|
|
. . .
|
|
|
|
2 @key{RET} 3 @key{RET} 4 M-3 & M-2 &
|
|
@end group
|
|
@end smallexample
|
|
|
|
Notice that the results here are left in floating-point form.
|
|
We can convert them back to integers by pressing @kbd{F}, the
|
|
``floor'' function. This function rounds down to the next lower
|
|
integer. There is also @kbd{R}, which rounds to the nearest
|
|
integer.
|
|
|
|
@smallexample
|
|
@group
|
|
7: 2. 7: 2 7: 2
|
|
6: 2.4 6: 2 6: 2
|
|
5: 2.5 5: 2 5: 3
|
|
4: 2.6 4: 2 4: 3
|
|
3: -2. 3: -2 3: -2
|
|
2: -2.4 2: -3 2: -2
|
|
1: -2.6 1: -3 1: -3
|
|
. . .
|
|
|
|
M-7 F U M-7 R
|
|
@end group
|
|
@end smallexample
|
|
|
|
Since dividing-and-flooring (i.e., ``integer quotient'') is such a
|
|
common operation, Calc provides a special command for that purpose, the
|
|
backslash @kbd{\}. Another common arithmetic operator is @kbd{%}, which
|
|
computes the remainder that would arise from a @kbd{\} operation, i.e.,
|
|
the ``modulo'' of two numbers. For example,
|
|
|
|
@smallexample
|
|
@group
|
|
2: 1234 1: 12 2: 1234 1: 34
|
|
1: 100 . 1: 100 .
|
|
. .
|
|
|
|
1234 @key{RET} 100 \ U %
|
|
@end group
|
|
@end smallexample
|
|
|
|
These commands actually work for any real numbers, not just integers.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 3.1415 1: 3 2: 3.1415 1: 0.1415
|
|
1: 1 . 1: 1 .
|
|
. .
|
|
|
|
3.1415 @key{RET} 1 \ U %
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 1.} The @kbd{\} command would appear to be a
|
|
frill, since you could always do the same thing with @kbd{/ F}. Think
|
|
of a situation where this is not true---@kbd{/ F} would be inadequate.
|
|
Now think of a way you could get around the problem if Calc didn't
|
|
provide a @kbd{\} command. @xref{Arithmetic Answer 1, 1}. (@bullet{})
|
|
|
|
We've already seen the @kbd{Q} (square root) and @kbd{S} (sine)
|
|
commands. Other commands along those lines are @kbd{C} (cosine),
|
|
@kbd{T} (tangent), @kbd{E} (@expr{e^x}) and @kbd{L} (natural
|
|
logarithm). These can be modified by the @kbd{I} (inverse) and
|
|
@kbd{H} (hyperbolic) prefix keys.
|
|
|
|
Let's compute the sine and cosine of an angle, and verify the
|
|
identity
|
|
@texline @math{\sin^2x + \cos^2x = 1}.
|
|
@infoline @expr{sin(x)^2 + cos(x)^2 = 1}.
|
|
We'll arbitrarily pick @mathit{-64} degrees as a good value for @expr{x}.
|
|
With the angular mode set to degrees (type @w{@kbd{m d}}), do:
|
|
|
|
@smallexample
|
|
@group
|
|
2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
|
|
1: -64 1: -0.89879 1: -64 1: 0.43837 .
|
|
. . . .
|
|
|
|
64 n @key{RET} @key{RET} S @key{TAB} C f h
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(For brevity, we're showing only five digits of the results here.
|
|
You can of course do these calculations to any precision you like.)
|
|
|
|
Remember, @kbd{f h} is the @code{calc-hypot}, or square-root of sum
|
|
of squares, command.
|
|
|
|
Another identity is
|
|
@texline @math{\displaystyle\tan x = {\sin x \over \cos x}}.
|
|
@infoline @expr{tan(x) = sin(x) / cos(x)}.
|
|
@smallexample
|
|
@group
|
|
|
|
2: -0.89879 1: -2.0503 1: -64.
|
|
1: 0.43837 . .
|
|
.
|
|
|
|
U / I T
|
|
@end group
|
|
@end smallexample
|
|
|
|
A physical interpretation of this calculation is that if you move
|
|
@expr{0.89879} units downward and @expr{0.43837} units to the right,
|
|
your direction of motion is @mathit{-64} degrees from horizontal. Suppose
|
|
we move in the opposite direction, up and to the left:
|
|
|
|
@smallexample
|
|
@group
|
|
2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
|
|
1: 0.43837 1: -0.43837 . .
|
|
. .
|
|
|
|
U U M-2 n / I T
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
How can the angle be the same? The answer is that the @kbd{/} operation
|
|
loses information about the signs of its inputs. Because the quotient
|
|
is negative, we know exactly one of the inputs was negative, but we
|
|
can't tell which one. There is an @kbd{f T} [@code{arctan2}] function which
|
|
computes the inverse tangent of the quotient of a pair of numbers.
|
|
Since you feed it the two original numbers, it has enough information
|
|
to give you a full 360-degree answer.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
|
|
1: -0.43837 . 2: -0.89879 1: -64. .
|
|
. 1: 0.43837 .
|
|
.
|
|
|
|
U U f T M-@key{RET} M-2 n f T -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The resulting angles differ by 180 degrees; in other words, they
|
|
point in opposite directions, just as we would expect.
|
|
|
|
The @key{META}-@key{RET} we used in the third step is the
|
|
``last-arguments'' command. It is sort of like Undo, except that it
|
|
restores the arguments of the last command to the stack without removing
|
|
the command's result. It is useful in situations like this one,
|
|
where we need to do several operations on the same inputs. We could
|
|
have accomplished the same thing by using @kbd{M-2 @key{RET}} to duplicate
|
|
the top two stack elements right after the @kbd{U U}, then a pair of
|
|
@kbd{M-@key{TAB}} commands to cycle the 116 up around the duplicates.
|
|
|
|
A similar identity is supposed to hold for hyperbolic sines and cosines,
|
|
except that it is the @emph{difference}
|
|
@texline @math{\cosh^2x - \sinh^2x}
|
|
@infoline @expr{cosh(x)^2 - sinh(x)^2}
|
|
that always equals one. Let's try to verify this identity.
|
|
|
|
@smallexample
|
|
@group
|
|
2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
|
|
1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
|
|
. . . . .
|
|
|
|
64 n @key{RET} @key{RET} H C 2 ^ @key{TAB} H S 2 ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
@cindex Roundoff errors, examples
|
|
Something's obviously wrong, because when we subtract these numbers
|
|
the answer will clearly be zero! But if you think about it, if these
|
|
numbers @emph{did} differ by one, it would be in the 55th decimal
|
|
place. The difference we seek has been lost entirely to roundoff
|
|
error.
|
|
|
|
We could verify this hypothesis by doing the actual calculation with,
|
|
say, 60 decimal places of precision. This will be slow, but not
|
|
enormously so. Try it if you wish; sure enough, the answer is
|
|
0.99999, reasonably close to 1.
|
|
|
|
Of course, a more reasonable way to verify the identity is to use
|
|
a more reasonable value for @expr{x}!
|
|
|
|
@cindex Common logarithm
|
|
Some Calculator commands use the Hyperbolic prefix for other purposes.
|
|
The logarithm and exponential functions, for example, work to the base
|
|
@expr{e} normally but use base-10 instead if you use the Hyperbolic
|
|
prefix.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1000 1: 6.9077 1: 1000 1: 3
|
|
. . . .
|
|
|
|
1000 L U H L
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First, we mistakenly compute a natural logarithm. Then we undo
|
|
and compute a common logarithm instead.
|
|
|
|
The @kbd{B} key computes a general base-@var{b} logarithm for any
|
|
value of @var{b}.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
|
|
1: 10 . . 1: 2.71828 .
|
|
. .
|
|
|
|
1000 @key{RET} 10 B H E H P B
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we first use @kbd{B} to compute the base-10 logarithm, then use
|
|
the ``hyperbolic'' exponential as a cheap hack to recover the number
|
|
1000, then use @kbd{B} again to compute the natural logarithm. Note
|
|
that @kbd{P} with the hyperbolic prefix pushes the constant @expr{e}
|
|
onto the stack.
|
|
|
|
You may have noticed that both times we took the base-10 logarithm
|
|
of 1000, we got an exact integer result. Calc always tries to give
|
|
an exact rational result for calculations involving rational numbers
|
|
where possible. But when we used @kbd{H E}, the result was a
|
|
floating-point number for no apparent reason. In fact, if we had
|
|
computed @kbd{10 @key{RET} 3 ^} we @emph{would} have gotten an
|
|
exact integer 1000. But the @kbd{H E} command is rigged to generate
|
|
a floating-point result all of the time so that @kbd{1000 H E} will
|
|
not waste time computing a thousand-digit integer when all you
|
|
probably wanted was @samp{1e1000}.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Find a pair of integer inputs to
|
|
the @kbd{B} command for which Calc could find an exact rational
|
|
result but doesn't. @xref{Arithmetic Answer 2, 2}. (@bullet{})
|
|
|
|
The Calculator also has a set of functions relating to combinatorics
|
|
and statistics. You may be familiar with the @dfn{factorial} function,
|
|
which computes the product of all the integers up to a given number.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
|
|
. . . .
|
|
|
|
100 ! U c f !
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Recall, the @kbd{c f} command converts the integer or fraction at the
|
|
top of the stack to floating-point format. If you take the factorial
|
|
of a floating-point number, you get a floating-point result
|
|
accurate to the current precision. But if you give @kbd{!} an
|
|
exact integer, you get an exact integer result (158 digits long
|
|
in this case).
|
|
|
|
If you take the factorial of a non-integer, Calc uses a generalized
|
|
factorial function defined in terms of Euler's Gamma function
|
|
@texline @math{\Gamma(n)}
|
|
@infoline @expr{gamma(n)}
|
|
(which is itself available as the @kbd{f g} command).
|
|
|
|
@smallexample
|
|
@group
|
|
3: 4. 3: 24. 1: 5.5 1: 52.342777847
|
|
2: 4.5 2: 52.3427777847 . .
|
|
1: 5. 1: 120.
|
|
. .
|
|
|
|
M-3 ! M-0 @key{DEL} 5.5 f g
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we verify the identity
|
|
@texline @math{n! = \Gamma(n+1)}.
|
|
@infoline @expr{@var{n}!@: = gamma(@var{n}+1)}.
|
|
|
|
The binomial coefficient @var{n}-choose-@var{m}
|
|
@texline or @math{\displaystyle {n \choose m}}
|
|
is defined by
|
|
@texline @math{\displaystyle {n! \over m! \, (n-m)!}}
|
|
@infoline @expr{n!@: / m!@: (n-m)!}
|
|
for all reals @expr{n} and @expr{m}. The intermediate results in this
|
|
formula can become quite large even if the final result is small; the
|
|
@kbd{k c} command computes a binomial coefficient in a way that avoids
|
|
large intermediate values.
|
|
|
|
The @kbd{k} prefix key defines several common functions out of
|
|
combinatorics and number theory. Here we compute the binomial
|
|
coefficient 30-choose-20, then determine its prime factorization.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
|
|
1: 20 . .
|
|
.
|
|
|
|
30 @key{RET} 20 k c k f
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
You can verify these prime factors by using @kbd{v u} to ``unpack''
|
|
this vector into 8 separate stack entries, then @kbd{M-8 *} to
|
|
multiply them back together. The result is the original number,
|
|
30045015.
|
|
|
|
@cindex Hash tables
|
|
Suppose a program you are writing needs a hash table with at least
|
|
10000 entries. It's best to use a prime number as the actual size
|
|
of a hash table. Calc can compute the next prime number after 10000:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10000 1: 10007 1: 9973
|
|
. . .
|
|
|
|
10000 k n I k n
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Just for kicks we've also computed the next prime @emph{less} than
|
|
10000.
|
|
|
|
@c [fix-ref Financial Functions]
|
|
@xref{Financial Functions}, for a description of the Calculator
|
|
commands that deal with business and financial calculations (functions
|
|
like @code{pv}, @code{rate}, and @code{sln}).
|
|
|
|
@c [fix-ref Binary Number Functions]
|
|
@xref{Binary Functions}, to read about the commands for operating
|
|
on binary numbers (like @code{and}, @code{xor}, and @code{lsh}).
|
|
|
|
@node Vector/Matrix Tutorial, Types Tutorial, Arithmetic Tutorial, Tutorial
|
|
@section Vector/Matrix Tutorial
|
|
|
|
@noindent
|
|
A @dfn{vector} is a list of numbers or other Calc data objects.
|
|
Calc provides a large set of commands that operate on vectors. Some
|
|
are familiar operations from vector analysis. Others simply treat
|
|
a vector as a list of objects.
|
|
|
|
@menu
|
|
* Vector Analysis Tutorial::
|
|
* Matrix Tutorial::
|
|
* List Tutorial::
|
|
@end menu
|
|
|
|
@node Vector Analysis Tutorial, Matrix Tutorial, Vector/Matrix Tutorial, Vector/Matrix Tutorial
|
|
@subsection Vector Analysis
|
|
|
|
@noindent
|
|
If you add two vectors, the result is a vector of the sums of the
|
|
elements, taken pairwise.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3] 2: [1, 2, 3] 1: [8, 8, 3]
|
|
. 1: [7, 6, 0] .
|
|
.
|
|
|
|
[1,2,3] s 1 [7 6 0] s 2 +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that we can separate the vector elements with either commas or
|
|
spaces. This is true whether we are using incomplete vectors or
|
|
algebraic entry. The @kbd{s 1} and @kbd{s 2} commands save these
|
|
vectors so we can easily reuse them later.
|
|
|
|
If you multiply two vectors, the result is the sum of the products
|
|
of the elements taken pairwise. This is called the @dfn{dot product}
|
|
of the vectors.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 3] 1: 19
|
|
1: [7, 6, 0] .
|
|
.
|
|
|
|
r 1 r 2 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Dot product
|
|
The dot product of two vectors is equal to the product of their
|
|
lengths times the cosine of the angle between them. (Here the vector
|
|
is interpreted as a line from the origin @expr{(0,0,0)} to the
|
|
specified point in three-dimensional space.) The @kbd{A}
|
|
(absolute value) command can be used to compute the length of a
|
|
vector.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 19 3: 19 1: 0.550782 1: 56.579
|
|
2: [1, 2, 3] 2: 3.741657 . .
|
|
1: [7, 6, 0] 1: 9.219544
|
|
. .
|
|
|
|
M-@key{RET} M-2 A * / I C
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we recall the arguments to the dot product command, then
|
|
we compute the absolute values of the top two stack entries to
|
|
obtain the lengths of the vectors, then we divide the dot product
|
|
by the product of the lengths to get the cosine of the angle.
|
|
The inverse cosine finds that the angle between the vectors
|
|
is about 56 degrees.
|
|
|
|
@cindex Cross product
|
|
@cindex Perpendicular vectors
|
|
The @dfn{cross product} of two vectors is a vector whose length
|
|
is the product of the lengths of the inputs times the sine of the
|
|
angle between them, and whose direction is perpendicular to both
|
|
input vectors. Unlike the dot product, the cross product is
|
|
defined only for three-dimensional vectors. Let's double-check
|
|
our computation of the angle using the cross product.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 3] 3: [-18, 21, -8] 1: [-0.52, 0.61, -0.23] 1: 56.579
|
|
1: [7, 6, 0] 2: [1, 2, 3] . .
|
|
. 1: [7, 6, 0]
|
|
.
|
|
|
|
r 1 r 2 V C s 3 M-@key{RET} M-2 A * / A I S
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we recall the original vectors and compute their cross product,
|
|
which we also store for later reference. Now we divide the vector
|
|
by the product of the lengths of the original vectors. The length of
|
|
this vector should be the sine of the angle; sure enough, it is!
|
|
|
|
@c [fix-ref General Mode Commands]
|
|
Vector-related commands generally begin with the @kbd{v} prefix key.
|
|
Some are uppercase letters and some are lowercase. To make it easier
|
|
to type these commands, the shift-@kbd{V} prefix key acts the same as
|
|
the @kbd{v} key. (@xref{General Mode Commands}, for a way to make all
|
|
prefix keys have this property.)
|
|
|
|
If we take the dot product of two perpendicular vectors we expect
|
|
to get zero, since the cosine of 90 degrees is zero. Let's check
|
|
that the cross product is indeed perpendicular to both inputs:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 3] 1: 0 2: [7, 6, 0] 1: 0
|
|
1: [-18, 21, -8] . 1: [-18, 21, -8] .
|
|
. .
|
|
|
|
r 1 r 3 * @key{DEL} r 2 r 3 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Normalizing a vector
|
|
@cindex Unit vectors
|
|
(@bullet{}) @strong{Exercise 1.} Given a vector on the top of the
|
|
stack, what keystrokes would you use to @dfn{normalize} the
|
|
vector, i.e., to reduce its length to one without changing its
|
|
direction? @xref{Vector Answer 1, 1}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Suppose a certain particle can be
|
|
at any of several positions along a ruler. You have a list of
|
|
those positions in the form of a vector, and another list of the
|
|
probabilities for the particle to be at the corresponding positions.
|
|
Find the average position of the particle.
|
|
@xref{Vector Answer 2, 2}. (@bullet{})
|
|
|
|
@node Matrix Tutorial, List Tutorial, Vector Analysis Tutorial, Vector/Matrix Tutorial
|
|
@subsection Matrices
|
|
|
|
@noindent
|
|
A @dfn{matrix} is just a vector of vectors, all the same length.
|
|
This means you can enter a matrix using nested brackets. You can
|
|
also use the semicolon character to enter a matrix. We'll show
|
|
both methods here:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
|
|
[ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
|
|
. .
|
|
|
|
[[1 2 3] [4 5 6]] ' [1 2 3; 4 5 6] @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We'll be using this matrix again, so type @kbd{s 4} to save it now.
|
|
|
|
Note that semicolons work with incomplete vectors, but they work
|
|
better in algebraic entry. That's why we use the apostrophe in
|
|
the second example.
|
|
|
|
When two matrices are multiplied, the lefthand matrix must have
|
|
the same number of columns as the righthand matrix has rows.
|
|
Row @expr{i}, column @expr{j} of the result is effectively the
|
|
dot product of row @expr{i} of the left matrix by column @expr{j}
|
|
of the right matrix.
|
|
|
|
If we try to duplicate this matrix and multiply it by itself,
|
|
the dimensions are wrong and the multiplication cannot take place:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1, 2, 3 ] * [ [ 1, 2, 3 ]
|
|
[ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
|
|
.
|
|
|
|
@key{RET} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Though rather hard to read, this is a formula which shows the product
|
|
of two matrices. The @samp{*} function, having invalid arguments, has
|
|
been left in symbolic form.
|
|
|
|
We can multiply the matrices if we @dfn{transpose} one of them first.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ [ 1, 2, 3 ] 1: [ [ 14, 32 ] 1: [ [ 17, 22, 27 ]
|
|
[ 4, 5, 6 ] ] [ 32, 77 ] ] [ 22, 29, 36 ]
|
|
1: [ [ 1, 4 ] . [ 27, 36, 45 ] ]
|
|
[ 2, 5 ] .
|
|
[ 3, 6 ] ]
|
|
.
|
|
|
|
U v t * U @key{TAB} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
Matrix multiplication is not commutative; indeed, switching the
|
|
order of the operands can even change the dimensions of the result
|
|
matrix, as happened here!
|
|
|
|
If you multiply a plain vector by a matrix, it is treated as a
|
|
single row or column depending on which side of the matrix it is
|
|
on. The result is a plain vector which should also be interpreted
|
|
as a row or column as appropriate.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ [ 1, 2, 3 ] 1: [14, 32]
|
|
[ 4, 5, 6 ] ] .
|
|
1: [1, 2, 3]
|
|
.
|
|
|
|
r 4 r 1 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
Multiplying in the other order wouldn't work because the number of
|
|
rows in the matrix is different from the number of elements in the
|
|
vector.
|
|
|
|
(@bullet{}) @strong{Exercise 1.} Use @samp{*} to sum along the rows
|
|
of the above
|
|
@texline @math{2\times3}
|
|
@infoline 2x3
|
|
matrix to get @expr{[6, 15]}. Now use @samp{*} to sum along the columns
|
|
to get @expr{[5, 7, 9]}.
|
|
@xref{Matrix Answer 1, 1}. (@bullet{})
|
|
|
|
@cindex Identity matrix
|
|
An @dfn{identity matrix} is a square matrix with ones along the
|
|
diagonal and zeros elsewhere. It has the property that multiplication
|
|
by an identity matrix, on the left or on the right, always produces
|
|
the original matrix.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1, 2, 3 ] 2: [ [ 1, 2, 3 ] 1: [ [ 1, 2, 3 ]
|
|
[ 4, 5, 6 ] ] [ 4, 5, 6 ] ] [ 4, 5, 6 ] ]
|
|
. 1: [ [ 1, 0, 0 ] .
|
|
[ 0, 1, 0 ]
|
|
[ 0, 0, 1 ] ]
|
|
.
|
|
|
|
r 4 v i 3 @key{RET} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
If a matrix is square, it is often possible to find its @dfn{inverse},
|
|
that is, a matrix which, when multiplied by the original matrix, yields
|
|
an identity matrix. The @kbd{&} (reciprocal) key also computes the
|
|
inverse of a matrix.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1, 2, 3 ] 1: [ [ -2.4, 1.2, -0.2 ]
|
|
[ 4, 5, 6 ] [ 2.8, -1.4, 0.4 ]
|
|
[ 7, 6, 0 ] ] [ -0.73333, 0.53333, -0.2 ] ]
|
|
. .
|
|
|
|
r 4 r 2 | s 5 &
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The vertical bar @kbd{|} @dfn{concatenates} numbers, vectors, and
|
|
matrices together. Here we have used it to add a new row onto
|
|
our matrix to make it square.
|
|
|
|
We can multiply these two matrices in either order to get an identity.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1., 0., 0. ] 1: [ [ 1., 0., 0. ]
|
|
[ 0., 1., 0. ] [ 0., 1., 0. ]
|
|
[ 0., 0., 1. ] ] [ 0., 0., 1. ] ]
|
|
. .
|
|
|
|
M-@key{RET} * U @key{TAB} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Systems of linear equations
|
|
@cindex Linear equations, systems of
|
|
Matrix inverses are related to systems of linear equations in algebra.
|
|
Suppose we had the following set of equations:
|
|
|
|
@ifinfo
|
|
@group
|
|
@example
|
|
a + 2b + 3c = 6
|
|
4a + 5b + 6c = 2
|
|
7a + 6b = 3
|
|
@end example
|
|
@end group
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplayh
|
|
$$ \openup1\jot \tabskip=0pt plus1fil
|
|
\halign to\displaywidth{\tabskip=0pt
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
|
|
a&+&2b&+&3c&=6 \cr
|
|
4a&+&5b&+&6c&=2 \cr
|
|
7a&+&6b& & &=3 \cr}
|
|
$$
|
|
\afterdisplayh
|
|
@end tex
|
|
|
|
@noindent
|
|
This can be cast into the matrix equation,
|
|
|
|
@ifinfo
|
|
@group
|
|
@example
|
|
[ [ 1, 2, 3 ] [ [ a ] [ [ 6 ]
|
|
[ 4, 5, 6 ] * [ b ] = [ 2 ]
|
|
[ 7, 6, 0 ] ] [ c ] ] [ 3 ] ]
|
|
@end example
|
|
@end group
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \pmatrix{ 1 & 2 & 3 \cr 4 & 5 & 6 \cr 7 & 6 & 0 }
|
|
\times
|
|
\pmatrix{ a \cr b \cr c } = \pmatrix{ 6 \cr 2 \cr 3 }
|
|
$$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
We can solve this system of equations by multiplying both sides by the
|
|
inverse of the matrix. Calc can do this all in one step:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [6, 2, 3] 1: [-12.6, 15.2, -3.93333]
|
|
1: [ [ 1, 2, 3 ] .
|
|
[ 4, 5, 6 ]
|
|
[ 7, 6, 0 ] ]
|
|
.
|
|
|
|
[6,2,3] r 5 /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The result is the @expr{[a, b, c]} vector that solves the equations.
|
|
(Dividing by a square matrix is equivalent to multiplying by its
|
|
inverse.)
|
|
|
|
Let's verify this solution:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ [ 1, 2, 3 ] 1: [6., 2., 3.]
|
|
[ 4, 5, 6 ] .
|
|
[ 7, 6, 0 ] ]
|
|
1: [-12.6, 15.2, -3.93333]
|
|
.
|
|
|
|
r 5 @key{TAB} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that we had to be careful about the order in which we multiplied
|
|
the matrix and vector. If we multiplied in the other order, Calc would
|
|
assume the vector was a row vector in order to make the dimensions
|
|
come out right, and the answer would be incorrect. If you
|
|
don't feel safe letting Calc take either interpretation of your
|
|
vectors, use explicit
|
|
@texline @math{N\times1}
|
|
@infoline Nx1
|
|
or
|
|
@texline @math{1\times N}
|
|
@infoline 1xN
|
|
matrices instead. In this case, you would enter the original column
|
|
vector as @samp{[[6], [2], [3]]} or @samp{[6; 2; 3]}.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Algebraic entry allows you to make
|
|
vectors and matrices that include variables. Solve the following
|
|
system of equations to get expressions for @expr{x} and @expr{y}
|
|
in terms of @expr{a} and @expr{b}.
|
|
|
|
@ifinfo
|
|
@group
|
|
@example
|
|
x + a y = 6
|
|
x + b y = 10
|
|
@end example
|
|
@end group
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \eqalign{ x &+ a y = 6 \cr
|
|
x &+ b y = 10}
|
|
$$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
@xref{Matrix Answer 2, 2}. (@bullet{})
|
|
|
|
@cindex Least-squares for over-determined systems
|
|
@cindex Over-determined systems of equations
|
|
(@bullet{}) @strong{Exercise 3.} A system of equations is ``over-determined''
|
|
if it has more equations than variables. It is often the case that
|
|
there are no values for the variables that will satisfy all the
|
|
equations at once, but it is still useful to find a set of values
|
|
which ``nearly'' satisfy all the equations. In terms of matrix equations,
|
|
you can't solve @expr{A X = B} directly because the matrix @expr{A}
|
|
is not square for an over-determined system. Matrix inversion works
|
|
only for square matrices. One common trick is to multiply both sides
|
|
on the left by the transpose of @expr{A}:
|
|
@ifinfo
|
|
@samp{trn(A)*A*X = trn(A)*B}.
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
$A^T A \, X = A^T B$, where $A^T$ is the transpose \samp{trn(A)}.
|
|
@end tex
|
|
Now
|
|
@texline @math{A^T A}
|
|
@infoline @expr{trn(A)*A}
|
|
is a square matrix so a solution is possible. It turns out that the
|
|
@expr{X} vector you compute in this way will be a ``least-squares''
|
|
solution, which can be regarded as the ``closest'' solution to the set
|
|
of equations. Use Calc to solve the following over-determined
|
|
system:
|
|
|
|
@ifinfo
|
|
@group
|
|
@example
|
|
a + 2b + 3c = 6
|
|
4a + 5b + 6c = 2
|
|
7a + 6b = 3
|
|
2a + 4b + 6c = 11
|
|
@end example
|
|
@end group
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplayh
|
|
$$ \openup1\jot \tabskip=0pt plus1fil
|
|
\halign to\displaywidth{\tabskip=0pt
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
|
|
a&+&2b&+&3c&=6 \cr
|
|
4a&+&5b&+&6c&=2 \cr
|
|
7a&+&6b& & &=3 \cr
|
|
2a&+&4b&+&6c&=11 \cr}
|
|
$$
|
|
\afterdisplayh
|
|
@end tex
|
|
|
|
@noindent
|
|
@xref{Matrix Answer 3, 3}. (@bullet{})
|
|
|
|
@node List Tutorial, , Matrix Tutorial, Vector/Matrix Tutorial
|
|
@subsection Vectors as Lists
|
|
|
|
@noindent
|
|
@cindex Lists
|
|
Although Calc has a number of features for manipulating vectors and
|
|
matrices as mathematical objects, you can also treat vectors as
|
|
simple lists of values. For example, we saw that the @kbd{k f}
|
|
command returns a vector which is a list of the prime factors of a
|
|
number.
|
|
|
|
You can pack and unpack stack entries into vectors:
|
|
|
|
@smallexample
|
|
@group
|
|
3: 10 1: [10, 20, 30] 3: 10
|
|
2: 20 . 2: 20
|
|
1: 30 1: 30
|
|
. .
|
|
|
|
M-3 v p v u
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can also build vectors out of consecutive integers, or out
|
|
of many copies of a given value:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, 4] 2: [1, 2, 3, 4] 2: [1, 2, 3, 4]
|
|
. 1: 17 1: [17, 17, 17, 17]
|
|
. .
|
|
|
|
v x 4 @key{RET} 17 v b 4 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can apply an operator to every element of a vector using the
|
|
@dfn{map} command.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [17, 34, 51, 68] 1: [289, 1156, 2601, 4624] 1: [17, 34, 51, 68]
|
|
. . .
|
|
|
|
V M * 2 V M ^ V M Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In the first step, we multiply the vector of integers by the vector
|
|
of 17's elementwise. In the second step, we raise each element to
|
|
the power two. (The general rule is that both operands must be
|
|
vectors of the same length, or else one must be a vector and the
|
|
other a plain number.) In the final step, we take the square root
|
|
of each element.
|
|
|
|
(@bullet{}) @strong{Exercise 1.} Compute a vector of powers of two
|
|
from
|
|
@texline @math{2^{-4}}
|
|
@infoline @expr{2^-4}
|
|
to @expr{2^4}. @xref{List Answer 1, 1}. (@bullet{})
|
|
|
|
You can also @dfn{reduce} a binary operator across a vector.
|
|
For example, reducing @samp{*} computes the product of all the
|
|
elements in the vector:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 123123 1: [3, 7, 11, 13, 41] 1: 123123
|
|
. . .
|
|
|
|
123123 k f V R *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In this example, we decompose 123123 into its prime factors, then
|
|
multiply those factors together again to yield the original number.
|
|
|
|
We could compute a dot product ``by hand'' using mapping and
|
|
reduction:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 3] 1: [7, 12, 0] 1: 19
|
|
1: [7, 6, 0] . .
|
|
.
|
|
|
|
r 1 r 2 V M * V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Recalling two vectors from the previous section, we compute the
|
|
sum of pairwise products of the elements to get the same answer
|
|
for the dot product as before.
|
|
|
|
A slight variant of vector reduction is the @dfn{accumulate} operation,
|
|
@kbd{V U}. This produces a vector of the intermediate results from
|
|
a corresponding reduction. Here we compute a table of factorials:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, 4, 5, 6] 1: [1, 2, 6, 24, 120, 720]
|
|
. .
|
|
|
|
v x 6 @key{RET} V U *
|
|
@end group
|
|
@end smallexample
|
|
|
|
Calc allows vectors to grow as large as you like, although it gets
|
|
rather slow if vectors have more than about a hundred elements.
|
|
Actually, most of the time is spent formatting these large vectors
|
|
for display, not calculating on them. Try the following experiment
|
|
(if your computer is very fast you may need to substitute a larger
|
|
vector size).
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, 4, ... 1: [2, 3, 4, 5, ...
|
|
. .
|
|
|
|
v x 500 @key{RET} 1 V M +
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now press @kbd{v .} (the letter @kbd{v}, then a period) and try the
|
|
experiment again. In @kbd{v .} mode, long vectors are displayed
|
|
``abbreviated'' like this:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, ..., 500] 1: [2, 3, 4, ..., 501]
|
|
. .
|
|
|
|
v x 500 @key{RET} 1 V M +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(where now the @samp{...} is actually part of the Calc display).
|
|
You will find both operations are now much faster. But notice that
|
|
even in @w{@kbd{v .}} mode, the full vectors are still shown in the Trail.
|
|
Type @w{@kbd{t .}} to cause the trail to abbreviate as well, and try the
|
|
experiment one more time. Operations on long vectors are now quite
|
|
fast! (But of course if you use @kbd{t .} you will lose the ability
|
|
to get old vectors back using the @kbd{t y} command.)
|
|
|
|
An easy way to view a full vector when @kbd{v .} mode is active is
|
|
to press @kbd{`} (back-quote) to edit the vector; editing always works
|
|
with the full, unabbreviated value.
|
|
|
|
@cindex Least-squares for fitting a straight line
|
|
@cindex Fitting data to a line
|
|
@cindex Line, fitting data to
|
|
@cindex Data, extracting from buffers
|
|
@cindex Columns of data, extracting
|
|
As a larger example, let's try to fit a straight line to some data,
|
|
using the method of least squares. (Calc has a built-in command for
|
|
least-squares curve fitting, but we'll do it by hand here just to
|
|
practice working with vectors.) Suppose we have the following list
|
|
of values in a file we have loaded into Emacs:
|
|
|
|
@smallexample
|
|
x y
|
|
--- ---
|
|
1.34 0.234
|
|
1.41 0.298
|
|
1.49 0.402
|
|
1.56 0.412
|
|
1.64 0.466
|
|
1.73 0.473
|
|
1.82 0.601
|
|
1.91 0.519
|
|
2.01 0.603
|
|
2.11 0.637
|
|
2.22 0.645
|
|
2.33 0.705
|
|
2.45 0.917
|
|
2.58 1.009
|
|
2.71 0.971
|
|
2.85 1.062
|
|
3.00 1.148
|
|
3.15 1.157
|
|
3.32 1.354
|
|
@end smallexample
|
|
|
|
@noindent
|
|
If you are reading this tutorial in printed form, you will find it
|
|
easiest to press @kbd{C-x * i} to enter the on-line Info version of
|
|
the manual and find this table there. (Press @kbd{g}, then type
|
|
@kbd{List Tutorial}, to jump straight to this section.)
|
|
|
|
Position the cursor at the upper-left corner of this table, just
|
|
to the left of the @expr{1.34}. Press @kbd{C-@@} to set the mark.
|
|
(On your system this may be @kbd{C-2}, @kbd{C-@key{SPC}}, or @kbd{NUL}.)
|
|
Now position the cursor to the lower-right, just after the @expr{1.354}.
|
|
You have now defined this region as an Emacs ``rectangle.'' Still
|
|
in the Info buffer, type @kbd{C-x * r}. This command
|
|
(@code{calc-grab-rectangle}) will pop you back into the Calculator, with
|
|
the contents of the rectangle you specified in the form of a matrix.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1.34, 0.234 ]
|
|
[ 1.41, 0.298 ]
|
|
@dots{}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(You may wish to use @kbd{v .} mode to abbreviate the display of this
|
|
large matrix.)
|
|
|
|
We want to treat this as a pair of lists. The first step is to
|
|
transpose this matrix into a pair of rows. Remember, a matrix is
|
|
just a vector of vectors. So we can unpack the matrix into a pair
|
|
of row vectors on the stack.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1.34, 1.41, 1.49, ... ] 2: [1.34, 1.41, 1.49, ... ]
|
|
[ 0.234, 0.298, 0.402, ... ] ] 1: [0.234, 0.298, 0.402, ... ]
|
|
. .
|
|
|
|
v t v u
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Let's store these in quick variables 1 and 2, respectively.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1.34, 1.41, 1.49, ... ] .
|
|
.
|
|
|
|
t 2 t 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Recall that @kbd{t 2} is a variant of @kbd{s 2} that removes the
|
|
stored value from the stack.)
|
|
|
|
In a least squares fit, the slope @expr{m} is given by the formula
|
|
|
|
@ifinfo
|
|
@example
|
|
m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ m = {N \sum x y - \sum x \sum y \over
|
|
N \sum x^2 - \left( \sum x \right)^2} $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
where
|
|
@texline @math{\sum x}
|
|
@infoline @expr{sum(x)}
|
|
represents the sum of all the values of @expr{x}. While there is an
|
|
actual @code{sum} function in Calc, it's easier to sum a vector using a
|
|
simple reduction. First, let's compute the four different sums that
|
|
this formula uses.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 41.63 1: 98.0003
|
|
. .
|
|
|
|
r 1 V R + t 3 r 1 2 V M ^ V R + t 4
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 13.613 1: 33.36554
|
|
. .
|
|
|
|
r 2 V R + t 5 r 1 r 2 V M * V R + t 6
|
|
@end group
|
|
@end smallexample
|
|
|
|
@ifinfo
|
|
@noindent
|
|
These are @samp{sum(x)}, @samp{sum(x^2)}, @samp{sum(y)}, and @samp{sum(x y)},
|
|
respectively. (We could have used @kbd{*} to compute @samp{sum(x^2)} and
|
|
@samp{sum(x y)}.)
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
These are $\sum x$, $\sum x^2$, $\sum y$, and $\sum x y$,
|
|
respectively. (We could have used \kbd{*} to compute $\sum x^2$ and
|
|
$\sum x y$.)
|
|
@end tex
|
|
|
|
Finally, we also need @expr{N}, the number of data points. This is just
|
|
the length of either of our lists.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 19
|
|
.
|
|
|
|
r 1 v l t 7
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(That's @kbd{v} followed by a lower-case @kbd{l}.)
|
|
|
|
Now we grind through the formula:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 633.94526 2: 633.94526 1: 67.23607
|
|
. 1: 566.70919 .
|
|
.
|
|
|
|
r 7 r 6 * r 3 r 5 * -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: 67.23607 3: 67.23607 2: 67.23607 1: 0.52141679
|
|
1: 1862.0057 2: 1862.0057 1: 128.9488 .
|
|
. 1: 1733.0569 .
|
|
.
|
|
|
|
r 7 r 4 * r 3 2 ^ - / t 8
|
|
@end group
|
|
@end smallexample
|
|
|
|
That gives us the slope @expr{m}. The y-intercept @expr{b} can now
|
|
be found with the simple formula,
|
|
|
|
@ifinfo
|
|
@example
|
|
b = (sum(y) - m sum(x)) / N
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ b = {\sum y - m \sum x \over N} $$
|
|
\afterdisplay
|
|
\vskip10pt
|
|
@end tex
|
|
|
|
@smallexample
|
|
@group
|
|
1: 13.613 2: 13.613 1: -8.09358 1: -0.425978
|
|
. 1: 21.70658 . .
|
|
.
|
|
|
|
r 5 r 8 r 3 * - r 7 / t 9
|
|
@end group
|
|
@end smallexample
|
|
|
|
Let's ``plot'' this straight line approximation,
|
|
@texline @math{y \approx m x + b},
|
|
@infoline @expr{m x + b},
|
|
and compare it with the original data.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.699, 0.735, ... ] 1: [0.273, 0.309, ... ]
|
|
. .
|
|
|
|
r 1 r 8 * r 9 + s 0
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice that multiplying a vector by a constant, and adding a constant
|
|
to a vector, can be done without mapping commands since these are
|
|
common operations from vector algebra. As far as Calc is concerned,
|
|
we've just been doing geometry in 19-dimensional space!
|
|
|
|
We can subtract this vector from our original @expr{y} vector to get
|
|
a feel for the error of our fit. Let's find the maximum error:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.0387, 0.0112, ... ] 1: [0.0387, 0.0112, ... ] 1: 0.0897
|
|
. . .
|
|
|
|
r 2 - V M A V R X
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we compute a vector of differences, then we take the absolute
|
|
values of these differences, then we reduce the @code{max} function
|
|
across the vector. (The @code{max} function is on the two-key sequence
|
|
@kbd{f x}; because it is so common to use @code{max} in a vector
|
|
operation, the letters @kbd{X} and @kbd{N} are also accepted for
|
|
@code{max} and @code{min} in this context. In general, you answer
|
|
the @kbd{V M} or @kbd{V R} prompt with the actual key sequence that
|
|
invokes the function you want. You could have typed @kbd{V R f x} or
|
|
even @kbd{V R x max @key{RET}} if you had preferred.)
|
|
|
|
If your system has the GNUPLOT program, you can see graphs of your
|
|
data and your straight line to see how well they match. (If you have
|
|
GNUPLOT 3.0 or higher, the following instructions will work regardless
|
|
of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems
|
|
may require additional steps to view the graphs.)
|
|
|
|
Let's start by plotting the original data. Recall the ``@var{x}'' and ``@var{y}''
|
|
vectors onto the stack and press @kbd{g f}. This ``fast'' graphing
|
|
command does everything you need to do for simple, straightforward
|
|
plotting of data.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1.34, 1.41, 1.49, ... ]
|
|
1: [0.234, 0.298, 0.402, ... ]
|
|
.
|
|
|
|
r 1 r 2 g f
|
|
@end group
|
|
@end smallexample
|
|
|
|
If all goes well, you will shortly get a new window containing a graph
|
|
of the data. (If not, contact your GNUPLOT or Calc installer to find
|
|
out what went wrong.) In the X window system, this will be a separate
|
|
graphics window. For other kinds of displays, the default is to
|
|
display the graph in Emacs itself using rough character graphics.
|
|
Press @kbd{q} when you are done viewing the character graphics.
|
|
|
|
Next, let's add the line we got from our least-squares fit.
|
|
@ifinfo
|
|
(If you are reading this tutorial on-line while running Calc, typing
|
|
@kbd{g a} may cause the tutorial to disappear from its window and be
|
|
replaced by a buffer named @samp{*Gnuplot Commands*}. The tutorial
|
|
will reappear when you terminate GNUPLOT by typing @kbd{g q}.)
|
|
@end ifinfo
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1.34, 1.41, 1.49, ... ]
|
|
1: [0.273, 0.309, 0.351, ... ]
|
|
.
|
|
|
|
@key{DEL} r 0 g a g p
|
|
@end group
|
|
@end smallexample
|
|
|
|
It's not very useful to get symbols to mark the data points on this
|
|
second curve; you can type @kbd{g S g p} to remove them. Type @kbd{g q}
|
|
when you are done to remove the X graphics window and terminate GNUPLOT.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} An earlier exercise showed how to do
|
|
least squares fitting to a general system of equations. Our 19 data
|
|
points are really 19 equations of the form @expr{y_i = m x_i + b} for
|
|
different pairs of @expr{(x_i,y_i)}. Use the matrix-transpose method
|
|
to solve for @expr{m} and @expr{b}, duplicating the above result.
|
|
@xref{List Answer 2, 2}. (@bullet{})
|
|
|
|
@cindex Geometric mean
|
|
(@bullet{}) @strong{Exercise 3.} If the input data do not form a
|
|
rectangle, you can use @w{@kbd{C-x * g}} (@code{calc-grab-region})
|
|
to grab the data the way Emacs normally works with regions---it reads
|
|
left-to-right, top-to-bottom, treating line breaks the same as spaces.
|
|
Use this command to find the geometric mean of the following numbers.
|
|
(The geometric mean is the @var{n}th root of the product of @var{n} numbers.)
|
|
|
|
@example
|
|
2.3 6 22 15.1 7
|
|
15 14 7.5
|
|
2.5
|
|
@end example
|
|
|
|
@noindent
|
|
The @kbd{C-x * g} command accepts numbers separated by spaces or commas,
|
|
with or without surrounding vector brackets.
|
|
@xref{List Answer 3, 3}. (@bullet{})
|
|
|
|
@ifinfo
|
|
As another example, a theorem about binomial coefficients tells
|
|
us that the alternating sum of binomial coefficients
|
|
@var{n}-choose-0 minus @var{n}-choose-1 plus @var{n}-choose-2, and so
|
|
on up to @var{n}-choose-@var{n},
|
|
always comes out to zero. Let's verify this
|
|
for @expr{n=6}.
|
|
@end ifinfo
|
|
@tex
|
|
As another example, a theorem about binomial coefficients tells
|
|
us that the alternating sum of binomial coefficients
|
|
${n \choose 0} - {n \choose 1} + {n \choose 2} - \cdots \pm {n \choose n}$
|
|
always comes out to zero. Let's verify this
|
|
for \cite{n=6}.
|
|
@end tex
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, 4, 5, 6, 7] 1: [0, 1, 2, 3, 4, 5, 6]
|
|
. .
|
|
|
|
v x 7 @key{RET} 1 -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [1, -6, 15, -20, 15, -6, 1] 1: 0
|
|
. .
|
|
|
|
V M ' (-1)^$ choose(6,$) @key{RET} V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
The @kbd{V M '} command prompts you to enter any algebraic expression
|
|
to define the function to map over the vector. The symbol @samp{$}
|
|
inside this expression represents the argument to the function.
|
|
The Calculator applies this formula to each element of the vector,
|
|
substituting each element's value for the @samp{$} sign(s) in turn.
|
|
|
|
To define a two-argument function, use @samp{$$} for the first
|
|
argument and @samp{$} for the second: @kbd{V M ' $$-$ @key{RET}} is
|
|
equivalent to @kbd{V M -}. This is analogous to regular algebraic
|
|
entry, where @samp{$$} would refer to the next-to-top stack entry
|
|
and @samp{$} would refer to the top stack entry, and @kbd{' $$-$ @key{RET}}
|
|
would act exactly like @kbd{-}.
|
|
|
|
Notice that the @kbd{V M '} command has recorded two things in the
|
|
trail: The result, as usual, and also a funny-looking thing marked
|
|
@samp{oper} that represents the operator function you typed in.
|
|
The function is enclosed in @samp{< >} brackets, and the argument is
|
|
denoted by a @samp{#} sign. If there were several arguments, they
|
|
would be shown as @samp{#1}, @samp{#2}, and so on. (For example,
|
|
@kbd{V M ' $$-$} will put the function @samp{<#1 - #2>} on the
|
|
trail.) This object is a ``nameless function''; you can use nameless
|
|
@w{@samp{< >}} notation to answer the @kbd{V M '} prompt if you like.
|
|
Nameless function notation has the interesting, occasionally useful
|
|
property that a nameless function is not actually evaluated until
|
|
it is used. For example, @kbd{V M ' $+random(2.0)} evaluates
|
|
@samp{random(2.0)} once and adds that random number to all elements
|
|
of the vector, but @kbd{V M ' <#+random(2.0)>} evaluates the
|
|
@samp{random(2.0)} separately for each vector element.
|
|
|
|
Another group of operators that are often useful with @kbd{V M} are
|
|
the relational operators: @kbd{a =}, for example, compares two numbers
|
|
and gives the result 1 if they are equal, or 0 if not. Similarly,
|
|
@w{@kbd{a <}} checks for one number being less than another.
|
|
|
|
Other useful vector operations include @kbd{v v}, to reverse a
|
|
vector end-for-end; @kbd{V S}, to sort the elements of a vector
|
|
into increasing order; and @kbd{v r} and @w{@kbd{v c}}, to extract
|
|
one row or column of a matrix, or (in both cases) to extract one
|
|
element of a plain vector. With a negative argument, @kbd{v r}
|
|
and @kbd{v c} instead delete one row, column, or vector element.
|
|
|
|
@cindex Divisor functions
|
|
(@bullet{}) @strong{Exercise 4.} The @expr{k}th @dfn{divisor function}
|
|
@tex
|
|
$\sigma_k(n)$
|
|
@end tex
|
|
is the sum of the @expr{k}th powers of all the divisors of an
|
|
integer @expr{n}. Figure out a method for computing the divisor
|
|
function for reasonably small values of @expr{n}. As a test,
|
|
the 0th and 1st divisor functions of 30 are 8 and 72, respectively.
|
|
@xref{List Answer 4, 4}. (@bullet{})
|
|
|
|
@cindex Square-free numbers
|
|
@cindex Duplicate values in a list
|
|
(@bullet{}) @strong{Exercise 5.} The @kbd{k f} command produces a
|
|
list of prime factors for a number. Sometimes it is important to
|
|
know that a number is @dfn{square-free}, i.e., that no prime occurs
|
|
more than once in its list of prime factors. Find a sequence of
|
|
keystrokes to tell if a number is square-free; your method should
|
|
leave 1 on the stack if it is, or 0 if it isn't.
|
|
@xref{List Answer 5, 5}. (@bullet{})
|
|
|
|
@cindex Triangular lists
|
|
(@bullet{}) @strong{Exercise 6.} Build a list of lists that looks
|
|
like the following diagram. (You may wish to use the @kbd{v /}
|
|
command to enable multi-line display of vectors.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [1],
|
|
[1, 2],
|
|
[1, 2, 3],
|
|
[1, 2, 3, 4],
|
|
[1, 2, 3, 4, 5],
|
|
[1, 2, 3, 4, 5, 6] ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
@xref{List Answer 6, 6}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 7.} Build the following list of lists.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [0],
|
|
[1, 2],
|
|
[3, 4, 5],
|
|
[6, 7, 8, 9],
|
|
[10, 11, 12, 13, 14],
|
|
[15, 16, 17, 18, 19, 20] ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
@xref{List Answer 7, 7}. (@bullet{})
|
|
|
|
@cindex Maximizing a function over a list of values
|
|
@c [fix-ref Numerical Solutions]
|
|
(@bullet{}) @strong{Exercise 8.} Compute a list of values of Bessel's
|
|
@texline @math{J_1(x)}
|
|
@infoline @expr{J1}
|
|
function @samp{besJ(1,x)} for @expr{x} from 0 to 5 in steps of 0.25.
|
|
Find the value of @expr{x} (from among the above set of values) for
|
|
which @samp{besJ(1,x)} is a maximum. Use an ``automatic'' method,
|
|
i.e., just reading along the list by hand to find the largest value
|
|
is not allowed! (There is an @kbd{a X} command which does this kind
|
|
of thing automatically; @pxref{Numerical Solutions}.)
|
|
@xref{List Answer 8, 8}. (@bullet{})
|
|
|
|
@cindex Digits, vectors of
|
|
(@bullet{}) @strong{Exercise 9.} You are given an integer in the range
|
|
@texline @math{0 \le N < 10^m}
|
|
@infoline @expr{0 <= N < 10^m}
|
|
for @expr{m=12} (i.e., an integer of less than
|
|
twelve digits). Convert this integer into a vector of @expr{m}
|
|
digits, each in the range from 0 to 9. In vector-of-digits notation,
|
|
add one to this integer to produce a vector of @expr{m+1} digits
|
|
(since there could be a carry out of the most significant digit).
|
|
Convert this vector back into a regular integer. A good integer
|
|
to try is 25129925999. @xref{List Answer 9, 9}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 10.} Your friend Joe tried to use
|
|
@kbd{V R a =} to test if all numbers in a list were equal. What
|
|
happened? How would you do this test? @xref{List Answer 10, 10}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 11.} The area of a circle of radius one
|
|
is @cpi{}. The area of the
|
|
@texline @math{2\times2}
|
|
@infoline 2x2
|
|
square that encloses that circle is 4. So if we throw @var{n} darts at
|
|
random points in the square, about @cpiover{4} of them will land inside
|
|
the circle. This gives us an entertaining way to estimate the value of
|
|
@cpi{}. The @w{@kbd{k r}}
|
|
command picks a random number between zero and the value on the stack.
|
|
We could get a random floating-point number between @mathit{-1} and 1 by typing
|
|
@w{@kbd{2.0 k r 1 -}}. Build a vector of 100 random @expr{(x,y)} points in
|
|
this square, then use vector mapping and reduction to count how many
|
|
points lie inside the unit circle. Hint: Use the @kbd{v b} command.
|
|
@xref{List Answer 11, 11}. (@bullet{})
|
|
|
|
@cindex Matchstick problem
|
|
(@bullet{}) @strong{Exercise 12.} The @dfn{matchstick problem} provides
|
|
another way to calculate @cpi{}. Say you have an infinite field
|
|
of vertical lines with a spacing of one inch. Toss a one-inch matchstick
|
|
onto the field. The probability that the matchstick will land crossing
|
|
a line turns out to be
|
|
@texline @math{2/\pi}.
|
|
@infoline @expr{2/pi}.
|
|
Toss 100 matchsticks to estimate @cpi{}. (If you want still more fun,
|
|
the probability that the GCD (@w{@kbd{k g}}) of two large integers is
|
|
one turns out to be
|
|
@texline @math{6/\pi^2}.
|
|
@infoline @expr{6/pi^2}.
|
|
That provides yet another way to estimate @cpi{}.)
|
|
@xref{List Answer 12, 12}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 13.} An algebraic entry of a string in
|
|
double-quote marks, @samp{"hello"}, creates a vector of the numerical
|
|
(ASCII) codes of the characters (here, @expr{[104, 101, 108, 108, 111]}).
|
|
Sometimes it is convenient to compute a @dfn{hash code} of a string,
|
|
which is just an integer that represents the value of that string.
|
|
Two equal strings have the same hash code; two different strings
|
|
@dfn{probably} have different hash codes. (For example, Calc has
|
|
over 400 function names, but Emacs can quickly find the definition for
|
|
any given name because it has sorted the functions into ``buckets'' by
|
|
their hash codes. Sometimes a few names will hash into the same bucket,
|
|
but it is easier to search among a few names than among all the names.)
|
|
One popular hash function is computed as follows: First set @expr{h = 0}.
|
|
Then, for each character from the string in turn, set @expr{h = 3h + c_i}
|
|
where @expr{c_i} is the character's ASCII code. If we have 511 buckets,
|
|
we then take the hash code modulo 511 to get the bucket number. Develop a
|
|
simple command or commands for converting string vectors into hash codes.
|
|
The hash code for @samp{"Testing, 1, 2, 3"} is 1960915098, which modulo
|
|
511 is 121. @xref{List Answer 13, 13}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 14.} The @kbd{H V R} and @kbd{H V U}
|
|
commands do nested function evaluations. @kbd{H V U} takes a starting
|
|
value and a number of steps @var{n} from the stack; it then applies the
|
|
function you give to the starting value 0, 1, 2, up to @var{n} times
|
|
and returns a vector of the results. Use this command to create a
|
|
``random walk'' of 50 steps. Start with the two-dimensional point
|
|
@expr{(0,0)}; then take one step a random distance between @mathit{-1} and 1
|
|
in both @expr{x} and @expr{y}; then take another step, and so on. Use the
|
|
@kbd{g f} command to display this random walk. Now modify your random
|
|
walk to walk a unit distance, but in a random direction, at each step.
|
|
(Hint: The @code{sincos} function returns a vector of the cosine and
|
|
sine of an angle.) @xref{List Answer 14, 14}. (@bullet{})
|
|
|
|
@node Types Tutorial, Algebra Tutorial, Vector/Matrix Tutorial, Tutorial
|
|
@section Types Tutorial
|
|
|
|
@noindent
|
|
Calc understands a variety of data types as well as simple numbers.
|
|
In this section, we'll experiment with each of these types in turn.
|
|
|
|
The numbers we've been using so far have mainly been either @dfn{integers}
|
|
or @dfn{floats}. We saw that floats are usually a good approximation to
|
|
the mathematical concept of real numbers, but they are only approximations
|
|
and are susceptible to roundoff error. Calc also supports @dfn{fractions},
|
|
which can exactly represent any rational number.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3628800 2: 3628800 1: 518400:7 1: 518414:7 1: 7:518414
|
|
. 1: 49 . . .
|
|
.
|
|
|
|
10 ! 49 @key{RET} : 2 + &
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @kbd{:} command divides two integers to get a fraction; @kbd{/}
|
|
would normally divide integers to get a floating-point result.
|
|
Notice we had to type @key{RET} between the @kbd{49} and the @kbd{:}
|
|
since the @kbd{:} would otherwise be interpreted as part of a
|
|
fraction beginning with 49.
|
|
|
|
You can convert between floating-point and fractional format using
|
|
@kbd{c f} and @kbd{c F}:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1.35027217629e-5 1: 7:518414
|
|
. .
|
|
|
|
c f c F
|
|
@end group
|
|
@end smallexample
|
|
|
|
The @kbd{c F} command replaces a floating-point number with the
|
|
``simplest'' fraction whose floating-point representation is the
|
|
same, to within the current precision.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3.14159265359 1: 1146408:364913 1: 3.1416 1: 355:113
|
|
. . . .
|
|
|
|
P c F @key{DEL} p 5 @key{RET} P c F
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 1.} A calculation has produced the
|
|
result 1.26508260337. You suspect it is the square root of the
|
|
product of @cpi{} and some rational number. Is it? (Be sure
|
|
to allow for roundoff error!) @xref{Types Answer 1, 1}. (@bullet{})
|
|
|
|
@dfn{Complex numbers} can be stored in both rectangular and polar form.
|
|
|
|
@smallexample
|
|
@group
|
|
1: -9 1: (0, 3) 1: (3; 90.) 1: (6; 90.) 1: (2.4495; 45.)
|
|
. . . . .
|
|
|
|
9 n Q c p 2 * Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The square root of @mathit{-9} is by default rendered in rectangular form
|
|
(@w{@expr{0 + 3i}}), but we can convert it to polar form (3 with a
|
|
phase angle of 90 degrees). All the usual arithmetic and scientific
|
|
operations are defined on both types of complex numbers.
|
|
|
|
Another generalized kind of number is @dfn{infinity}. Infinity
|
|
isn't really a number, but it can sometimes be treated like one.
|
|
Calc uses the symbol @code{inf} to represent positive infinity,
|
|
i.e., a value greater than any real number. Naturally, you can
|
|
also write @samp{-inf} for minus infinity, a value less than any
|
|
real number. The word @code{inf} can only be input using
|
|
algebraic entry.
|
|
|
|
@smallexample
|
|
@group
|
|
2: inf 2: -inf 2: -inf 2: -inf 1: nan
|
|
1: -17 1: -inf 1: -inf 1: inf .
|
|
. . . .
|
|
|
|
' inf @key{RET} 17 n * @key{RET} 72 + A +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Since infinity is infinitely large, multiplying it by any finite
|
|
number (like @mathit{-17}) has no effect, except that since @mathit{-17}
|
|
is negative, it changes a plus infinity to a minus infinity.
|
|
(``A huge positive number, multiplied by @mathit{-17}, yields a huge
|
|
negative number.'') Adding any finite number to infinity also
|
|
leaves it unchanged. Taking an absolute value gives us plus
|
|
infinity again. Finally, we add this plus infinity to the minus
|
|
infinity we had earlier. If you work it out, you might expect
|
|
the answer to be @mathit{-72} for this. But the 72 has been completely
|
|
lost next to the infinities; by the time we compute @w{@samp{inf - inf}}
|
|
the finite difference between them, if any, is undetectable.
|
|
So we say the result is @dfn{indeterminate}, which Calc writes
|
|
with the symbol @code{nan} (for Not A Number).
|
|
|
|
Dividing by zero is normally treated as an error, but you can get
|
|
Calc to write an answer in terms of infinity by pressing @kbd{m i}
|
|
to turn on Infinite mode.
|
|
|
|
@smallexample
|
|
@group
|
|
3: nan 2: nan 2: nan 2: nan 1: nan
|
|
2: 1 1: 1 / 0 1: uinf 1: uinf .
|
|
1: 0 . . .
|
|
.
|
|
|
|
1 @key{RET} 0 / m i U / 17 n * +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Dividing by zero normally is left unevaluated, but after @kbd{m i}
|
|
it instead gives an infinite result. The answer is actually
|
|
@code{uinf}, ``undirected infinity.'' If you look at a graph of
|
|
@expr{1 / x} around @w{@expr{x = 0}}, you'll see that it goes toward
|
|
plus infinity as you approach zero from above, but toward minus
|
|
infinity as you approach from below. Since we said only @expr{1 / 0},
|
|
Calc knows that the answer is infinite but not in which direction.
|
|
That's what @code{uinf} means. Notice that multiplying @code{uinf}
|
|
by a negative number still leaves plain @code{uinf}; there's no
|
|
point in saying @samp{-uinf} because the sign of @code{uinf} is
|
|
unknown anyway. Finally, we add @code{uinf} to our @code{nan},
|
|
yielding @code{nan} again. It's easy to see that, because
|
|
@code{nan} means ``totally unknown'' while @code{uinf} means
|
|
``unknown sign but known to be infinite,'' the more mysterious
|
|
@code{nan} wins out when it is combined with @code{uinf}, or, for
|
|
that matter, with anything else.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Predict what Calc will answer
|
|
for each of these formulas: @samp{inf / inf}, @samp{exp(inf)},
|
|
@samp{exp(-inf)}, @samp{sqrt(-inf)}, @samp{sqrt(uinf)},
|
|
@samp{abs(uinf)}, @samp{ln(0)}.
|
|
@xref{Types Answer 2, 2}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 3.} We saw that @samp{inf - inf = nan},
|
|
which stands for an unknown value. Can @code{nan} stand for
|
|
a complex number? Can it stand for infinity?
|
|
@xref{Types Answer 3, 3}. (@bullet{})
|
|
|
|
@dfn{HMS forms} represent a value in terms of hours, minutes, and
|
|
seconds.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2@@ 30' 0" 1: 3@@ 30' 0" 2: 3@@ 30' 0" 1: 2.
|
|
. . 1: 1@@ 45' 0." .
|
|
.
|
|
|
|
2@@ 30' @key{RET} 1 + @key{RET} 2 / /
|
|
@end group
|
|
@end smallexample
|
|
|
|
HMS forms can also be used to hold angles in degrees, minutes, and
|
|
seconds.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.5 1: 26.56505 1: 26@@ 33' 54.18" 1: 0.44721
|
|
. . . .
|
|
|
|
0.5 I T c h S
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we convert the inverse tangent of 0.5 to degrees-minutes-seconds
|
|
form, then we take the sine of that angle. Note that the trigonometric
|
|
functions will accept HMS forms directly as input.
|
|
|
|
@cindex Beatles
|
|
(@bullet{}) @strong{Exercise 4.} The Beatles' @emph{Abbey Road} is
|
|
47 minutes and 26 seconds long, and contains 17 songs. What is the
|
|
average length of a song on @emph{Abbey Road}? If the Extended Disco
|
|
Version of @emph{Abbey Road} added 20 seconds to the length of each
|
|
song, how long would the album be? @xref{Types Answer 4, 4}. (@bullet{})
|
|
|
|
A @dfn{date form} represents a date, or a date and time. Dates must
|
|
be entered using algebraic entry. Date forms are surrounded by
|
|
@samp{< >} symbols; most standard formats for dates are recognized.
|
|
|
|
@smallexample
|
|
@group
|
|
2: <Sun Jan 13, 1991> 1: 2.25
|
|
1: <6:00pm Thu Jan 10, 1991> .
|
|
.
|
|
|
|
' <13 Jan 1991>, <1/10/91, 6pm> @key{RET} -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In this example, we enter two dates, then subtract to find the
|
|
number of days between them. It is also possible to add an
|
|
HMS form or a number (of days) to a date form to get another
|
|
date form.
|
|
|
|
@smallexample
|
|
@group
|
|
1: <4:45:59pm Mon Jan 14, 1991> 1: <2:50:59am Thu Jan 17, 1991>
|
|
. .
|
|
|
|
t N 2 + 10@@ 5' +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@c [fix-ref Date Arithmetic]
|
|
@noindent
|
|
The @kbd{t N} (``now'') command pushes the current date and time on the
|
|
stack; then we add two days, ten hours and five minutes to the date and
|
|
time. Other date-and-time related commands include @kbd{t J}, which
|
|
does Julian day conversions, @kbd{t W}, which finds the beginning of
|
|
the week in which a date form lies, and @kbd{t I}, which increments a
|
|
date by one or several months. @xref{Date Arithmetic}, for more.
|
|
|
|
(@bullet{}) @strong{Exercise 5.} How many days until the next
|
|
Friday the 13th? @xref{Types Answer 5, 5}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 6.} How many leap years will there be
|
|
between now and the year 10001 A.D.? @xref{Types Answer 6, 6}. (@bullet{})
|
|
|
|
@cindex Slope and angle of a line
|
|
@cindex Angle and slope of a line
|
|
An @dfn{error form} represents a mean value with an attached standard
|
|
deviation, or error estimate. Suppose our measurements indicate that
|
|
a certain telephone pole is about 30 meters away, with an estimated
|
|
error of 1 meter, and 8 meters tall, with an estimated error of 0.2
|
|
meters. What is the slope of a line from here to the top of the
|
|
pole, and what is the equivalent angle in degrees?
|
|
|
|
@smallexample
|
|
@group
|
|
1: 8 +/- 0.2 2: 8 +/- 0.2 1: 0.266 +/- 0.011 1: 14.93 +/- 0.594
|
|
. 1: 30 +/- 1 . .
|
|
.
|
|
|
|
8 p .2 @key{RET} 30 p 1 / I T
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This means that the angle is about 15 degrees, and, assuming our
|
|
original error estimates were valid standard deviations, there is about
|
|
a 60% chance that the result is correct within 0.59 degrees.
|
|
|
|
@cindex Torus, volume of
|
|
(@bullet{}) @strong{Exercise 7.} The volume of a torus (a donut shape) is
|
|
@texline @math{2 \pi^2 R r^2}
|
|
@infoline @w{@expr{2 pi^2 R r^2}}
|
|
where @expr{R} is the radius of the circle that
|
|
defines the center of the tube and @expr{r} is the radius of the tube
|
|
itself. Suppose @expr{R} is 20 cm and @expr{r} is 4 cm, each known to
|
|
within 5 percent. What is the volume and the relative uncertainty of
|
|
the volume? @xref{Types Answer 7, 7}. (@bullet{})
|
|
|
|
An @dfn{interval form} represents a range of values. While an
|
|
error form is best for making statistical estimates, intervals give
|
|
you exact bounds on an answer. Suppose we additionally know that
|
|
our telephone pole is definitely between 28 and 31 meters away,
|
|
and that it is between 7.7 and 8.1 meters tall.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [7.7 .. 8.1] 2: [7.7 .. 8.1] 1: [0.24 .. 0.28] 1: [13.9 .. 16.1]
|
|
. 1: [28 .. 31] . .
|
|
.
|
|
|
|
[ 7.7 .. 8.1 ] [ 28 .. 31 ] / I T
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
If our bounds were correct, then the angle to the top of the pole
|
|
is sure to lie in the range shown.
|
|
|
|
The square brackets around these intervals indicate that the endpoints
|
|
themselves are allowable values. In other words, the distance to the
|
|
telephone pole is between 28 and 31, @emph{inclusive}. You can also
|
|
make an interval that is exclusive of its endpoints by writing
|
|
parentheses instead of square brackets. You can even make an interval
|
|
which is inclusive (``closed'') on one end and exclusive (``open'') on
|
|
the other.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1 .. 10) 1: (0.1 .. 1] 2: (0.1 .. 1] 1: (0.2 .. 3)
|
|
. . 1: [2 .. 3) .
|
|
.
|
|
|
|
[ 1 .. 10 ) & [ 2 .. 3 ) *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The Calculator automatically keeps track of which end values should
|
|
be open and which should be closed. You can also make infinite or
|
|
semi-infinite intervals by using @samp{-inf} or @samp{inf} for one
|
|
or both endpoints.
|
|
|
|
(@bullet{}) @strong{Exercise 8.} What answer would you expect from
|
|
@samp{@w{1 /} @w{(0 .. 10)}}? What about @samp{@w{1 /} @w{(-10 .. 0)}}? What
|
|
about @samp{@w{1 /} @w{[0 .. 10]}} (where the interval actually includes
|
|
zero)? What about @samp{@w{1 /} @w{(-10 .. 10)}}?
|
|
@xref{Types Answer 8, 8}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 9.} Two easy ways of squaring a number
|
|
are @kbd{@key{RET} *} and @w{@kbd{2 ^}}. Normally these produce the same
|
|
answer. Would you expect this still to hold true for interval forms?
|
|
If not, which of these will result in a larger interval?
|
|
@xref{Types Answer 9, 9}. (@bullet{})
|
|
|
|
A @dfn{modulo form} is used for performing arithmetic modulo @var{m}.
|
|
For example, arithmetic involving time is generally done modulo 12
|
|
or 24 hours.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 mod 24 1: 3 mod 24 1: 21 mod 24 1: 9 mod 24
|
|
. . . .
|
|
|
|
17 M 24 @key{RET} 10 + n 5 /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In this last step, Calc has divided by 5 modulo 24; i.e., it has found a
|
|
new number which, when multiplied by 5 modulo 24, produces the original
|
|
number, 21. If @var{m} is prime and the divisor is not a multiple of
|
|
@var{m}, it is always possible to find such a number. For non-prime
|
|
@var{m} like 24, it is only sometimes possible.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10 mod 24 1: 16 mod 24 1: 1000000... 1: 16
|
|
. . . .
|
|
|
|
10 M 24 @key{RET} 100 ^ 10 @key{RET} 100 ^ 24 %
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
These two calculations get the same answer, but the first one is
|
|
much more efficient because it avoids the huge intermediate value
|
|
that arises in the second one.
|
|
|
|
@cindex Fermat, primality test of
|
|
(@bullet{}) @strong{Exercise 10.} A theorem of Pierre de Fermat
|
|
says that
|
|
@texline @w{@math{x^{n-1} \bmod n = 1}}
|
|
@infoline @expr{x^(n-1) mod n = 1}
|
|
if @expr{n} is a prime number and @expr{x} is an integer less than
|
|
@expr{n}. If @expr{n} is @emph{not} a prime number, this will
|
|
@emph{not} be true for most values of @expr{x}. Thus we can test
|
|
informally if a number is prime by trying this formula for several
|
|
values of @expr{x}. Use this test to tell whether the following numbers
|
|
are prime: 811749613, 15485863. @xref{Types Answer 10, 10}. (@bullet{})
|
|
|
|
It is possible to use HMS forms as parts of error forms, intervals,
|
|
modulo forms, or as the phase part of a polar complex number.
|
|
For example, the @code{calc-time} command pushes the current time
|
|
of day on the stack as an HMS/modulo form.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17@@ 34' 45" mod 24@@ 0' 0" 1: 6@@ 22' 15" mod 24@@ 0' 0"
|
|
. .
|
|
|
|
x time @key{RET} n
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This calculation tells me it is six hours and 22 minutes until midnight.
|
|
|
|
(@bullet{}) @strong{Exercise 11.} A rule of thumb is that one year
|
|
is about
|
|
@texline @math{\pi \times 10^7}
|
|
@infoline @w{@expr{pi * 10^7}}
|
|
seconds. What time will it be that many seconds from right now?
|
|
@xref{Types Answer 11, 11}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 12.} You are preparing to order packaging
|
|
for the CD release of the Extended Disco Version of @emph{Abbey Road}.
|
|
You are told that the songs will actually be anywhere from 20 to 60
|
|
seconds longer than the originals. One CD can hold about 75 minutes
|
|
of music. Should you order single or double packages?
|
|
@xref{Types Answer 12, 12}. (@bullet{})
|
|
|
|
Another kind of data the Calculator can manipulate is numbers with
|
|
@dfn{units}. This isn't strictly a new data type; it's simply an
|
|
application of algebraic expressions, where we use variables with
|
|
suggestive names like @samp{cm} and @samp{in} to represent units
|
|
like centimeters and inches.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 in 1: 5.08 cm 1: 0.027778 fath 1: 0.0508 m
|
|
. . . .
|
|
|
|
' 2in @key{RET} u c cm @key{RET} u c fath @key{RET} u b
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We enter the quantity ``2 inches'' (actually an algebraic expression
|
|
which means two times the variable @samp{in}), then we convert it
|
|
first to centimeters, then to fathoms, then finally to ``base'' units,
|
|
which in this case means meters.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 9 acre 1: 3 sqrt(acre) 1: 190.84 m 1: 190.84 m + 30 cm
|
|
. . . .
|
|
|
|
' 9 acre @key{RET} Q u s ' $+30 cm @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 191.14 m 1: 36536.3046 m^2 1: 365363046 cm^2
|
|
. . .
|
|
|
|
u s 2 ^ u c cgs
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Since units expressions are really just formulas, taking the square
|
|
root of @samp{acre} is undefined. After all, @code{acre} might be an
|
|
algebraic variable that you will someday assign a value. We use the
|
|
``units-simplify'' command to simplify the expression with variables
|
|
being interpreted as unit names.
|
|
|
|
In the final step, we have converted not to a particular unit, but to a
|
|
units system. The ``cgs'' system uses centimeters instead of meters
|
|
as its standard unit of length.
|
|
|
|
There is a wide variety of units defined in the Calculator.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 55 mph 1: 88.5139 kph 1: 88.5139 km / hr 1: 8.201407e-8 c
|
|
. . . .
|
|
|
|
' 55 mph @key{RET} u c kph @key{RET} u c km/hr @key{RET} u c c @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We express a speed first in miles per hour, then in kilometers per
|
|
hour, then again using a slightly more explicit notation, then
|
|
finally in terms of fractions of the speed of light.
|
|
|
|
Temperature conversions are a bit more tricky. There are two ways to
|
|
interpret ``20 degrees Fahrenheit''---it could mean an actual
|
|
temperature, or it could mean a change in temperature. For normal
|
|
units there is no difference, but temperature units have an offset
|
|
as well as a scale factor and so there must be two explicit commands
|
|
for them.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 20 degF 1: 11.1111 degC 1: -20:3 degC 1: -6.666 degC
|
|
. . . .
|
|
|
|
' 20 degF @key{RET} u c degC @key{RET} U u t degC @key{RET} c f
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we convert a change of 20 degrees Fahrenheit into an equivalent
|
|
change in degrees Celsius (or Centigrade). Then, we convert the
|
|
absolute temperature 20 degrees Fahrenheit into Celsius. Since
|
|
this comes out as an exact fraction, we then convert to floating-point
|
|
for easier comparison with the other result.
|
|
|
|
For simple unit conversions, you can put a plain number on the stack.
|
|
Then @kbd{u c} and @kbd{u t} will prompt for both old and new units.
|
|
When you use this method, you're responsible for remembering which
|
|
numbers are in which units:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 55 1: 88.5139 1: 8.201407e-8
|
|
. . .
|
|
|
|
55 u c mph @key{RET} kph @key{RET} u c km/hr @key{RET} c @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
To see a complete list of built-in units, type @kbd{u v}. Press
|
|
@w{@kbd{C-x * c}} again to re-enter the Calculator when you're done looking
|
|
at the units table.
|
|
|
|
(@bullet{}) @strong{Exercise 13.} How many seconds are there really
|
|
in a year? @xref{Types Answer 13, 13}. (@bullet{})
|
|
|
|
@cindex Speed of light
|
|
(@bullet{}) @strong{Exercise 14.} Supercomputer designs are limited by
|
|
the speed of light (and of electricity, which is nearly as fast).
|
|
Suppose a computer has a 4.1 ns (nanosecond) clock cycle, and its
|
|
cabinet is one meter across. Is speed of light going to be a
|
|
significant factor in its design? @xref{Types Answer 14, 14}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 15.} Sam the Slug normally travels about
|
|
five yards in an hour. He has obtained a supply of Power Pills; each
|
|
Power Pill he eats doubles his speed. How many Power Pills can he
|
|
swallow and still travel legally on most US highways?
|
|
@xref{Types Answer 15, 15}. (@bullet{})
|
|
|
|
@node Algebra Tutorial, Programming Tutorial, Types Tutorial, Tutorial
|
|
@section Algebra and Calculus Tutorial
|
|
|
|
@noindent
|
|
This section shows how to use Calc's algebra facilities to solve
|
|
equations, do simple calculus problems, and manipulate algebraic
|
|
formulas.
|
|
|
|
@menu
|
|
* Basic Algebra Tutorial::
|
|
* Rewrites Tutorial::
|
|
@end menu
|
|
|
|
@node Basic Algebra Tutorial, Rewrites Tutorial, Algebra Tutorial, Algebra Tutorial
|
|
@subsection Basic Algebra
|
|
|
|
@noindent
|
|
If you enter a formula in Algebraic mode that refers to variables,
|
|
the formula itself is pushed onto the stack. You can manipulate
|
|
formulas as regular data objects.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 2 x^2 - 6 1: 6 - 2 x^2 1: (6 - 2 x^2) (3 x^2 + y)
|
|
. . .
|
|
|
|
' 2x^2-6 @key{RET} n ' 3x^2+y @key{RET} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 1.} Do @kbd{' x @key{RET} Q 2 ^} and
|
|
@kbd{' x @key{RET} 2 ^ Q} both wind up with the same result (@samp{x})?
|
|
Why or why not? @xref{Algebra Answer 1, 1}. (@bullet{})
|
|
|
|
There are also commands for doing common algebraic operations on
|
|
formulas. Continuing with the formula from the last example,
|
|
|
|
@smallexample
|
|
@group
|
|
1: 18 x^2 + 6 y - 6 x^4 - 2 x^2 y 1: (18 - 2 y) x^2 - 6 x^4 + 6 y
|
|
. .
|
|
|
|
a x a c x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we ``expand'' using the distributive law, then we ``collect''
|
|
terms involving like powers of @expr{x}.
|
|
|
|
Let's find the value of this expression when @expr{x} is 2 and @expr{y}
|
|
is one-half.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 x^2 - 6 x^4 + 3 1: -25
|
|
. .
|
|
|
|
1:2 s l y @key{RET} 2 s l x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @kbd{s l} command means ``let''; it takes a number from the top of
|
|
the stack and temporarily assigns it as the value of the variable
|
|
you specify. It then evaluates (as if by the @kbd{=} key) the
|
|
next expression on the stack. After this command, the variable goes
|
|
back to its original value, if any.
|
|
|
|
(An earlier exercise in this tutorial involved storing a value in the
|
|
variable @code{x}; if this value is still there, you will have to
|
|
unstore it with @kbd{s u x @key{RET}} before the above example will work
|
|
properly.)
|
|
|
|
@cindex Maximum of a function using Calculus
|
|
Let's find the maximum value of our original expression when @expr{y}
|
|
is one-half and @expr{x} ranges over all possible values. We can
|
|
do this by taking the derivative with respect to @expr{x} and examining
|
|
values of @expr{x} for which the derivative is zero. If the second
|
|
derivative of the function at that value of @expr{x} is negative,
|
|
the function has a local maximum there.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 x^2 - 6 x^4 + 3 1: 34 x - 24 x^3
|
|
. .
|
|
|
|
U @key{DEL} s 1 a d x @key{RET} s 2
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Well, the derivative is clearly zero when @expr{x} is zero. To find
|
|
the other root(s), let's divide through by @expr{x} and then solve:
|
|
|
|
@smallexample
|
|
@group
|
|
1: (34 x - 24 x^3) / x 1: 34 x / x - 24 x^3 / x 1: 34 - 24 x^2
|
|
. . .
|
|
|
|
' x @key{RET} / a x a s
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 34 - 24 x^2 = 0 1: x = 1.19023
|
|
. .
|
|
|
|
0 a = s 3 a S x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice the use of @kbd{a s} to ``simplify'' the formula. When the
|
|
default algebraic simplifications don't do enough, you can use
|
|
@kbd{a s} to tell Calc to spend more time on the job.
|
|
|
|
Now we compute the second derivative and plug in our values of @expr{x}:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1.19023 2: 1.19023 2: 1.19023
|
|
. 1: 34 x - 24 x^3 1: 34 - 72 x^2
|
|
. .
|
|
|
|
a . r 2 a d x @key{RET} s 4
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(The @kbd{a .} command extracts just the righthand side of an equation.
|
|
Another method would have been to use @kbd{v u} to unpack the equation
|
|
@w{@samp{x = 1.19}} to @samp{x} and @samp{1.19}, then use @kbd{M-- M-2 @key{DEL}}
|
|
to delete the @samp{x}.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: 34 - 72 x^2 1: -68. 2: 34 - 72 x^2 1: 34
|
|
1: 1.19023 . 1: 0 .
|
|
. .
|
|
|
|
@key{TAB} s l x @key{RET} U @key{DEL} 0 s l x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The first of these second derivatives is negative, so we know the function
|
|
has a maximum value at @expr{x = 1.19023}. (The function also has a
|
|
local @emph{minimum} at @expr{x = 0}.)
|
|
|
|
When we solved for @expr{x}, we got only one value even though
|
|
@expr{34 - 24 x^2 = 0} is a quadratic equation that ought to have
|
|
two solutions. The reason is that @w{@kbd{a S}} normally returns a
|
|
single ``principal'' solution. If it needs to come up with an
|
|
arbitrary sign (as occurs in the quadratic formula) it picks @expr{+}.
|
|
If it needs an arbitrary integer, it picks zero. We can get a full
|
|
solution by pressing @kbd{H} (the Hyperbolic flag) before @kbd{a S}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 34 - 24 x^2 = 0 1: x = 1.19023 s1 1: x = -1.19023
|
|
. . .
|
|
|
|
r 3 H a S x @key{RET} s 5 1 n s l s1 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Calc has invented the variable @samp{s1} to represent an unknown sign;
|
|
it is supposed to be either @mathit{+1} or @mathit{-1}. Here we have used
|
|
the ``let'' command to evaluate the expression when the sign is negative.
|
|
If we plugged this into our second derivative we would get the same,
|
|
negative, answer, so @expr{x = -1.19023} is also a maximum.
|
|
|
|
To find the actual maximum value, we must plug our two values of @expr{x}
|
|
into the original formula.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 17 x^2 - 6 x^4 + 3 1: 24.08333 s1^2 - 12.04166 s1^4 + 3
|
|
1: x = 1.19023 s1 .
|
|
.
|
|
|
|
r 1 r 5 s l @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Here we see another way to use @kbd{s l}; if its input is an equation
|
|
with a variable on the lefthand side, then @kbd{s l} treats the equation
|
|
like an assignment to that variable if you don't give a variable name.)
|
|
|
|
It's clear that this will have the same value for either sign of
|
|
@code{s1}, but let's work it out anyway, just for the exercise:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [-1, 1] 1: [15.04166, 15.04166]
|
|
1: 24.08333 s1^2 ... .
|
|
.
|
|
|
|
[ 1 n , 1 ] @key{TAB} V M $ @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we have used a vector mapping operation to evaluate the function
|
|
at several values of @samp{s1} at once. @kbd{V M $} is like @kbd{V M '}
|
|
except that it takes the formula from the top of the stack. The
|
|
formula is interpreted as a function to apply across the vector at the
|
|
next-to-top stack level. Since a formula on the stack can't contain
|
|
@samp{$} signs, Calc assumes the variables in the formula stand for
|
|
different arguments. It prompts you for an @dfn{argument list}, giving
|
|
the list of all variables in the formula in alphabetical order as the
|
|
default list. In this case the default is @samp{(s1)}, which is just
|
|
what we want so we simply press @key{RET} at the prompt.
|
|
|
|
If there had been several different values, we could have used
|
|
@w{@kbd{V R X}} to find the global maximum.
|
|
|
|
Calc has a built-in @kbd{a P} command that solves an equation using
|
|
@w{@kbd{H a S}} and returns a vector of all the solutions. It simply
|
|
automates the job we just did by hand. Applied to our original
|
|
cubic polynomial, it would produce the vector of solutions
|
|
@expr{[1.19023, -1.19023, 0]}. (There is also an @kbd{a X} command
|
|
which finds a local maximum of a function. It uses a numerical search
|
|
method rather than examining the derivatives, and thus requires you
|
|
to provide some kind of initial guess to show it where to look.)
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Given a vector of the roots of a
|
|
polynomial (such as the output of an @kbd{a P} command), what
|
|
sequence of commands would you use to reconstruct the original
|
|
polynomial? (The answer will be unique to within a constant
|
|
multiple; choose the solution where the leading coefficient is one.)
|
|
@xref{Algebra Answer 2, 2}. (@bullet{})
|
|
|
|
The @kbd{m s} command enables Symbolic mode, in which formulas
|
|
like @samp{sqrt(5)} that can't be evaluated exactly are left in
|
|
symbolic form rather than giving a floating-point approximate answer.
|
|
Fraction mode (@kbd{m f}) is also useful when doing algebra.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 34 x - 24 x^3 2: 34 x - 24 x^3
|
|
1: 34 x - 24 x^3 1: [sqrt(51) / 6, sqrt(51) / -6, 0]
|
|
. .
|
|
|
|
r 2 @key{RET} m s m f a P x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
One more mode that makes reading formulas easier is Big mode.
|
|
|
|
@smallexample
|
|
@group
|
|
3
|
|
2: 34 x - 24 x
|
|
|
|
____ ____
|
|
V 51 V 51
|
|
1: [-----, -----, 0]
|
|
6 -6
|
|
|
|
.
|
|
|
|
d B
|
|
@end group
|
|
@end smallexample
|
|
|
|
Here things like powers, square roots, and quotients and fractions
|
|
are displayed in a two-dimensional pictorial form. Calc has other
|
|
language modes as well, such as C mode, FORTRAN mode, @TeX{} mode
|
|
and La@TeX{} mode.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 34*x - 24*pow(x, 3) 2: 34*x - 24*x**3
|
|
1: @{sqrt(51) / 6, sqrt(51) / -6, 0@} 1: /sqrt(51) / 6, sqrt(51) / -6, 0/
|
|
. .
|
|
|
|
d C d F
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
3: 34 x - 24 x^3
|
|
2: [@{\sqrt@{51@} \over 6@}, @{\sqrt@{51@} \over -6@}, 0]
|
|
1: @{2 \over 3@} \sqrt@{5@}
|
|
.
|
|
|
|
d T ' 2 \sqrt@{5@} \over 3 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
As you can see, language modes affect both entry and display of
|
|
formulas. They affect such things as the names used for built-in
|
|
functions, the set of arithmetic operators and their precedences,
|
|
and notations for vectors and matrices.
|
|
|
|
Notice that @samp{sqrt(51)} may cause problems with older
|
|
implementations of C and FORTRAN, which would require something more
|
|
like @samp{sqrt(51.0)}. It is always wise to check over the formulas
|
|
produced by the various language modes to make sure they are fully
|
|
correct.
|
|
|
|
Type @kbd{m s}, @kbd{m f}, and @kbd{d N} to reset these modes. (You
|
|
may prefer to remain in Big mode, but all the examples in the tutorial
|
|
are shown in normal mode.)
|
|
|
|
@cindex Area under a curve
|
|
What is the area under the portion of this curve from @expr{x = 1} to @expr{2}?
|
|
This is simply the integral of the function:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 x^2 - 6 x^4 + 3 1: 5.6666 x^3 - 1.2 x^5 + 3 x
|
|
. .
|
|
|
|
r 1 a i x
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We want to evaluate this at our two values for @expr{x} and subtract.
|
|
One way to do it is again with vector mapping and reduction:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [2, 1] 1: [12.93333, 7.46666] 1: 5.46666
|
|
1: 5.6666 x^3 ... . .
|
|
|
|
[ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 3.} Find the integral from 1 to @expr{y}
|
|
of
|
|
@texline @math{x \sin \pi x}
|
|
@infoline @w{@expr{x sin(pi x)}}
|
|
(where the sine is calculated in radians). Find the values of the
|
|
integral for integers @expr{y} from 1 to 5. @xref{Algebra Answer 3,
|
|
3}. (@bullet{})
|
|
|
|
Calc's integrator can do many simple integrals symbolically, but many
|
|
others are beyond its capabilities. Suppose we wish to find the area
|
|
under the curve
|
|
@texline @math{\sin x \ln x}
|
|
@infoline @expr{sin(x) ln(x)}
|
|
over the same range of @expr{x}. If you entered this formula and typed
|
|
@kbd{a i x @key{RET}} (don't bother to try this), Calc would work for a
|
|
long time but would be unable to find a solution. In fact, there is no
|
|
closed-form solution to this integral. Now what do we do?
|
|
|
|
@cindex Integration, numerical
|
|
@cindex Numerical integration
|
|
One approach would be to do the integral numerically. It is not hard
|
|
to do this by hand using vector mapping and reduction. It is rather
|
|
slow, though, since the sine and logarithm functions take a long time.
|
|
We can save some time by reducing the working precision.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 10 1: [1, 1.1, 1.2, ... , 1.8, 1.9]
|
|
2: 1 .
|
|
1: 0.1
|
|
.
|
|
|
|
10 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Note that we have used the extended version of @kbd{v x}; we could
|
|
also have used plain @kbd{v x} as follows: @kbd{v x 10 @key{RET} 9 + .1 *}.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 1.1, ... ] 1: [0., 0.084941, 0.16993, ... ]
|
|
1: sin(x) ln(x) .
|
|
.
|
|
|
|
' sin(x) ln(x) @key{RET} s 1 m r p 5 @key{RET} V M $ @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 3.4195 0.34195
|
|
. .
|
|
|
|
V R + 0.1 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(If you got wildly different results, did you remember to switch
|
|
to Radians mode?)
|
|
|
|
Here we have divided the curve into ten segments of equal width;
|
|
approximating these segments as rectangular boxes (i.e., assuming
|
|
the curve is nearly flat at that resolution), we compute the areas
|
|
of the boxes (height times width), then sum the areas. (It is
|
|
faster to sum first, then multiply by the width, since the width
|
|
is the same for every box.)
|
|
|
|
The true value of this integral turns out to be about 0.374, so
|
|
we're not doing too well. Let's try another approach.
|
|
|
|
@smallexample
|
|
@group
|
|
1: sin(x) ln(x) 1: 0.84147 x - 0.84147 + 0.11957 (x - 1)^2 - ...
|
|
. .
|
|
|
|
r 1 a t x=1 @key{RET} 4 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we have computed the Taylor series expansion of the function
|
|
about the point @expr{x=1}. We can now integrate this polynomial
|
|
approximation, since polynomials are easy to integrate.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.42074 x^2 + ... 1: [-0.0446, -0.42073] 1: 0.3761
|
|
. . .
|
|
|
|
a i x @key{RET} [ 2 , 1 ] @key{TAB} V M $ @key{RET} V R -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Better! By increasing the precision and/or asking for more terms
|
|
in the Taylor series, we can get a result as accurate as we like.
|
|
(Taylor series converge better away from singularities in the
|
|
function such as the one at @code{ln(0)}, so it would also help to
|
|
expand the series about the points @expr{x=2} or @expr{x=1.5} instead
|
|
of @expr{x=1}.)
|
|
|
|
@cindex Simpson's rule
|
|
@cindex Integration by Simpson's rule
|
|
(@bullet{}) @strong{Exercise 4.} Our first method approximated the
|
|
curve by stairsteps of width 0.1; the total area was then the sum
|
|
of the areas of the rectangles under these stairsteps. Our second
|
|
method approximated the function by a polynomial, which turned out
|
|
to be a better approximation than stairsteps. A third method is
|
|
@dfn{Simpson's rule}, which is like the stairstep method except
|
|
that the steps are not required to be flat. Simpson's rule boils
|
|
down to the formula,
|
|
|
|
@ifinfo
|
|
@example
|
|
(h/3) * (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + ...
|
|
+ 2 f(a+(n-2)*h) + 4 f(a+(n-1)*h) + f(a+n*h))
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \displaylines{
|
|
\qquad {h \over 3} (f(a) + 4 f(a+h) + 2 f(a+2h) + 4 f(a+3h) + \cdots
|
|
\hfill \cr \hfill {} + 2 f(a+(n-2)h) + 4 f(a+(n-1)h) + f(a+n h)) \qquad
|
|
} $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
where @expr{n} (which must be even) is the number of slices and @expr{h}
|
|
is the width of each slice. These are 10 and 0.1 in our example.
|
|
For reference, here is the corresponding formula for the stairstep
|
|
method:
|
|
|
|
@ifinfo
|
|
@example
|
|
h * (f(a) + f(a+h) + f(a+2h) + f(a+3h) + ...
|
|
+ f(a+(n-2)*h) + f(a+(n-1)*h))
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ h (f(a) + f(a+h) + f(a+2h) + f(a+3h) + \cdots
|
|
+ f(a+(n-2)h) + f(a+(n-1)h)) $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
Compute the integral from 1 to 2 of
|
|
@texline @math{\sin x \ln x}
|
|
@infoline @expr{sin(x) ln(x)}
|
|
using Simpson's rule with 10 slices.
|
|
@xref{Algebra Answer 4, 4}. (@bullet{})
|
|
|
|
Calc has a built-in @kbd{a I} command for doing numerical integration.
|
|
It uses @dfn{Romberg's method}, which is a more sophisticated cousin
|
|
of Simpson's rule. In particular, it knows how to keep refining the
|
|
result until the current precision is satisfied.
|
|
|
|
@c [fix-ref Selecting Sub-Formulas]
|
|
Aside from the commands we've seen so far, Calc also provides a
|
|
large set of commands for operating on parts of formulas. You
|
|
indicate the desired sub-formula by placing the cursor on any part
|
|
of the formula before giving a @dfn{selection} command. Selections won't
|
|
be covered in the tutorial; @pxref{Selecting Subformulas}, for
|
|
details and examples.
|
|
|
|
@c hard exercise: simplify (2^(n r) - 2^(r*(n - 1))) / (2^r - 1) 2^(n - 1)
|
|
@c to 2^((n-1)*(r-1)).
|
|
|
|
@node Rewrites Tutorial, , Basic Algebra Tutorial, Algebra Tutorial
|
|
@subsection Rewrite Rules
|
|
|
|
@noindent
|
|
No matter how many built-in commands Calc provided for doing algebra,
|
|
there would always be something you wanted to do that Calc didn't have
|
|
in its repertoire. So Calc also provides a @dfn{rewrite rule} system
|
|
that you can use to define your own algebraic manipulations.
|
|
|
|
Suppose we want to simplify this trigonometric formula:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1 / cos(x) - sin(x) tan(x)
|
|
.
|
|
|
|
' 1/cos(x) - sin(x) tan(x) @key{RET} s 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
If we were simplifying this by hand, we'd probably replace the
|
|
@samp{tan} with a @samp{sin/cos} first, then combine over a common
|
|
denominator. There is no Calc command to do the former; the @kbd{a n}
|
|
algebra command will do the latter but we'll do both with rewrite
|
|
rules just for practice.
|
|
|
|
Rewrite rules are written with the @samp{:=} symbol.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1 / cos(x) - sin(x)^2 / cos(x)
|
|
.
|
|
|
|
a r tan(a) := sin(a)/cos(a) @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(The ``assignment operator'' @samp{:=} has several uses in Calc. All
|
|
by itself the formula @samp{tan(a) := sin(a)/cos(a)} doesn't do anything,
|
|
but when it is given to the @kbd{a r} command, that command interprets
|
|
it as a rewrite rule.)
|
|
|
|
The lefthand side, @samp{tan(a)}, is called the @dfn{pattern} of the
|
|
rewrite rule. Calc searches the formula on the stack for parts that
|
|
match the pattern. Variables in a rewrite pattern are called
|
|
@dfn{meta-variables}, and when matching the pattern each meta-variable
|
|
can match any sub-formula. Here, the meta-variable @samp{a} matched
|
|
the actual variable @samp{x}.
|
|
|
|
When the pattern part of a rewrite rule matches a part of the formula,
|
|
that part is replaced by the righthand side with all the meta-variables
|
|
substituted with the things they matched. So the result is
|
|
@samp{sin(x) / cos(x)}. Calc's normal algebraic simplifications then
|
|
mix this in with the rest of the original formula.
|
|
|
|
To merge over a common denominator, we can use another simple rule:
|
|
|
|
@smallexample
|
|
@group
|
|
1: (1 - sin(x)^2) / cos(x)
|
|
.
|
|
|
|
a r a/x + b/x := (a+b)/x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
This rule points out several interesting features of rewrite patterns.
|
|
First, if a meta-variable appears several times in a pattern, it must
|
|
match the same thing everywhere. This rule detects common denominators
|
|
because the same meta-variable @samp{x} is used in both of the
|
|
denominators.
|
|
|
|
Second, meta-variable names are independent from variables in the
|
|
target formula. Notice that the meta-variable @samp{x} here matches
|
|
the subformula @samp{cos(x)}; Calc never confuses the two meanings of
|
|
@samp{x}.
|
|
|
|
And third, rewrite patterns know a little bit about the algebraic
|
|
properties of formulas. The pattern called for a sum of two quotients;
|
|
Calc was able to match a difference of two quotients by matching
|
|
@samp{a = 1}, @samp{b = -sin(x)^2}, and @samp{x = cos(x)}.
|
|
|
|
@c [fix-ref Algebraic Properties of Rewrite Rules]
|
|
We could just as easily have written @samp{a/x - b/x := (a-b)/x} for
|
|
the rule. It would have worked just the same in all cases. (If we
|
|
really wanted the rule to apply only to @samp{+} or only to @samp{-},
|
|
we could have used the @code{plain} symbol. @xref{Algebraic Properties
|
|
of Rewrite Rules}, for some examples of this.)
|
|
|
|
One more rewrite will complete the job. We want to use the identity
|
|
@samp{sin(x)^2 + cos(x)^2 = 1}, but of course we must first rearrange
|
|
the identity in a way that matches our formula. The obvious rule
|
|
would be @samp{@w{1 - sin(x)^2} := cos(x)^2}, but a little thought shows
|
|
that the rule @samp{sin(x)^2 := 1 - cos(x)^2} will also work. The
|
|
latter rule has a more general pattern so it will work in many other
|
|
situations, too.
|
|
|
|
@smallexample
|
|
@group
|
|
1: (1 + cos(x)^2 - 1) / cos(x) 1: cos(x)
|
|
. .
|
|
|
|
a r sin(x)^2 := 1 - cos(x)^2 @key{RET} a s
|
|
@end group
|
|
@end smallexample
|
|
|
|
You may ask, what's the point of using the most general rule if you
|
|
have to type it in every time anyway? The answer is that Calc allows
|
|
you to store a rewrite rule in a variable, then give the variable
|
|
name in the @kbd{a r} command. In fact, this is the preferred way to
|
|
use rewrites. For one, if you need a rule once you'll most likely
|
|
need it again later. Also, if the rule doesn't work quite right you
|
|
can simply Undo, edit the variable, and run the rule again without
|
|
having to retype it.
|
|
|
|
@smallexample
|
|
@group
|
|
' tan(x) := sin(x)/cos(x) @key{RET} s t tsc @key{RET}
|
|
' a/x + b/x := (a+b)/x @key{RET} s t merge @key{RET}
|
|
' sin(x)^2 := 1 - cos(x)^2 @key{RET} s t sinsqr @key{RET}
|
|
|
|
1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
|
|
. .
|
|
|
|
r 1 a r tsc @key{RET} a r merge @key{RET} a r sinsqr @key{RET} a s
|
|
@end group
|
|
@end smallexample
|
|
|
|
To edit a variable, type @kbd{s e} and the variable name, use regular
|
|
Emacs editing commands as necessary, then type @kbd{C-c C-c} to store
|
|
the edited value back into the variable.
|
|
You can also use @w{@kbd{s e}} to create a new variable if you wish.
|
|
|
|
Notice that the first time you use each rule, Calc puts up a ``compiling''
|
|
message briefly. The pattern matcher converts rules into a special
|
|
optimized pattern-matching language rather than using them directly.
|
|
This allows @kbd{a r} to apply even rather complicated rules very
|
|
efficiently. If the rule is stored in a variable, Calc compiles it
|
|
only once and stores the compiled form along with the variable. That's
|
|
another good reason to store your rules in variables rather than
|
|
entering them on the fly.
|
|
|
|
(@bullet{}) @strong{Exercise 1.} Type @kbd{m s} to get Symbolic
|
|
mode, then enter the formula @samp{@w{(2 + sqrt(2))} / @w{(1 + sqrt(2))}}.
|
|
Using a rewrite rule, simplify this formula by multiplying the top and
|
|
bottom by the conjugate @w{@samp{1 - sqrt(2)}}. The result will have
|
|
to be expanded by the distributive law; do this with another
|
|
rewrite. @xref{Rewrites Answer 1, 1}. (@bullet{})
|
|
|
|
The @kbd{a r} command can also accept a vector of rewrite rules, or
|
|
a variable containing a vector of rules.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [tsc, merge, sinsqr] 1: [tan(x) := sin(x) / cos(x), ... ]
|
|
. .
|
|
|
|
' [tsc,merge,sinsqr] @key{RET} =
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 1 / cos(x) - sin(x) tan(x) 1: cos(x)
|
|
. .
|
|
|
|
s t trig @key{RET} r 1 a r trig @key{RET} a s
|
|
@end group
|
|
@end smallexample
|
|
|
|
@c [fix-ref Nested Formulas with Rewrite Rules]
|
|
Calc tries all the rules you give against all parts of the formula,
|
|
repeating until no further change is possible. (The exact order in
|
|
which things are tried is rather complex, but for simple rules like
|
|
the ones we've used here the order doesn't really matter.
|
|
@xref{Nested Formulas with Rewrite Rules}.)
|
|
|
|
Calc actually repeats only up to 100 times, just in case your rule set
|
|
has gotten into an infinite loop. You can give a numeric prefix argument
|
|
to @kbd{a r} to specify any limit. In particular, @kbd{M-1 a r} does
|
|
only one rewrite at a time.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1 / cos(x) - sin(x)^2 / cos(x) 1: (1 - sin(x)^2) / cos(x)
|
|
. .
|
|
|
|
r 1 M-1 a r trig @key{RET} M-1 a r trig @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
You can type @kbd{M-0 a r} if you want no limit at all on the number
|
|
of rewrites that occur.
|
|
|
|
Rewrite rules can also be @dfn{conditional}. Simply follow the rule
|
|
with a @samp{::} symbol and the desired condition. For example,
|
|
|
|
@smallexample
|
|
@group
|
|
1: exp(2 pi i) + exp(3 pi i) + exp(4 pi i)
|
|
.
|
|
|
|
' exp(2 pi i) + exp(3 pi i) + exp(4 pi i) @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 1 + exp(3 pi i) + 1
|
|
.
|
|
|
|
a r exp(k pi i) := 1 :: k % 2 = 0 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Recall, @samp{k % 2} is the remainder from dividing @samp{k} by 2,
|
|
which will be zero only when @samp{k} is an even integer.)
|
|
|
|
An interesting point is that the variables @samp{pi} and @samp{i}
|
|
were matched literally rather than acting as meta-variables.
|
|
This is because they are special-constant variables. The special
|
|
constants @samp{e}, @samp{phi}, and so on also match literally.
|
|
A common error with rewrite
|
|
rules is to write, say, @samp{f(a,b,c,d,e) := g(a+b+c+d+e)}, expecting
|
|
to match any @samp{f} with five arguments but in fact matching
|
|
only when the fifth argument is literally @samp{e}!
|
|
|
|
@cindex Fibonacci numbers
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex fib
|
|
Rewrite rules provide an interesting way to define your own functions.
|
|
Suppose we want to define @samp{fib(n)} to produce the @var{n}th
|
|
Fibonacci number. The first two Fibonacci numbers are each 1;
|
|
later numbers are formed by summing the two preceding numbers in
|
|
the sequence. This is easy to express in a set of three rules:
|
|
|
|
@smallexample
|
|
@group
|
|
' [fib(1) := 1, fib(2) := 1, fib(n) := fib(n-1) + fib(n-2)] @key{RET} s t fib
|
|
|
|
1: fib(7) 1: 13
|
|
. .
|
|
|
|
' fib(7) @key{RET} a r fib @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
One thing that is guaranteed about the order that rewrites are tried
|
|
is that, for any given subformula, earlier rules in the rule set will
|
|
be tried for that subformula before later ones. So even though the
|
|
first and third rules both match @samp{fib(1)}, we know the first will
|
|
be used preferentially.
|
|
|
|
This rule set has one dangerous bug: Suppose we apply it to the
|
|
formula @samp{fib(x)}? (Don't actually try this.) The third rule
|
|
will match @samp{fib(x)} and replace it with @w{@samp{fib(x-1) + fib(x-2)}}.
|
|
Each of these will then be replaced to get @samp{fib(x-2) + 2 fib(x-3) +
|
|
fib(x-4)}, and so on, expanding forever. What we really want is to apply
|
|
the third rule only when @samp{n} is an integer greater than two. Type
|
|
@w{@kbd{s e fib @key{RET}}}, then edit the third rule to:
|
|
|
|
@smallexample
|
|
fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now:
|
|
|
|
@smallexample
|
|
@group
|
|
1: fib(6) + fib(x) + fib(0) 1: 8 + fib(x) + fib(0)
|
|
. .
|
|
|
|
' fib(6)+fib(x)+fib(0) @key{RET} a r fib @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We've created a new function, @code{fib}, and a new command,
|
|
@w{@kbd{a r fib @key{RET}}}, which means ``evaluate all @code{fib} calls in
|
|
this formula.'' To make things easier still, we can tell Calc to
|
|
apply these rules automatically by storing them in the special
|
|
variable @code{EvalRules}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [fib(1) := ...] . 1: [8, 13]
|
|
. .
|
|
|
|
s r fib @key{RET} s t EvalRules @key{RET} ' [fib(6), fib(7)] @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
It turns out that this rule set has the problem that it does far
|
|
more work than it needs to when @samp{n} is large. Consider the
|
|
first few steps of the computation of @samp{fib(6)}:
|
|
|
|
@smallexample
|
|
@group
|
|
fib(6) =
|
|
fib(5) + fib(4) =
|
|
fib(4) + fib(3) + fib(3) + fib(2) =
|
|
fib(3) + fib(2) + fib(2) + fib(1) + fib(2) + fib(1) + 1 = ...
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that @samp{fib(3)} appears three times here. Unless Calc's
|
|
algebraic simplifier notices the multiple @samp{fib(3)}s and combines
|
|
them (and, as it happens, it doesn't), this rule set does lots of
|
|
needless recomputation. To cure the problem, type @code{s e EvalRules}
|
|
to edit the rules (or just @kbd{s E}, a shorthand command for editing
|
|
@code{EvalRules}) and add another condition:
|
|
|
|
@smallexample
|
|
fib(n) := fib(n-1) + fib(n-2) :: integer(n) :: n > 2 :: remember
|
|
@end smallexample
|
|
|
|
@noindent
|
|
If a @samp{:: remember} condition appears anywhere in a rule, then if
|
|
that rule succeeds Calc will add another rule that describes that match
|
|
to the front of the rule set. (Remembering works in any rule set, but
|
|
for technical reasons it is most effective in @code{EvalRules}.) For
|
|
example, if the rule rewrites @samp{fib(7)} to something that evaluates
|
|
to 13, then the rule @samp{fib(7) := 13} will be added to the rule set.
|
|
|
|
Type @kbd{' fib(8) @key{RET}} to compute the eighth Fibonacci number, then
|
|
type @kbd{s E} again to see what has happened to the rule set.
|
|
|
|
With the @code{remember} feature, our rule set can now compute
|
|
@samp{fib(@var{n})} in just @var{n} steps. In the process it builds
|
|
up a table of all Fibonacci numbers up to @var{n}. After we have
|
|
computed the result for a particular @var{n}, we can get it back
|
|
(and the results for all smaller @var{n}) later in just one step.
|
|
|
|
All Calc operations will run somewhat slower whenever @code{EvalRules}
|
|
contains any rules. You should type @kbd{s u EvalRules @key{RET}} now to
|
|
un-store the variable.
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Sometimes it is possible to reformulate
|
|
a problem to reduce the amount of recursion necessary to solve it.
|
|
Create a rule that, in about @var{n} simple steps and without recourse
|
|
to the @code{remember} option, replaces @samp{fib(@var{n}, 1, 1)} with
|
|
@samp{fib(1, @var{x}, @var{y})} where @var{x} and @var{y} are the
|
|
@var{n}th and @var{n+1}st Fibonacci numbers, respectively. This rule is
|
|
rather clunky to use, so add a couple more rules to make the ``user
|
|
interface'' the same as for our first version: enter @samp{fib(@var{n})},
|
|
get back a plain number. @xref{Rewrites Answer 2, 2}. (@bullet{})
|
|
|
|
There are many more things that rewrites can do. For example, there
|
|
are @samp{&&&} and @samp{|||} pattern operators that create ``and''
|
|
and ``or'' combinations of rules. As one really simple example, we
|
|
could combine our first two Fibonacci rules thusly:
|
|
|
|
@example
|
|
[fib(1 ||| 2) := 1, fib(n) := ... ]
|
|
@end example
|
|
|
|
@noindent
|
|
That means ``@code{fib} of something matching either 1 or 2 rewrites
|
|
to 1.''
|
|
|
|
You can also make meta-variables optional by enclosing them in @code{opt}.
|
|
For example, the pattern @samp{a + b x} matches @samp{2 + 3 x} but not
|
|
@samp{2 + x} or @samp{3 x} or @samp{x}. The pattern @samp{opt(a) + opt(b) x}
|
|
matches all of these forms, filling in a default of zero for @samp{a}
|
|
and one for @samp{b}.
|
|
|
|
(@bullet{}) @strong{Exercise 3.} Your friend Joe had @samp{2 + 3 x}
|
|
on the stack and tried to use the rule
|
|
@samp{opt(a) + opt(b) x := f(a, b, x)}. What happened?
|
|
@xref{Rewrites Answer 3, 3}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 4.} Starting with a positive integer @expr{a},
|
|
divide @expr{a} by two if it is even, otherwise compute @expr{3 a + 1}.
|
|
Now repeat this step over and over. A famous unproved conjecture
|
|
is that for any starting @expr{a}, the sequence always eventually
|
|
reaches 1. Given the formula @samp{seq(@var{a}, 0)}, write a set of
|
|
rules that convert this into @samp{seq(1, @var{n})} where @var{n}
|
|
is the number of steps it took the sequence to reach the value 1.
|
|
Now enhance the rules to accept @samp{seq(@var{a})} as a starting
|
|
configuration, and to stop with just the number @var{n} by itself.
|
|
Now make the result be a vector of values in the sequence, from @var{a}
|
|
to 1. (The formula @samp{@var{x}|@var{y}} appends the vectors @var{x}
|
|
and @var{y}.) For example, rewriting @samp{seq(6)} should yield the
|
|
vector @expr{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
|
|
@xref{Rewrites Answer 4, 4}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 5.} Define, using rewrite rules, a function
|
|
@samp{nterms(@var{x})} that returns the number of terms in the sum
|
|
@var{x}, or 1 if @var{x} is not a sum. (A @dfn{sum} for our purposes
|
|
is one or more non-sum terms separated by @samp{+} or @samp{-} signs,
|
|
so that @expr{2 - 3 (x + y) + x y} is a sum of three terms.)
|
|
@xref{Rewrites Answer 5, 5}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 6.} A Taylor series for a function is an
|
|
infinite series that exactly equals the value of that function at
|
|
values of @expr{x} near zero.
|
|
|
|
@ifinfo
|
|
@example
|
|
cos(x) = 1 - x^2 / 2! + x^4 / 4! - x^6 / 6! + ...
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \cos x = 1 - {x^2 \over 2!} + {x^4 \over 4!} - {x^6 \over 6!} + \cdots $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
The @kbd{a t} command produces a @dfn{truncated Taylor series} which
|
|
is obtained by dropping all the terms higher than, say, @expr{x^2}.
|
|
Calc represents the truncated Taylor series as a polynomial in @expr{x}.
|
|
Mathematicians often write a truncated series using a ``big-O'' notation
|
|
that records what was the lowest term that was truncated.
|
|
|
|
@ifinfo
|
|
@example
|
|
cos(x) = 1 - x^2 / 2! + O(x^3)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \cos x = 1 - {x^2 \over 2!} + O(x^3) $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
The meaning of @expr{O(x^3)} is ``a quantity which is negligibly small
|
|
if @expr{x^3} is considered negligibly small as @expr{x} goes to zero.''
|
|
|
|
The exercise is to create rewrite rules that simplify sums and products of
|
|
power series represented as @samp{@var{polynomial} + O(@var{var}^@var{n})}.
|
|
For example, given @samp{1 - x^2 / 2 + O(x^3)} and @samp{x - x^3 / 6 + O(x^4)}
|
|
on the stack, we want to be able to type @kbd{*} and get the result
|
|
@samp{x - 2:3 x^3 + O(x^4)}. Don't worry if the terms of the sum are
|
|
rearranged or if @kbd{a s} needs to be typed after rewriting. (This one
|
|
is rather tricky; the solution at the end of this chapter uses 6 rewrite
|
|
rules. Hint: The @samp{constant(x)} condition tests whether @samp{x} is
|
|
a number.) @xref{Rewrites Answer 6, 6}. (@bullet{})
|
|
|
|
Just for kicks, try adding the rule @code{2+3 := 6} to @code{EvalRules}.
|
|
What happens? (Be sure to remove this rule afterward, or you might get
|
|
a nasty surprise when you use Calc to balance your checkbook!)
|
|
|
|
@xref{Rewrite Rules}, for the whole story on rewrite rules.
|
|
|
|
@node Programming Tutorial, Answers to Exercises, Algebra Tutorial, Tutorial
|
|
@section Programming Tutorial
|
|
|
|
@noindent
|
|
The Calculator is written entirely in Emacs Lisp, a highly extensible
|
|
language. If you know Lisp, you can program the Calculator to do
|
|
anything you like. Rewrite rules also work as a powerful programming
|
|
system. But Lisp and rewrite rules take a while to master, and often
|
|
all you want to do is define a new function or repeat a command a few
|
|
times. Calc has features that allow you to do these things easily.
|
|
|
|
One very limited form of programming is defining your own functions.
|
|
Calc's @kbd{Z F} command allows you to define a function name and
|
|
key sequence to correspond to any formula. Programming commands use
|
|
the shift-@kbd{Z} prefix; the user commands they create use the lower
|
|
case @kbd{z} prefix.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1 + x + x^2 / 2 + x^3 / 6 1: 1 + x + x^2 / 2 + x^3 / 6
|
|
. .
|
|
|
|
' 1 + x + x^2/2! + x^3/3! @key{RET} Z F e myexp @key{RET} @key{RET} @key{RET} y
|
|
@end group
|
|
@end smallexample
|
|
|
|
This polynomial is a Taylor series approximation to @samp{exp(x)}.
|
|
The @kbd{Z F} command asks a number of questions. The above answers
|
|
say that the key sequence for our function should be @kbd{z e}; the
|
|
@kbd{M-x} equivalent should be @code{calc-myexp}; the name of the
|
|
function in algebraic formulas should also be @code{myexp}; the
|
|
default argument list @samp{(x)} is acceptable; and finally @kbd{y}
|
|
answers the question ``leave it in symbolic form for non-constant
|
|
arguments?''
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1.3495 2: 1.3495 3: 1.3495
|
|
. 1: 1.34986 2: 1.34986
|
|
. 1: myexp(a + 1)
|
|
.
|
|
|
|
.3 z e .3 E ' a+1 @key{RET} z e
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
First we call our new @code{exp} approximation with 0.3 as an
|
|
argument, and compare it with the true @code{exp} function. Then
|
|
we note that, as requested, if we try to give @kbd{z e} an
|
|
argument that isn't a plain number, it leaves the @code{myexp}
|
|
function call in symbolic form. If we had answered @kbd{n} to the
|
|
final question, @samp{myexp(a + 1)} would have evaluated by plugging
|
|
in @samp{a + 1} for @samp{x} in the defining formula.
|
|
|
|
@cindex Sine integral Si(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Si
|
|
(@bullet{}) @strong{Exercise 1.} The ``sine integral'' function
|
|
@texline @math{{\rm Si}(x)}
|
|
@infoline @expr{Si(x)}
|
|
is defined as the integral of @samp{sin(t)/t} for
|
|
@expr{t = 0} to @expr{x} in radians. (It was invented because this
|
|
integral has no solution in terms of basic functions; if you give it
|
|
to Calc's @kbd{a i} command, it will ponder it for a long time and then
|
|
give up.) We can use the numerical integration command, however,
|
|
which in algebraic notation is written like @samp{ninteg(f(t), t, 0, x)}
|
|
with any integrand @samp{f(t)}. Define a @kbd{z s} command and
|
|
@code{Si} function that implement this. You will need to edit the
|
|
default argument list a bit. As a test, @samp{Si(1)} should return
|
|
0.946083. (If you don't get this answer, you might want to check that
|
|
Calc is in Radians mode. Also, @code{ninteg} will run a lot faster if
|
|
you reduce the precision to, say, six digits beforehand.)
|
|
@xref{Programming Answer 1, 1}. (@bullet{})
|
|
|
|
The simplest way to do real ``programming'' of Emacs is to define a
|
|
@dfn{keyboard macro}. A keyboard macro is simply a sequence of
|
|
keystrokes which Emacs has stored away and can play back on demand.
|
|
For example, if you find yourself typing @kbd{H a S x @key{RET}} often,
|
|
you may wish to program a keyboard macro to type this for you.
|
|
|
|
@smallexample
|
|
@group
|
|
1: y = sqrt(x) 1: x = y^2
|
|
. .
|
|
|
|
' y=sqrt(x) @key{RET} C-x ( H a S x @key{RET} C-x )
|
|
|
|
1: y = cos(x) 1: x = s1 arccos(y) + 2 pi n1
|
|
. .
|
|
|
|
' y=cos(x) @key{RET} X
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
When you type @kbd{C-x (}, Emacs begins recording. But it is also
|
|
still ready to execute your keystrokes, so you're really ``training''
|
|
Emacs by walking it through the procedure once. When you type
|
|
@w{@kbd{C-x )}}, the macro is recorded. You can now type @kbd{X} to
|
|
re-execute the same keystrokes.
|
|
|
|
You can give a name to your macro by typing @kbd{Z K}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: . 1: y = x^4 1: x = s2 sqrt(s1 sqrt(y))
|
|
. .
|
|
|
|
Z K x @key{RET} ' y=x^4 @key{RET} z x
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Notice that we use shift-@kbd{Z} to define the command, and lower-case
|
|
@kbd{z} to call it up.
|
|
|
|
Keyboard macros can call other macros.
|
|
|
|
@smallexample
|
|
@group
|
|
1: abs(x) 1: x = s1 y 1: 2 / x 1: x = 2 / y
|
|
. . . .
|
|
|
|
' abs(x) @key{RET} C-x ( ' y @key{RET} a = z x C-x ) ' 2/x @key{RET} X
|
|
@end group
|
|
@end smallexample
|
|
|
|
(@bullet{}) @strong{Exercise 2.} Define a keyboard macro to negate
|
|
the item in level 3 of the stack, without disturbing the rest of
|
|
the stack. @xref{Programming Answer 2, 2}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 3.} Define keyboard macros to compute
|
|
the following functions:
|
|
|
|
@enumerate
|
|
@item
|
|
Compute
|
|
@texline @math{\displaystyle{\sin x \over x}},
|
|
@infoline @expr{sin(x) / x},
|
|
where @expr{x} is the number on the top of the stack.
|
|
|
|
@item
|
|
Compute the base-@expr{b} logarithm, just like the @kbd{B} key except
|
|
the arguments are taken in the opposite order.
|
|
|
|
@item
|
|
Produce a vector of integers from 1 to the integer on the top of
|
|
the stack.
|
|
@end enumerate
|
|
@noindent
|
|
@xref{Programming Answer 3, 3}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 4.} Define a keyboard macro to compute
|
|
the average (mean) value of a list of numbers.
|
|
@xref{Programming Answer 4, 4}. (@bullet{})
|
|
|
|
In many programs, some of the steps must execute several times.
|
|
Calc has @dfn{looping} commands that allow this. Loops are useful
|
|
inside keyboard macros, but actually work at any time.
|
|
|
|
@smallexample
|
|
@group
|
|
1: x^6 2: x^6 1: 360 x^2
|
|
. 1: 4 .
|
|
.
|
|
|
|
' x^6 @key{RET} 4 Z < a d x @key{RET} Z >
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we have computed the fourth derivative of @expr{x^6} by
|
|
enclosing a derivative command in a ``repeat loop'' structure.
|
|
This structure pops a repeat count from the stack, then
|
|
executes the body of the loop that many times.
|
|
|
|
If you make a mistake while entering the body of the loop,
|
|
type @w{@kbd{Z C-g}} to cancel the loop command.
|
|
|
|
@cindex Fibonacci numbers
|
|
Here's another example:
|
|
|
|
@smallexample
|
|
@group
|
|
3: 1 2: 10946
|
|
2: 1 1: 17711
|
|
1: 20 .
|
|
.
|
|
|
|
1 @key{RET} @key{RET} 20 Z < @key{TAB} C-j + Z >
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The numbers in levels 2 and 1 should be the 21st and 22nd Fibonacci
|
|
numbers, respectively. (To see what's going on, try a few repetitions
|
|
of the loop body by hand; @kbd{C-j}, also on the Line-Feed or @key{LFD}
|
|
key if you have one, makes a copy of the number in level 2.)
|
|
|
|
@cindex Golden ratio
|
|
@cindex Phi, golden ratio
|
|
A fascinating property of the Fibonacci numbers is that the @expr{n}th
|
|
Fibonacci number can be found directly by computing
|
|
@texline @math{\phi^n / \sqrt{5}}
|
|
@infoline @expr{phi^n / sqrt(5)}
|
|
and then rounding to the nearest integer, where
|
|
@texline @math{\phi} (``phi''),
|
|
@infoline @expr{phi},
|
|
the ``golden ratio,'' is
|
|
@texline @math{(1 + \sqrt{5}) / 2}.
|
|
@infoline @expr{(1 + sqrt(5)) / 2}.
|
|
(For convenience, this constant is available from the @code{phi}
|
|
variable, or the @kbd{I H P} command.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1.61803 1: 24476.0000409 1: 10945.9999817 1: 10946
|
|
. . . .
|
|
|
|
I H P 21 ^ 5 Q / R
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex Continued fractions
|
|
(@bullet{}) @strong{Exercise 5.} The @dfn{continued fraction}
|
|
representation of
|
|
@texline @math{\phi}
|
|
@infoline @expr{phi}
|
|
is
|
|
@texline @math{1 + 1/(1 + 1/(1 + 1/( \ldots )))}.
|
|
@infoline @expr{1 + 1/(1 + 1/(1 + 1/( ...@: )))}.
|
|
We can compute an approximate value by carrying this however far
|
|
and then replacing the innermost
|
|
@texline @math{1/( \ldots )}
|
|
@infoline @expr{1/( ...@: )}
|
|
by 1. Approximate
|
|
@texline @math{\phi}
|
|
@infoline @expr{phi}
|
|
using a twenty-term continued fraction.
|
|
@xref{Programming Answer 5, 5}. (@bullet{})
|
|
|
|
(@bullet{}) @strong{Exercise 6.} Linear recurrences like the one for
|
|
Fibonacci numbers can be expressed in terms of matrices. Given a
|
|
vector @w{@expr{[a, b]}} determine a matrix which, when multiplied by this
|
|
vector, produces the vector @expr{[b, c]}, where @expr{a}, @expr{b} and
|
|
@expr{c} are three successive Fibonacci numbers. Now write a program
|
|
that, given an integer @expr{n}, computes the @expr{n}th Fibonacci number
|
|
using matrix arithmetic. @xref{Programming Answer 6, 6}. (@bullet{})
|
|
|
|
@cindex Harmonic numbers
|
|
A more sophisticated kind of loop is the @dfn{for} loop. Suppose
|
|
we wish to compute the 20th ``harmonic'' number, which is equal to
|
|
the sum of the reciprocals of the integers from 1 to 20.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 0 1: 3.597739
|
|
2: 1 .
|
|
1: 20
|
|
.
|
|
|
|
0 @key{RET} 1 @key{RET} 20 Z ( & + 1 Z )
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The ``for'' loop pops two numbers, the lower and upper limits, then
|
|
repeats the body of the loop as an internal counter increases from
|
|
the lower limit to the upper one. Just before executing the loop
|
|
body, it pushes the current loop counter. When the loop body
|
|
finishes, it pops the ``step,'' i.e., the amount by which to
|
|
increment the loop counter. As you can see, our loop always
|
|
uses a step of one.
|
|
|
|
This harmonic number function uses the stack to hold the running
|
|
total as well as for the various loop housekeeping functions. If
|
|
you find this disorienting, you can sum in a variable instead:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0 2: 1 . 1: 3.597739
|
|
. 1: 20 .
|
|
.
|
|
|
|
0 t 7 1 @key{RET} 20 Z ( & s + 7 1 Z ) r 7
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @kbd{s +} command adds the top-of-stack into the value in a
|
|
variable (and removes that value from the stack).
|
|
|
|
It's worth noting that many jobs that call for a ``for'' loop can
|
|
also be done more easily by Calc's high-level operations. Two
|
|
other ways to compute harmonic numbers are to use vector mapping
|
|
and reduction (@kbd{v x 20}, then @w{@kbd{V M &}}, then @kbd{V R +}),
|
|
or to use the summation command @kbd{a +}. Both of these are
|
|
probably easier than using loops. However, there are some
|
|
situations where loops really are the way to go:
|
|
|
|
(@bullet{}) @strong{Exercise 7.} Use a ``for'' loop to find the first
|
|
harmonic number which is greater than 4.0.
|
|
@xref{Programming Answer 7, 7}. (@bullet{})
|
|
|
|
Of course, if we're going to be using variables in our programs,
|
|
we have to worry about the programs clobbering values that the
|
|
caller was keeping in those same variables. This is easy to
|
|
fix, though:
|
|
|
|
@smallexample
|
|
@group
|
|
. 1: 0.6667 1: 0.6667 3: 0.6667
|
|
. . 2: 3.597739
|
|
1: 0.6667
|
|
.
|
|
|
|
Z ` p 4 @key{RET} 2 @key{RET} 3 / s 7 s s a @key{RET} Z ' r 7 s r a @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
When we type @kbd{Z `} (that's a back-quote character), Calc saves
|
|
its mode settings and the contents of the ten ``quick variables''
|
|
for later reference. When we type @kbd{Z '} (that's an apostrophe
|
|
now), Calc restores those saved values. Thus the @kbd{p 4} and
|
|
@kbd{s 7} commands have no effect outside this sequence. Wrapping
|
|
this around the body of a keyboard macro ensures that it doesn't
|
|
interfere with what the user of the macro was doing. Notice that
|
|
the contents of the stack, and the values of named variables,
|
|
survive past the @kbd{Z '} command.
|
|
|
|
@cindex Bernoulli numbers, approximate
|
|
The @dfn{Bernoulli numbers} are a sequence with the interesting
|
|
property that all of the odd Bernoulli numbers are zero, and the
|
|
even ones, while difficult to compute, can be roughly approximated
|
|
by the formula
|
|
@texline @math{\displaystyle{2 n! \over (2 \pi)^n}}.
|
|
@infoline @expr{2 n!@: / (2 pi)^n}.
|
|
Let's write a keyboard macro to compute (approximate) Bernoulli numbers.
|
|
(Calc has a command, @kbd{k b}, to compute exact Bernoulli numbers, but
|
|
this command is very slow for large @expr{n} since the higher Bernoulli
|
|
numbers are very large fractions.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 10 1: 0.0756823
|
|
. .
|
|
|
|
10 C-x ( @key{RET} 2 % Z [ @key{DEL} 0 Z : ' 2 $! / (2 pi)^$ @key{RET} = Z ] C-x )
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
You can read @kbd{Z [} as ``then,'' @kbd{Z :} as ``else,'' and
|
|
@kbd{Z ]} as ``end-if.'' There is no need for an explicit ``if''
|
|
command. For the purposes of @w{@kbd{Z [}}, the condition is ``true''
|
|
if the value it pops from the stack is a nonzero number, or ``false''
|
|
if it pops zero or something that is not a number (like a formula).
|
|
Here we take our integer argument modulo 2; this will be nonzero
|
|
if we're asking for an odd Bernoulli number.
|
|
|
|
The actual tenth Bernoulli number is @expr{5/66}.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 0.0756823 1: 0 1: 0.25305 1: 0 1: 1.16659
|
|
2: 5:66 . . . .
|
|
1: 0.0757575
|
|
.
|
|
|
|
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
|
|
@end group
|
|
@end smallexample
|
|
|
|
Just to exercise loops a bit more, let's compute a table of even
|
|
Bernoulli numbers.
|
|
|
|
@smallexample
|
|
@group
|
|
3: [] 1: [0.10132, 0.03079, 0.02340, 0.033197, ...]
|
|
2: 2 .
|
|
1: 30
|
|
.
|
|
|
|
[ ] 2 @key{RET} 30 Z ( X | 2 Z )
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The vertical-bar @kbd{|} is the vector-concatenation command. When
|
|
we execute it, the list we are building will be in stack level 2
|
|
(initially this is an empty list), and the next Bernoulli number
|
|
will be in level 1. The effect is to append the Bernoulli number
|
|
onto the end of the list. (To create a table of exact fractional
|
|
Bernoulli numbers, just replace @kbd{X} with @kbd{k b} in the above
|
|
sequence of keystrokes.)
|
|
|
|
With loops and conditionals, you can program essentially anything
|
|
in Calc. One other command that makes looping easier is @kbd{Z /},
|
|
which takes a condition from the stack and breaks out of the enclosing
|
|
loop if the condition is true (non-zero). You can use this to make
|
|
``while'' and ``until'' style loops.
|
|
|
|
If you make a mistake when entering a keyboard macro, you can edit
|
|
it using @kbd{Z E}. First, you must attach it to a key with @kbd{Z K}.
|
|
One technique is to enter a throwaway dummy definition for the macro,
|
|
then enter the real one in the edit command.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3 1: 3 Calc Macro Edit Mode.
|
|
. . Original keys: 1 <return> 2 +
|
|
|
|
1 ;; calc digits
|
|
RET ;; calc-enter
|
|
2 ;; calc digits
|
|
+ ;; calc-plus
|
|
|
|
C-x ( 1 @key{RET} 2 + C-x ) Z K h @key{RET} Z E h
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
A keyboard macro is stored as a pure keystroke sequence. The
|
|
@file{edmacro} package (invoked by @kbd{Z E}) scans along the
|
|
macro and tries to decode it back into human-readable steps.
|
|
Descriptions of the keystrokes are given as comments, which begin with
|
|
@samp{;;}, and which are ignored when the edited macro is saved.
|
|
Spaces and line breaks are also ignored when the edited macro is saved.
|
|
To enter a space into the macro, type @code{SPC}. All the special
|
|
characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC}, @code{DEL},
|
|
and @code{NUL} must be written in all uppercase, as must the prefixes
|
|
@code{C-} and @code{M-}.
|
|
|
|
Let's edit in a new definition, for computing harmonic numbers.
|
|
First, erase the four lines of the old definition. Then, type
|
|
in the new definition (or use Emacs @kbd{M-w} and @kbd{C-y} commands
|
|
to copy it from this page of the Info file; you can of course skip
|
|
typing the comments, which begin with @samp{;;}).
|
|
|
|
@smallexample
|
|
Z` ;; calc-kbd-push (Save local values)
|
|
0 ;; calc digits (Push a zero onto the stack)
|
|
st ;; calc-store-into (Store it in the following variable)
|
|
1 ;; calc quick variable (Quick variable q1)
|
|
1 ;; calc digits (Initial value for the loop)
|
|
TAB ;; calc-roll-down (Swap initial and final)
|
|
Z( ;; calc-kbd-for (Begin the "for" loop)
|
|
& ;; calc-inv (Take the reciprocal)
|
|
s+ ;; calc-store-plus (Add to the following variable)
|
|
1 ;; calc quick variable (Quick variable q1)
|
|
1 ;; calc digits (The loop step is 1)
|
|
Z) ;; calc-kbd-end-for (End the "for" loop)
|
|
sr ;; calc-recall (Recall the final accumulated value)
|
|
1 ;; calc quick variable (Quick variable q1)
|
|
Z' ;; calc-kbd-pop (Restore values)
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Press @kbd{C-c C-c} to finish editing and return to the Calculator.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 20 1: 3.597739
|
|
. .
|
|
|
|
20 z h
|
|
@end group
|
|
@end smallexample
|
|
|
|
The @file{edmacro} package defines a handy @code{read-kbd-macro} command
|
|
which reads the current region of the current buffer as a sequence of
|
|
keystroke names, and defines that sequence on the @kbd{X}
|
|
(and @kbd{C-x e}) key. Because this is so useful, Calc puts this
|
|
command on the @kbd{C-x * m} key. Try reading in this macro in the
|
|
following form: Press @kbd{C-@@} (or @kbd{C-@key{SPC}}) at
|
|
one end of the text below, then type @kbd{C-x * m} at the other.
|
|
|
|
@example
|
|
@group
|
|
Z ` 0 t 1
|
|
1 TAB
|
|
Z ( & s + 1 1 Z )
|
|
r 1
|
|
Z '
|
|
@end group
|
|
@end example
|
|
|
|
(@bullet{}) @strong{Exercise 8.} A general algorithm for solving
|
|
equations numerically is @dfn{Newton's Method}. Given the equation
|
|
@expr{f(x) = 0} for any function @expr{f}, and an initial guess
|
|
@expr{x_0} which is reasonably close to the desired solution, apply
|
|
this formula over and over:
|
|
|
|
@ifinfo
|
|
@example
|
|
new_x = x - f(x)/f'(x)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\beforedisplay
|
|
$$ x_{\rm new} = x - {f(x) \over f'(x)} $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
where @expr{f'(x)} is the derivative of @expr{f}. The @expr{x}
|
|
values will quickly converge to a solution, i.e., eventually
|
|
@texline @math{x_{\rm new}}
|
|
@infoline @expr{new_x}
|
|
and @expr{x} will be equal to within the limits
|
|
of the current precision. Write a program which takes a formula
|
|
involving the variable @expr{x}, and an initial guess @expr{x_0},
|
|
on the stack, and produces a value of @expr{x} for which the formula
|
|
is zero. Use it to find a solution of
|
|
@texline @math{\sin(\cos x) = 0.5}
|
|
@infoline @expr{sin(cos(x)) = 0.5}
|
|
near @expr{x = 4.5}. (Use angles measured in radians.) Note that
|
|
the built-in @w{@kbd{a R}} (@code{calc-find-root}) command uses Newton's
|
|
method when it is able. @xref{Programming Answer 8, 8}. (@bullet{})
|
|
|
|
@cindex Digamma function
|
|
@cindex Gamma constant, Euler's
|
|
@cindex Euler's gamma constant
|
|
(@bullet{}) @strong{Exercise 9.} The @dfn{digamma} function
|
|
@texline @math{\psi(z) (``psi'')}
|
|
@infoline @expr{psi(z)}
|
|
is defined as the derivative of
|
|
@texline @math{\ln \Gamma(z)}.
|
|
@infoline @expr{ln(gamma(z))}.
|
|
For large values of @expr{z}, it can be approximated by the infinite sum
|
|
|
|
@ifinfo
|
|
@example
|
|
psi(z) ~= ln(z) - 1/2z - sum(bern(2 n) / 2 n z^(2 n), n, 1, inf)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\beforedisplay
|
|
$$ \psi(z) \approx \ln z - {1\over2z} -
|
|
\sum_{n=1}^\infty {\code{bern}(2 n) \over 2 n z^{2n}}
|
|
$$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
where
|
|
@texline @math{\sum}
|
|
@infoline @expr{sum}
|
|
represents the sum over @expr{n} from 1 to infinity
|
|
(or to some limit high enough to give the desired accuracy), and
|
|
the @code{bern} function produces (exact) Bernoulli numbers.
|
|
While this sum is not guaranteed to converge, in practice it is safe.
|
|
An interesting mathematical constant is Euler's gamma, which is equal
|
|
to about 0.5772. One way to compute it is by the formula,
|
|
@texline @math{\gamma = -\psi(1)}.
|
|
@infoline @expr{gamma = -psi(1)}.
|
|
Unfortunately, 1 isn't a large enough argument
|
|
for the above formula to work (5 is a much safer value for @expr{z}).
|
|
Fortunately, we can compute
|
|
@texline @math{\psi(1)}
|
|
@infoline @expr{psi(1)}
|
|
from
|
|
@texline @math{\psi(5)}
|
|
@infoline @expr{psi(5)}
|
|
using the recurrence
|
|
@texline @math{\psi(z+1) = \psi(z) + {1 \over z}}.
|
|
@infoline @expr{psi(z+1) = psi(z) + 1/z}.
|
|
Your task: Develop a program to compute
|
|
@texline @math{\psi(z)};
|
|
@infoline @expr{psi(z)};
|
|
it should ``pump up'' @expr{z}
|
|
if necessary to be greater than 5, then use the above summation
|
|
formula. Use looping commands to compute the sum. Use your function
|
|
to compute
|
|
@texline @math{\gamma}
|
|
@infoline @expr{gamma}
|
|
to twelve decimal places. (Calc has a built-in command
|
|
for Euler's constant, @kbd{I P}, which you can use to check your answer.)
|
|
@xref{Programming Answer 9, 9}. (@bullet{})
|
|
|
|
@cindex Polynomial, list of coefficients
|
|
(@bullet{}) @strong{Exercise 10.} Given a polynomial in @expr{x} and
|
|
a number @expr{m} on the stack, where the polynomial is of degree
|
|
@expr{m} or less (i.e., does not have any terms higher than @expr{x^m}),
|
|
write a program to convert the polynomial into a list-of-coefficients
|
|
notation. For example, @expr{5 x^4 + (x + 1)^2} with @expr{m = 6}
|
|
should produce the list @expr{[1, 2, 1, 0, 5, 0, 0]}. Also develop
|
|
a way to convert from this form back to the standard algebraic form.
|
|
@xref{Programming Answer 10, 10}. (@bullet{})
|
|
|
|
@cindex Recursion
|
|
(@bullet{}) @strong{Exercise 11.} The @dfn{Stirling numbers of the
|
|
first kind} are defined by the recurrences,
|
|
|
|
@ifinfo
|
|
@example
|
|
s(n,n) = 1 for n >= 0,
|
|
s(n,0) = 0 for n > 0,
|
|
s(n+1,m) = s(n,m-1) - n s(n,m) for n >= m >= 1.
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \eqalign{ s(n,n) &= 1 \qquad \hbox{for } n \ge 0, \cr
|
|
s(n,0) &= 0 \qquad \hbox{for } n > 0, \cr
|
|
s(n+1,m) &= s(n,m-1) - n \, s(n,m) \qquad
|
|
\hbox{for } n \ge m \ge 1.}
|
|
$$
|
|
\afterdisplay
|
|
\vskip5pt
|
|
(These numbers are also sometimes written $\displaystyle{n \brack m}$.)
|
|
@end tex
|
|
|
|
This can be implemented using a @dfn{recursive} program in Calc; the
|
|
program must invoke itself in order to calculate the two righthand
|
|
terms in the general formula. Since it always invokes itself with
|
|
``simpler'' arguments, it's easy to see that it must eventually finish
|
|
the computation. Recursion is a little difficult with Emacs keyboard
|
|
macros since the macro is executed before its definition is complete.
|
|
So here's the recommended strategy: Create a ``dummy macro'' and assign
|
|
it to a key with, e.g., @kbd{Z K s}. Now enter the true definition,
|
|
using the @kbd{z s} command to call itself recursively, then assign it
|
|
to the same key with @kbd{Z K s}. Now the @kbd{z s} command will run
|
|
the complete recursive program. (Another way is to use @w{@kbd{Z E}}
|
|
or @kbd{C-x * m} (@code{read-kbd-macro}) to read the whole macro at once,
|
|
thus avoiding the ``training'' phase.) The task: Write a program
|
|
that computes Stirling numbers of the first kind, given @expr{n} and
|
|
@expr{m} on the stack. Test it with @emph{small} inputs like
|
|
@expr{s(4,2)}. (There is a built-in command for Stirling numbers,
|
|
@kbd{k s}, which you can use to check your answers.)
|
|
@xref{Programming Answer 11, 11}. (@bullet{})
|
|
|
|
The programming commands we've seen in this part of the tutorial
|
|
are low-level, general-purpose operations. Often you will find
|
|
that a higher-level function, such as vector mapping or rewrite
|
|
rules, will do the job much more easily than a detailed, step-by-step
|
|
program can:
|
|
|
|
(@bullet{}) @strong{Exercise 12.} Write another program for
|
|
computing Stirling numbers of the first kind, this time using
|
|
rewrite rules. Once again, @expr{n} and @expr{m} should be taken
|
|
from the stack. @xref{Programming Answer 12, 12}. (@bullet{})
|
|
|
|
@example
|
|
|
|
@end example
|
|
This ends the tutorial section of the Calc manual. Now you know enough
|
|
about Calc to use it effectively for many kinds of calculations. But
|
|
Calc has many features that were not even touched upon in this tutorial.
|
|
@c [not-split]
|
|
The rest of this manual tells the whole story.
|
|
@c [when-split]
|
|
@c Volume II of this manual, the @dfn{Calc Reference}, tells the whole story.
|
|
|
|
@page
|
|
@node Answers to Exercises, , Programming Tutorial, Tutorial
|
|
@section Answers to Exercises
|
|
|
|
@noindent
|
|
This section includes answers to all the exercises in the Calc tutorial.
|
|
|
|
@menu
|
|
* RPN Answer 1:: 1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -
|
|
* RPN Answer 2:: 2*4 + 7*9.5 + 5/4
|
|
* RPN Answer 3:: Operating on levels 2 and 3
|
|
* RPN Answer 4:: Joe's complex problems
|
|
* Algebraic Answer 1:: Simulating Q command
|
|
* Algebraic Answer 2:: Joe's algebraic woes
|
|
* Algebraic Answer 3:: 1 / 0
|
|
* Modes Answer 1:: 3#0.1 = 3#0.0222222?
|
|
* Modes Answer 2:: 16#f.e8fe15
|
|
* Modes Answer 3:: Joe's rounding bug
|
|
* Modes Answer 4:: Why floating point?
|
|
* Arithmetic Answer 1:: Why the \ command?
|
|
* Arithmetic Answer 2:: Tripping up the B command
|
|
* Vector Answer 1:: Normalizing a vector
|
|
* Vector Answer 2:: Average position
|
|
* Matrix Answer 1:: Row and column sums
|
|
* Matrix Answer 2:: Symbolic system of equations
|
|
* Matrix Answer 3:: Over-determined system
|
|
* List Answer 1:: Powers of two
|
|
* List Answer 2:: Least-squares fit with matrices
|
|
* List Answer 3:: Geometric mean
|
|
* List Answer 4:: Divisor function
|
|
* List Answer 5:: Duplicate factors
|
|
* List Answer 6:: Triangular list
|
|
* List Answer 7:: Another triangular list
|
|
* List Answer 8:: Maximum of Bessel function
|
|
* List Answer 9:: Integers the hard way
|
|
* List Answer 10:: All elements equal
|
|
* List Answer 11:: Estimating pi with darts
|
|
* List Answer 12:: Estimating pi with matchsticks
|
|
* List Answer 13:: Hash codes
|
|
* List Answer 14:: Random walk
|
|
* Types Answer 1:: Square root of pi times rational
|
|
* Types Answer 2:: Infinities
|
|
* Types Answer 3:: What can "nan" be?
|
|
* Types Answer 4:: Abbey Road
|
|
* Types Answer 5:: Friday the 13th
|
|
* Types Answer 6:: Leap years
|
|
* Types Answer 7:: Erroneous donut
|
|
* Types Answer 8:: Dividing intervals
|
|
* Types Answer 9:: Squaring intervals
|
|
* Types Answer 10:: Fermat's primality test
|
|
* Types Answer 11:: pi * 10^7 seconds
|
|
* Types Answer 12:: Abbey Road on CD
|
|
* Types Answer 13:: Not quite pi * 10^7 seconds
|
|
* Types Answer 14:: Supercomputers and c
|
|
* Types Answer 15:: Sam the Slug
|
|
* Algebra Answer 1:: Squares and square roots
|
|
* Algebra Answer 2:: Building polynomial from roots
|
|
* Algebra Answer 3:: Integral of x sin(pi x)
|
|
* Algebra Answer 4:: Simpson's rule
|
|
* Rewrites Answer 1:: Multiplying by conjugate
|
|
* Rewrites Answer 2:: Alternative fib rule
|
|
* Rewrites Answer 3:: Rewriting opt(a) + opt(b) x
|
|
* Rewrites Answer 4:: Sequence of integers
|
|
* Rewrites Answer 5:: Number of terms in sum
|
|
* Rewrites Answer 6:: Truncated Taylor series
|
|
* Programming Answer 1:: Fresnel's C(x)
|
|
* Programming Answer 2:: Negate third stack element
|
|
* Programming Answer 3:: Compute sin(x) / x, etc.
|
|
* Programming Answer 4:: Average value of a list
|
|
* Programming Answer 5:: Continued fraction phi
|
|
* Programming Answer 6:: Matrix Fibonacci numbers
|
|
* Programming Answer 7:: Harmonic number greater than 4
|
|
* Programming Answer 8:: Newton's method
|
|
* Programming Answer 9:: Digamma function
|
|
* Programming Answer 10:: Unpacking a polynomial
|
|
* Programming Answer 11:: Recursive Stirling numbers
|
|
* Programming Answer 12:: Stirling numbers with rewrites
|
|
@end menu
|
|
|
|
@c The following kludgery prevents the individual answers from
|
|
@c being entered on the table of contents.
|
|
@tex
|
|
\global\let\oldwrite=\write
|
|
\gdef\skipwrite#1#2{\let\write=\oldwrite}
|
|
\global\let\oldchapternofonts=\chapternofonts
|
|
\gdef\chapternofonts{\let\write=\skipwrite\oldchapternofonts}
|
|
@end tex
|
|
|
|
@node RPN Answer 1, RPN Answer 2, Answers to Exercises, Answers to Exercises
|
|
@subsection RPN Tutorial Exercise 1
|
|
|
|
@noindent
|
|
@kbd{1 @key{RET} 2 @key{RET} 3 @key{RET} 4 + * -}
|
|
|
|
The result is
|
|
@texline @math{1 - (2 \times (3 + 4)) = -13}.
|
|
@infoline @expr{1 - (2 * (3 + 4)) = -13}.
|
|
|
|
@node RPN Answer 2, RPN Answer 3, RPN Answer 1, Answers to Exercises
|
|
@subsection RPN Tutorial Exercise 2
|
|
|
|
@noindent
|
|
@texline @math{2\times4 + 7\times9.5 + {5\over4} = 75.75}
|
|
@infoline @expr{2*4 + 7*9.5 + 5/4 = 75.75}
|
|
|
|
After computing the intermediate term
|
|
@texline @math{2\times4 = 8},
|
|
@infoline @expr{2*4 = 8},
|
|
you can leave that result on the stack while you compute the second
|
|
term. With both of these results waiting on the stack you can then
|
|
compute the final term, then press @kbd{+ +} to add everything up.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 2 1: 8 3: 8 2: 8
|
|
1: 4 . 2: 7 1: 66.5
|
|
. 1: 9.5 .
|
|
.
|
|
|
|
2 @key{RET} 4 * 7 @key{RET} 9.5 *
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
4: 8 3: 8 2: 8 1: 75.75
|
|
3: 66.5 2: 66.5 1: 67.75 .
|
|
2: 5 1: 1.25 .
|
|
1: 4 .
|
|
.
|
|
|
|
5 @key{RET} 4 / + +
|
|
@end group
|
|
@end smallexample
|
|
|
|
Alternatively, you could add the first two terms before going on
|
|
with the third term.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 8 1: 74.5 3: 74.5 2: 74.5 1: 75.75
|
|
1: 66.5 . 2: 5 1: 1.25 .
|
|
. 1: 4 .
|
|
.
|
|
|
|
... + 5 @key{RET} 4 / +
|
|
@end group
|
|
@end smallexample
|
|
|
|
On an old-style RPN calculator this second method would have the
|
|
advantage of using only three stack levels. But since Calc's stack
|
|
can grow arbitrarily large this isn't really an issue. Which method
|
|
you choose is purely a matter of taste.
|
|
|
|
@node RPN Answer 3, RPN Answer 4, RPN Answer 2, Answers to Exercises
|
|
@subsection RPN Tutorial Exercise 3
|
|
|
|
@noindent
|
|
The @key{TAB} key provides a way to operate on the number in level 2.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 10 3: 10 4: 10 3: 10 3: 10
|
|
2: 20 2: 30 3: 30 2: 30 2: 21
|
|
1: 30 1: 20 2: 20 1: 21 1: 30
|
|
. . 1: 1 . .
|
|
.
|
|
|
|
@key{TAB} 1 + @key{TAB}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Similarly, @kbd{M-@key{TAB}} gives you access to the number in level 3.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 10 3: 21 3: 21 3: 30 3: 11
|
|
2: 21 2: 30 2: 30 2: 11 2: 21
|
|
1: 30 1: 10 1: 11 1: 21 1: 30
|
|
. . . . .
|
|
|
|
M-@key{TAB} 1 + M-@key{TAB} M-@key{TAB}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node RPN Answer 4, Algebraic Answer 1, RPN Answer 3, Answers to Exercises
|
|
@subsection RPN Tutorial Exercise 4
|
|
|
|
@noindent
|
|
Either @kbd{( 2 , 3 )} or @kbd{( 2 @key{SPC} 3 )} would have worked,
|
|
but using both the comma and the space at once yields:
|
|
|
|
@smallexample
|
|
@group
|
|
1: ( ... 2: ( ... 1: (2, ... 2: (2, ... 2: (2, ...
|
|
. 1: 2 . 1: (2, ... 1: (2, 3)
|
|
. . .
|
|
|
|
( 2 , @key{SPC} 3 )
|
|
@end group
|
|
@end smallexample
|
|
|
|
Joe probably tried to type @kbd{@key{TAB} @key{DEL}} to swap the
|
|
extra incomplete object to the top of the stack and delete it.
|
|
But a feature of Calc is that @key{DEL} on an incomplete object
|
|
deletes just one component out of that object, so he had to press
|
|
@key{DEL} twice to finish the job.
|
|
|
|
@smallexample
|
|
@group
|
|
2: (2, ... 2: (2, 3) 2: (2, 3) 1: (2, 3)
|
|
1: (2, 3) 1: (2, ... 1: ( ... .
|
|
. . .
|
|
|
|
@key{TAB} @key{DEL} @key{DEL}
|
|
@end group
|
|
@end smallexample
|
|
|
|
(As it turns out, deleting the second-to-top stack entry happens often
|
|
enough that Calc provides a special key, @kbd{M-@key{DEL}}, to do just that.
|
|
@kbd{M-@key{DEL}} is just like @kbd{@key{TAB} @key{DEL}}, except that it doesn't exhibit
|
|
the ``feature'' that tripped poor Joe.)
|
|
|
|
@node Algebraic Answer 1, Algebraic Answer 2, RPN Answer 4, Answers to Exercises
|
|
@subsection Algebraic Entry Tutorial Exercise 1
|
|
|
|
@noindent
|
|
Type @kbd{' sqrt($) @key{RET}}.
|
|
|
|
If the @kbd{Q} key is broken, you could use @kbd{' $^0.5 @key{RET}}.
|
|
Or, RPN style, @kbd{0.5 ^}.
|
|
|
|
(Actually, @samp{$^1:2}, using the fraction one-half as the power, is
|
|
a closer equivalent, since @samp{9^0.5} yields @expr{3.0} whereas
|
|
@samp{sqrt(9)} and @samp{9^1:2} yield the exact integer @expr{3}.)
|
|
|
|
@node Algebraic Answer 2, Algebraic Answer 3, Algebraic Answer 1, Answers to Exercises
|
|
@subsection Algebraic Entry Tutorial Exercise 2
|
|
|
|
@noindent
|
|
In the formula @samp{2 x (1+y)}, @samp{x} was interpreted as a function
|
|
name with @samp{1+y} as its argument. Assigning a value to a variable
|
|
has no relation to a function by the same name. Joe needed to use an
|
|
explicit @samp{*} symbol here: @samp{2 x*(1+y)}.
|
|
|
|
@node Algebraic Answer 3, Modes Answer 1, Algebraic Answer 2, Answers to Exercises
|
|
@subsection Algebraic Entry Tutorial Exercise 3
|
|
|
|
@noindent
|
|
The result from @kbd{1 @key{RET} 0 /} will be the formula @expr{1 / 0}.
|
|
The ``function'' @samp{/} cannot be evaluated when its second argument
|
|
is zero, so it is left in symbolic form. When you now type @kbd{0 *},
|
|
the result will be zero because Calc uses the general rule that ``zero
|
|
times anything is zero.''
|
|
|
|
@c [fix-ref Infinities]
|
|
The @kbd{m i} command enables an @dfn{Infinite mode} in which @expr{1 / 0}
|
|
results in a special symbol that represents ``infinity.'' If you
|
|
multiply infinity by zero, Calc uses another special new symbol to
|
|
show that the answer is ``indeterminate.'' @xref{Infinities}, for
|
|
further discussion of infinite and indeterminate values.
|
|
|
|
@node Modes Answer 1, Modes Answer 2, Algebraic Answer 3, Answers to Exercises
|
|
@subsection Modes Tutorial Exercise 1
|
|
|
|
@noindent
|
|
Calc always stores its numbers in decimal, so even though one-third has
|
|
an exact base-3 representation (@samp{3#0.1}), it is still stored as
|
|
0.3333333 (chopped off after 12 or however many decimal digits) inside
|
|
the calculator's memory. When this inexact number is converted back
|
|
to base 3 for display, it may still be slightly inexact. When we
|
|
multiply this number by 3, we get 0.999999, also an inexact value.
|
|
|
|
When Calc displays a number in base 3, it has to decide how many digits
|
|
to show. If the current precision is 12 (decimal) digits, that corresponds
|
|
to @samp{12 / log10(3) = 25.15} base-3 digits. Because 25.15 is not an
|
|
exact integer, Calc shows only 25 digits, with the result that stored
|
|
numbers carry a little bit of extra information that may not show up on
|
|
the screen. When Joe entered @samp{3#0.2}, the stored number 0.666666
|
|
happened to round to a pleasing value when it lost that last 0.15 of a
|
|
digit, but it was still inexact in Calc's memory. When he divided by 2,
|
|
he still got the dreaded inexact value 0.333333. (Actually, he divided
|
|
0.666667 by 2 to get 0.333334, which is why he got something a little
|
|
higher than @code{3#0.1} instead of a little lower.)
|
|
|
|
If Joe didn't want to be bothered with all this, he could have typed
|
|
@kbd{M-24 d n} to display with one less digit than the default. (If
|
|
you give @kbd{d n} a negative argument, it uses default-minus-that,
|
|
so @kbd{M-- d n} would be an easier way to get the same effect.) Those
|
|
inexact results would still be lurking there, but they would now be
|
|
rounded to nice, natural-looking values for display purposes. (Remember,
|
|
@samp{0.022222} in base 3 is like @samp{0.099999} in base 10; rounding
|
|
off one digit will round the number up to @samp{0.1}.) Depending on the
|
|
nature of your work, this hiding of the inexactness may be a benefit or
|
|
a danger. With the @kbd{d n} command, Calc gives you the choice.
|
|
|
|
Incidentally, another consequence of all this is that if you type
|
|
@kbd{M-30 d n} to display more digits than are ``really there,''
|
|
you'll see garbage digits at the end of the number. (In decimal
|
|
display mode, with decimally-stored numbers, these garbage digits are
|
|
always zero so they vanish and you don't notice them.) Because Calc
|
|
rounds off that 0.15 digit, there is the danger that two numbers could
|
|
be slightly different internally but still look the same. If you feel
|
|
uneasy about this, set the @kbd{d n} precision to be a little higher
|
|
than normal; you'll get ugly garbage digits, but you'll always be able
|
|
to tell two distinct numbers apart.
|
|
|
|
An interesting side note is that most computers store their
|
|
floating-point numbers in binary, and convert to decimal for display.
|
|
Thus everyday programs have the same problem: Decimal 0.1 cannot be
|
|
represented exactly in binary (try it: @kbd{0.1 d 2}), so @samp{0.1 * 10}
|
|
comes out as an inexact approximation to 1 on some machines (though
|
|
they generally arrange to hide it from you by rounding off one digit as
|
|
we did above). Because Calc works in decimal instead of binary, you can
|
|
be sure that numbers that look exact @emph{are} exact as long as you stay
|
|
in decimal display mode.
|
|
|
|
It's not hard to show that any number that can be represented exactly
|
|
in binary, octal, or hexadecimal is also exact in decimal, so the kinds
|
|
of problems we saw in this exercise are likely to be severe only when
|
|
you use a relatively unusual radix like 3.
|
|
|
|
@node Modes Answer 2, Modes Answer 3, Modes Answer 1, Answers to Exercises
|
|
@subsection Modes Tutorial Exercise 2
|
|
|
|
If the radix is 15 or higher, we can't use the letter @samp{e} to mark
|
|
the exponent because @samp{e} is interpreted as a digit. When Calc
|
|
needs to display scientific notation in a high radix, it writes
|
|
@samp{16#F.E8F*16.^15}. You can enter a number like this as an
|
|
algebraic entry. Also, pressing @kbd{e} without any digits before it
|
|
normally types @kbd{1e}, but in a high radix it types @kbd{16.^} and
|
|
puts you in algebraic entry: @kbd{16#f.e8f @key{RET} e 15 @key{RET} *} is another
|
|
way to enter this number.
|
|
|
|
The reason Calc puts a decimal point in the @samp{16.^} is to prevent
|
|
huge integers from being generated if the exponent is large (consider
|
|
@samp{16#1.23*16^1000}, where we compute @samp{16^1000} as a giant
|
|
exact integer and then throw away most of the digits when we multiply
|
|
it by the floating-point @samp{16#1.23}). While this wouldn't normally
|
|
matter for display purposes, it could give you a nasty surprise if you
|
|
copied that number into a file and later moved it back into Calc.
|
|
|
|
@node Modes Answer 3, Modes Answer 4, Modes Answer 2, Answers to Exercises
|
|
@subsection Modes Tutorial Exercise 3
|
|
|
|
@noindent
|
|
The answer he got was @expr{0.5000000000006399}.
|
|
|
|
The problem is not that the square operation is inexact, but that the
|
|
sine of 45 that was already on the stack was accurate to only 12 places.
|
|
Arbitrary-precision calculations still only give answers as good as
|
|
their inputs.
|
|
|
|
The real problem is that there is no 12-digit number which, when
|
|
squared, comes out to 0.5 exactly. The @kbd{f [} and @kbd{f ]}
|
|
commands decrease or increase a number by one unit in the last
|
|
place (according to the current precision). They are useful for
|
|
determining facts like this.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.707106781187 1: 0.500000000001
|
|
. .
|
|
|
|
45 S 2 ^
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 0.707106781187 1: 0.707106781186 1: 0.499999999999
|
|
. . .
|
|
|
|
U @key{DEL} f [ 2 ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
A high-precision calculation must be carried out in high precision
|
|
all the way. The only number in the original problem which was known
|
|
exactly was the quantity 45 degrees, so the precision must be raised
|
|
before anything is done after the number 45 has been entered in order
|
|
for the higher precision to be meaningful.
|
|
|
|
@node Modes Answer 4, Arithmetic Answer 1, Modes Answer 3, Answers to Exercises
|
|
@subsection Modes Tutorial Exercise 4
|
|
|
|
@noindent
|
|
Many calculations involve real-world quantities, like the width and
|
|
height of a piece of wood or the volume of a jar. Such quantities
|
|
can't be measured exactly anyway, and if the data that is input to
|
|
a calculation is inexact, doing exact arithmetic on it is a waste
|
|
of time.
|
|
|
|
Fractions become unwieldy after too many calculations have been
|
|
done with them. For example, the sum of the reciprocals of the
|
|
integers from 1 to 10 is 7381:2520. The sum from 1 to 30 is
|
|
9304682830147:2329089562800. After a point it will take a long
|
|
time to add even one more term to this sum, but a floating-point
|
|
calculation of the sum will not have this problem.
|
|
|
|
Also, rational numbers cannot express the results of all calculations.
|
|
There is no fractional form for the square root of two, so if you type
|
|
@w{@kbd{2 Q}}, Calc has no choice but to give you a floating-point answer.
|
|
|
|
@node Arithmetic Answer 1, Arithmetic Answer 2, Modes Answer 4, Answers to Exercises
|
|
@subsection Arithmetic Tutorial Exercise 1
|
|
|
|
@noindent
|
|
Dividing two integers that are larger than the current precision may
|
|
give a floating-point result that is inaccurate even when rounded
|
|
down to an integer. Consider @expr{123456789 / 2} when the current
|
|
precision is 6 digits. The true answer is @expr{61728394.5}, but
|
|
with a precision of 6 this will be rounded to
|
|
@texline @math{12345700.0/2.0 = 61728500.0}.
|
|
@infoline @expr{12345700.@: / 2.@: = 61728500.}.
|
|
The result, when converted to an integer, will be off by 106.
|
|
|
|
Here are two solutions: Raise the precision enough that the
|
|
floating-point round-off error is strictly to the right of the
|
|
decimal point. Or, convert to Fraction mode so that @expr{123456789 / 2}
|
|
produces the exact fraction @expr{123456789:2}, which can be rounded
|
|
down by the @kbd{F} command without ever switching to floating-point
|
|
format.
|
|
|
|
@node Arithmetic Answer 2, Vector Answer 1, Arithmetic Answer 1, Answers to Exercises
|
|
@subsection Arithmetic Tutorial Exercise 2
|
|
|
|
@noindent
|
|
@kbd{27 @key{RET} 9 B} could give the exact result @expr{3:2}, but it
|
|
does a floating-point calculation instead and produces @expr{1.5}.
|
|
|
|
Calc will find an exact result for a logarithm if the result is an integer
|
|
or (when in Fraction mode) the reciprocal of an integer. But there is
|
|
no efficient way to search the space of all possible rational numbers
|
|
for an exact answer, so Calc doesn't try.
|
|
|
|
@node Vector Answer 1, Vector Answer 2, Arithmetic Answer 2, Answers to Exercises
|
|
@subsection Vector Tutorial Exercise 1
|
|
|
|
@noindent
|
|
Duplicate the vector, compute its length, then divide the vector
|
|
by its length: @kbd{@key{RET} A /}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3] 2: [1, 2, 3] 1: [0.27, 0.53, 0.80] 1: 1.
|
|
. 1: 3.74165738677 . .
|
|
.
|
|
|
|
r 1 @key{RET} A / A
|
|
@end group
|
|
@end smallexample
|
|
|
|
The final @kbd{A} command shows that the normalized vector does
|
|
indeed have unit length.
|
|
|
|
@node Vector Answer 2, Matrix Answer 1, Vector Answer 1, Answers to Exercises
|
|
@subsection Vector Tutorial Exercise 2
|
|
|
|
@noindent
|
|
The average position is equal to the sum of the products of the
|
|
positions times their corresponding probabilities. This is the
|
|
definition of the dot product operation. So all you need to do
|
|
is to put the two vectors on the stack and press @kbd{*}.
|
|
|
|
@node Matrix Answer 1, Matrix Answer 2, Vector Answer 2, Answers to Exercises
|
|
@subsection Matrix Tutorial Exercise 1
|
|
|
|
@noindent
|
|
The trick is to multiply by a vector of ones. Use @kbd{r 4 [1 1 1] *} to
|
|
get the row sum. Similarly, use @kbd{[1 1] r 4 *} to get the column sum.
|
|
|
|
@node Matrix Answer 2, Matrix Answer 3, Matrix Answer 1, Answers to Exercises
|
|
@subsection Matrix Tutorial Exercise 2
|
|
|
|
@ifinfo
|
|
@example
|
|
@group
|
|
x + a y = 6
|
|
x + b y = 10
|
|
@end group
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \eqalign{ x &+ a y = 6 \cr
|
|
x &+ b y = 10}
|
|
$$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
Just enter the righthand side vector, then divide by the lefthand side
|
|
matrix as usual.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [6, 10] 2: [6, 10] 1: [6 - 4 a / (b - a), 4 / (b - a) ]
|
|
. 1: [ [ 1, a ] .
|
|
[ 1, b ] ]
|
|
.
|
|
|
|
' [6 10] @key{RET} ' [1 a; 1 b] @key{RET} /
|
|
@end group
|
|
@end smallexample
|
|
|
|
This can be made more readable using @kbd{d B} to enable Big display
|
|
mode:
|
|
|
|
@smallexample
|
|
@group
|
|
4 a 4
|
|
1: [6 - -----, -----]
|
|
b - a b - a
|
|
@end group
|
|
@end smallexample
|
|
|
|
Type @kbd{d N} to return to Normal display mode afterwards.
|
|
|
|
@node Matrix Answer 3, List Answer 1, Matrix Answer 2, Answers to Exercises
|
|
@subsection Matrix Tutorial Exercise 3
|
|
|
|
@noindent
|
|
To solve
|
|
@texline @math{A^T A \, X = A^T B},
|
|
@infoline @expr{trn(A) * A * X = trn(A) * B},
|
|
first we compute
|
|
@texline @math{A' = A^T A}
|
|
@infoline @expr{A2 = trn(A) * A}
|
|
and
|
|
@texline @math{B' = A^T B};
|
|
@infoline @expr{B2 = trn(A) * B};
|
|
now, we have a system
|
|
@texline @math{A' X = B'}
|
|
@infoline @expr{A2 * X = B2}
|
|
which we can solve using Calc's @samp{/} command.
|
|
|
|
@ifinfo
|
|
@example
|
|
@group
|
|
a + 2b + 3c = 6
|
|
4a + 5b + 6c = 2
|
|
7a + 6b = 3
|
|
2a + 4b + 6c = 11
|
|
@end group
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplayh
|
|
$$ \openup1\jot \tabskip=0pt plus1fil
|
|
\halign to\displaywidth{\tabskip=0pt
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&$\hfil{}#{}$&
|
|
$\hfil#$&${}#\hfil$\tabskip=0pt plus1fil\cr
|
|
a&+&2b&+&3c&=6 \cr
|
|
4a&+&5b&+&6c&=2 \cr
|
|
7a&+&6b& & &=3 \cr
|
|
2a&+&4b&+&6c&=11 \cr}
|
|
$$
|
|
\afterdisplayh
|
|
@end tex
|
|
|
|
The first step is to enter the coefficient matrix. We'll store it in
|
|
quick variable number 7 for later reference. Next, we compute the
|
|
@texline @math{B'}
|
|
@infoline @expr{B2}
|
|
vector.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [ 1, 2, 3 ] 2: [ [ 1, 4, 7, 2 ] 1: [57, 84, 96]
|
|
[ 4, 5, 6 ] [ 2, 5, 6, 4 ] .
|
|
[ 7, 6, 0 ] [ 3, 6, 0, 6 ] ]
|
|
[ 2, 4, 6 ] ] 1: [6, 2, 3, 11]
|
|
. .
|
|
|
|
' [1 2 3; 4 5 6; 7 6 0; 2 4 6] @key{RET} s 7 v t [6 2 3 11] *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now we compute the matrix
|
|
@texline @math{A'}
|
|
@infoline @expr{A2}
|
|
and divide.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [57, 84, 96] 1: [-11.64, 14.08, -3.64]
|
|
1: [ [ 70, 72, 39 ] .
|
|
[ 72, 81, 60 ]
|
|
[ 39, 60, 81 ] ]
|
|
.
|
|
|
|
r 7 v t r 7 * /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(The actual computed answer will be slightly inexact due to
|
|
round-off error.)
|
|
|
|
Notice that the answers are similar to those for the
|
|
@texline @math{3\times3}
|
|
@infoline 3x3
|
|
system solved in the text. That's because the fourth equation that was
|
|
added to the system is almost identical to the first one multiplied
|
|
by two. (If it were identical, we would have gotten the exact same
|
|
answer since the
|
|
@texline @math{4\times3}
|
|
@infoline 4x3
|
|
system would be equivalent to the original
|
|
@texline @math{3\times3}
|
|
@infoline 3x3
|
|
system.)
|
|
|
|
Since the first and fourth equations aren't quite equivalent, they
|
|
can't both be satisfied at once. Let's plug our answers back into
|
|
the original system of equations to see how well they match.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [-11.64, 14.08, -3.64] 1: [5.6, 2., 3., 11.2]
|
|
1: [ [ 1, 2, 3 ] .
|
|
[ 4, 5, 6 ]
|
|
[ 7, 6, 0 ]
|
|
[ 2, 4, 6 ] ]
|
|
.
|
|
|
|
r 7 @key{TAB} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This is reasonably close to our original @expr{B} vector,
|
|
@expr{[6, 2, 3, 11]}.
|
|
|
|
@node List Answer 1, List Answer 2, Matrix Answer 3, Answers to Exercises
|
|
@subsection List Tutorial Exercise 1
|
|
|
|
@noindent
|
|
We can use @kbd{v x} to build a vector of integers. This needs to be
|
|
adjusted to get the range of integers we desire. Mapping @samp{-}
|
|
across the vector will accomplish this, although it turns out the
|
|
plain @samp{-} key will work just as well.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 2 2: 2
|
|
1: [1, 2, 3, 4, 5, 6, 7, 8, 9] 1: [-4, -3, -2, -1, 0, 1, 2, 3, 4]
|
|
. .
|
|
|
|
2 v x 9 @key{RET} 5 V M - or 5 -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now we use @kbd{V M ^} to map the exponentiation operator across the
|
|
vector.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16]
|
|
.
|
|
|
|
V M ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node List Answer 2, List Answer 3, List Answer 1, Answers to Exercises
|
|
@subsection List Tutorial Exercise 2
|
|
|
|
@noindent
|
|
Given @expr{x} and @expr{y} vectors in quick variables 1 and 2 as before,
|
|
the first job is to form the matrix that describes the problem.
|
|
|
|
@ifinfo
|
|
@example
|
|
m*x + b*1 = y
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ m \times x + b \times 1 = y $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
Thus we want a
|
|
@texline @math{19\times2}
|
|
@infoline 19x2
|
|
matrix with our @expr{x} vector as one column and
|
|
ones as the other column. So, first we build the column of ones, then
|
|
we combine the two columns to form our @expr{A} matrix.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1.34, 1.41, 1.49, ... ] 1: [ [ 1.34, 1 ]
|
|
1: [1, 1, 1, ...] [ 1.41, 1 ]
|
|
. [ 1.49, 1 ]
|
|
@dots{}
|
|
|
|
r 1 1 v b 19 @key{RET} M-2 v p v t s 3
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now we compute
|
|
@texline @math{A^T y}
|
|
@infoline @expr{trn(A) * y}
|
|
and
|
|
@texline @math{A^T A}
|
|
@infoline @expr{trn(A) * A}
|
|
and divide.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [33.36554, 13.613] 2: [33.36554, 13.613]
|
|
. 1: [ [ 98.0003, 41.63 ]
|
|
[ 41.63, 19 ] ]
|
|
.
|
|
|
|
v t r 2 * r 3 v t r 3 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Hey, those numbers look familiar!)
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.52141679, -0.425978]
|
|
.
|
|
|
|
/
|
|
@end group
|
|
@end smallexample
|
|
|
|
Since we were solving equations of the form
|
|
@texline @math{m \times x + b \times 1 = y},
|
|
@infoline @expr{m*x + b*1 = y},
|
|
these numbers should be @expr{m} and @expr{b}, respectively. Sure
|
|
enough, they agree exactly with the result computed using @kbd{V M} and
|
|
@kbd{V R}!
|
|
|
|
The moral of this story: @kbd{V M} and @kbd{V R} will probably solve
|
|
your problem, but there is often an easier way using the higher-level
|
|
arithmetic functions!
|
|
|
|
@c [fix-ref Curve Fitting]
|
|
In fact, there is a built-in @kbd{a F} command that does least-squares
|
|
fits. @xref{Curve Fitting}.
|
|
|
|
@node List Answer 3, List Answer 4, List Answer 2, Answers to Exercises
|
|
@subsection List Tutorial Exercise 3
|
|
|
|
@noindent
|
|
Move to one end of the list and press @kbd{C-@@} (or @kbd{C-@key{SPC}} or
|
|
whatever) to set the mark, then move to the other end of the list
|
|
and type @w{@kbd{C-x * g}}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [2.3, 6, 22, 15.1, 7, 15, 14, 7.5, 2.5]
|
|
.
|
|
@end group
|
|
@end smallexample
|
|
|
|
To make things interesting, let's assume we don't know at a glance
|
|
how many numbers are in this list. Then we could type:
|
|
|
|
@smallexample
|
|
@group
|
|
2: [2.3, 6, 22, ... ] 2: [2.3, 6, 22, ... ]
|
|
1: [2.3, 6, 22, ... ] 1: 126356422.5
|
|
. .
|
|
|
|
@key{RET} V R *
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: 126356422.5 2: 126356422.5 1: 7.94652913734
|
|
1: [2.3, 6, 22, ... ] 1: 9 .
|
|
. .
|
|
|
|
@key{TAB} v l I ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(The @kbd{I ^} command computes the @var{n}th root of a number.
|
|
You could also type @kbd{& ^} to take the reciprocal of 9 and
|
|
then raise the number to that power.)
|
|
|
|
@node List Answer 4, List Answer 5, List Answer 3, Answers to Exercises
|
|
@subsection List Tutorial Exercise 4
|
|
|
|
@noindent
|
|
A number @expr{j} is a divisor of @expr{n} if
|
|
@texline @math{n \mathbin{\hbox{\code{\%}}} j = 0}.
|
|
@infoline @samp{n % j = 0}.
|
|
The first step is to get a vector that identifies the divisors.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 30 2: [0, 0, 0, 2, ...] 1: [1, 1, 1, 0, ...]
|
|
1: [1, 2, 3, 4, ...] 1: 0 .
|
|
. .
|
|
|
|
30 @key{RET} v x 30 @key{RET} s 1 V M % 0 V M a = s 2
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This vector has 1's marking divisors of 30 and 0's marking non-divisors.
|
|
|
|
The zeroth divisor function is just the total number of divisors.
|
|
The first divisor function is the sum of the divisors.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 8 3: 8 2: 8 2: 8
|
|
2: [1, 2, 3, 4, ...] 1: [1, 2, 3, 0, ...] 1: 72
|
|
1: [1, 1, 1, 0, ...] . .
|
|
.
|
|
|
|
V R + r 1 r 2 V M * V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Once again, the last two steps just compute a dot product for which
|
|
a simple @kbd{*} would have worked equally well.
|
|
|
|
@node List Answer 5, List Answer 6, List Answer 4, Answers to Exercises
|
|
@subsection List Tutorial Exercise 5
|
|
|
|
@noindent
|
|
The obvious first step is to obtain the list of factors with @kbd{k f}.
|
|
This list will always be in sorted order, so if there are duplicates
|
|
they will be right next to each other. A suitable method is to compare
|
|
the list with a copy of itself shifted over by one.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19] 2: [3, 7, 7, 7, 19, 0]
|
|
. 1: [3, 7, 7, 7, 19, 0] 1: [0, 3, 7, 7, 7, 19]
|
|
. .
|
|
|
|
19551 k f @key{RET} 0 | @key{TAB} 0 @key{TAB} |
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [0, 0, 1, 1, 0, 0] 1: 2 1: 0
|
|
. . .
|
|
|
|
V M a = V R + 0 a =
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that we have to arrange for both vectors to have the same length
|
|
so that the mapping operation works; no prime factor will ever be
|
|
zero, so adding zeros on the left and right is safe. From then on
|
|
the job is pretty straightforward.
|
|
|
|
Incidentally, Calc provides the
|
|
@texline @dfn{M@"obius} @math{\mu}
|
|
@infoline @dfn{Moebius mu}
|
|
function which is zero if and only if its argument is square-free. It
|
|
would be a much more convenient way to do the above test in practice.
|
|
|
|
@node List Answer 6, List Answer 7, List Answer 5, Answers to Exercises
|
|
@subsection List Tutorial Exercise 6
|
|
|
|
@noindent
|
|
First use @kbd{v x 6 @key{RET}} to get a list of integers, then @kbd{V M v x}
|
|
to get a list of lists of integers!
|
|
|
|
@node List Answer 7, List Answer 8, List Answer 6, Answers to Exercises
|
|
@subsection List Tutorial Exercise 7
|
|
|
|
@noindent
|
|
Here's one solution. First, compute the triangular list from the previous
|
|
exercise and type @kbd{1 -} to subtract one from all the elements.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [0],
|
|
[0, 1],
|
|
[0, 1, 2],
|
|
@dots{}
|
|
|
|
1 -
|
|
@end group
|
|
@end smallexample
|
|
|
|
The numbers down the lefthand edge of the list we desire are called
|
|
the ``triangular numbers'' (now you know why!). The @expr{n}th
|
|
triangular number is the sum of the integers from 1 to @expr{n}, and
|
|
can be computed directly by the formula
|
|
@texline @math{n (n+1) \over 2}.
|
|
@infoline @expr{n * (n+1) / 2}.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
|
|
1: [0, 1, 2, 3, 4, 5] 1: [0, 1, 3, 6, 10, 15]
|
|
. .
|
|
|
|
v x 6 @key{RET} 1 - V M ' $ ($+1)/2 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Adding this list to the above list of lists produces the desired
|
|
result:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [ [0],
|
|
[1, 2],
|
|
[3, 4, 5],
|
|
[6, 7, 8, 9],
|
|
[10, 11, 12, 13, 14],
|
|
[15, 16, 17, 18, 19, 20] ]
|
|
.
|
|
|
|
V M +
|
|
@end group
|
|
@end smallexample
|
|
|
|
If we did not know the formula for triangular numbers, we could have
|
|
computed them using a @kbd{V U +} command. We could also have
|
|
gotten them the hard way by mapping a reduction across the original
|
|
triangular list.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ [0], [0, 1], ... ] 2: [ [0], [0, 1], ... ]
|
|
1: [ [0], [0, 1], ... ] 1: [0, 1, 3, 6, 10, 15]
|
|
. .
|
|
|
|
@key{RET} V M V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(This means ``map a @kbd{V R +} command across the vector,'' and
|
|
since each element of the main vector is itself a small vector,
|
|
@kbd{V R +} computes the sum of its elements.)
|
|
|
|
@node List Answer 8, List Answer 9, List Answer 7, Answers to Exercises
|
|
@subsection List Tutorial Exercise 8
|
|
|
|
@noindent
|
|
The first step is to build a list of values of @expr{x}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [1, 2, 3, ..., 21] 1: [0, 1, 2, ..., 20] 1: [0, 0.25, 0.5, ..., 5]
|
|
. . .
|
|
|
|
v x 21 @key{RET} 1 - 4 / s 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
Next, we compute the Bessel function values.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0., 0.124, 0.242, ..., -0.328]
|
|
.
|
|
|
|
V M ' besJ(1,$) @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Another way to do this would be @kbd{1 @key{TAB} V M f j}.)
|
|
|
|
A way to isolate the maximum value is to compute the maximum using
|
|
@kbd{V R X}, then compare all the Bessel values with that maximum.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0., 0.124, 0.242, ... ] 1: [0, 0, 0, ... ] 2: [0, 0, 0, ... ]
|
|
1: 0.5801562 . 1: 1
|
|
. .
|
|
|
|
@key{RET} V R X V M a = @key{RET} V R + @key{DEL}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
It's a good idea to verify, as in the last step above, that only
|
|
one value is equal to the maximum. (After all, a plot of
|
|
@texline @math{\sin x}
|
|
@infoline @expr{sin(x)}
|
|
might have many points all equal to the maximum value, 1.)
|
|
|
|
The vector we have now has a single 1 in the position that indicates
|
|
the maximum value of @expr{x}. Now it is a simple matter to convert
|
|
this back into the corresponding value itself.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0, 0, 0, ... ] 1: [0, 0., 0., ... ] 1: 1.75
|
|
1: [0, 0.25, 0.5, ... ] . .
|
|
.
|
|
|
|
r 1 V M * V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
If @kbd{a =} had produced more than one @expr{1} value, this method
|
|
would have given the sum of all maximum @expr{x} values; not very
|
|
useful! In this case we could have used @kbd{v m} (@code{calc-mask-vector})
|
|
instead. This command deletes all elements of a ``data'' vector that
|
|
correspond to zeros in a ``mask'' vector, leaving us with, in this
|
|
example, a vector of maximum @expr{x} values.
|
|
|
|
The built-in @kbd{a X} command maximizes a function using more
|
|
efficient methods. Just for illustration, let's use @kbd{a X}
|
|
to maximize @samp{besJ(1,x)} over this same interval.
|
|
|
|
@smallexample
|
|
@group
|
|
2: besJ(1, x) 1: [1.84115, 0.581865]
|
|
1: [0 .. 5] .
|
|
.
|
|
|
|
' besJ(1,x), [0..5] @key{RET} a X x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The output from @kbd{a X} is a vector containing the value of @expr{x}
|
|
that maximizes the function, and the function's value at that maximum.
|
|
As you can see, our simple search got quite close to the right answer.
|
|
|
|
@node List Answer 9, List Answer 10, List Answer 8, Answers to Exercises
|
|
@subsection List Tutorial Exercise 9
|
|
|
|
@noindent
|
|
Step one is to convert our integer into vector notation.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 25129925999 3: 25129925999
|
|
. 2: 10
|
|
1: [11, 10, 9, ..., 1, 0]
|
|
.
|
|
|
|
25129925999 @key{RET} 10 @key{RET} 12 @key{RET} v x 12 @key{RET} -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 25129925999 1: [0, 2, 25, 251, 2512, ... ]
|
|
2: [100000000000, ... ] .
|
|
.
|
|
|
|
V M ^ s 1 V M \
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Recall, the @kbd{\} command computes an integer quotient.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0, 2, 5, 1, 2, 9, 9, 2, 5, 9, 9, 9]
|
|
.
|
|
|
|
10 V M % s 2
|
|
@end group
|
|
@end smallexample
|
|
|
|
Next we must increment this number. This involves adding one to
|
|
the last digit, plus handling carries. There is a carry to the
|
|
left out of a digit if that digit is a nine and all the digits to
|
|
the right of it are nines.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1] 1: [1, 1, 1, 0, 0, 1, ... ]
|
|
. .
|
|
|
|
9 V M a = v v
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [1, 1, 1, 0, 0, 0, ... ] 1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
|
|
. .
|
|
|
|
V U * v v 1 |
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Accumulating @kbd{*} across a vector of ones and zeros will preserve
|
|
only the initial run of ones. These are the carries into all digits
|
|
except the rightmost digit. Concatenating a one on the right takes
|
|
care of aligning the carries properly, and also adding one to the
|
|
rightmost digit.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0, 0, 0, 0, ... ] 1: [0, 0, 2, 5, 1, 2, 9, 9, 2, 6, 0, 0, 0]
|
|
1: [0, 0, 2, 5, ... ] .
|
|
.
|
|
|
|
0 r 2 | V M + 10 V M %
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we have concatenated 0 to the @emph{left} of the original number;
|
|
this takes care of shifting the carries by one with respect to the
|
|
digits that generated them.
|
|
|
|
Finally, we must convert this list back into an integer.
|
|
|
|
@smallexample
|
|
@group
|
|
3: [0, 0, 2, 5, ... ] 2: [0, 0, 2, 5, ... ]
|
|
2: 1000000000000 1: [1000000000000, 100000000000, ... ]
|
|
1: [100000000000, ... ] .
|
|
.
|
|
|
|
10 @key{RET} 12 ^ r 1 |
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [0, 0, 20000000000, 5000000000, ... ] 1: 25129926000
|
|
. .
|
|
|
|
V M * V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Another way to do this final step would be to reduce the formula
|
|
@w{@samp{10 $$ + $}} across the vector of digits.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0, 0, 2, 5, ... ] 1: 25129926000
|
|
. .
|
|
|
|
V R ' 10 $$ + $ @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node List Answer 10, List Answer 11, List Answer 9, Answers to Exercises
|
|
@subsection List Tutorial Exercise 10
|
|
|
|
@noindent
|
|
For the list @expr{[a, b, c, d]}, the result is @expr{((a = b) = c) = d},
|
|
which will compare @expr{a} and @expr{b} to produce a 1 or 0, which is
|
|
then compared with @expr{c} to produce another 1 or 0, which is then
|
|
compared with @expr{d}. This is not at all what Joe wanted.
|
|
|
|
Here's a more correct method:
|
|
|
|
@smallexample
|
|
@group
|
|
1: [7, 7, 7, 8, 7] 2: [7, 7, 7, 8, 7]
|
|
. 1: 7
|
|
.
|
|
|
|
' [7,7,7,8,7] @key{RET} @key{RET} v r 1 @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [1, 1, 1, 0, 1] 1: 0
|
|
. .
|
|
|
|
V M a = V R *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node List Answer 11, List Answer 12, List Answer 10, Answers to Exercises
|
|
@subsection List Tutorial Exercise 11
|
|
|
|
@noindent
|
|
The circle of unit radius consists of those points @expr{(x,y)} for which
|
|
@expr{x^2 + y^2 < 1}. We start by generating a vector of @expr{x^2}
|
|
and a vector of @expr{y^2}.
|
|
|
|
We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
|
|
commands.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [2., 2., ..., 2.] 2: [2., 2., ..., 2.]
|
|
1: [2., 2., ..., 2.] 1: [1.16, 1.98, ..., 0.81]
|
|
. .
|
|
|
|
v . t . 2. v b 100 @key{RET} @key{RET} V M k r
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: [2., 2., ..., 2.] 1: [0.026, 0.96, ..., 0.036]
|
|
1: [0.026, 0.96, ..., 0.036] 2: [0.53, 0.81, ..., 0.094]
|
|
. .
|
|
|
|
1 - 2 V M ^ @key{TAB} V M k r 1 - 2 V M ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now we sum the @expr{x^2} and @expr{y^2} values, compare with 1 to
|
|
get a vector of 1/0 truth values, then sum the truth values.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.56, 1.78, ..., 0.13] 1: [1, 0, ..., 1] 1: 84
|
|
. . .
|
|
|
|
+ 1 V M a < V R +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The ratio @expr{84/100} should approximate the ratio @cpiover{4}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.84 1: 3.36 2: 3.36 1: 1.0695
|
|
. . 1: 3.14159 .
|
|
|
|
100 / 4 * P /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Our estimate, 3.36, is off by about 7%. We could get a better estimate
|
|
by taking more points (say, 1000), but it's clear that this method is
|
|
not very efficient!
|
|
|
|
(Naturally, since this example uses random numbers your own answer
|
|
will be slightly different from the one shown here!)
|
|
|
|
If you typed @kbd{v .} and @kbd{t .} before, type them again to
|
|
return to full-sized display of vectors.
|
|
|
|
@node List Answer 12, List Answer 13, List Answer 11, Answers to Exercises
|
|
@subsection List Tutorial Exercise 12
|
|
|
|
@noindent
|
|
This problem can be made a lot easier by taking advantage of some
|
|
symmetries. First of all, after some thought it's clear that the
|
|
@expr{y} axis can be ignored altogether. Just pick a random @expr{x}
|
|
component for one end of the match, pick a random direction
|
|
@texline @math{\theta},
|
|
@infoline @expr{theta},
|
|
and see if @expr{x} and
|
|
@texline @math{x + \cos \theta}
|
|
@infoline @expr{x + cos(theta)}
|
|
(which is the @expr{x} coordinate of the other endpoint) cross a line.
|
|
The lines are at integer coordinates, so this happens when the two
|
|
numbers surround an integer.
|
|
|
|
Since the two endpoints are equivalent, we may as well choose the leftmost
|
|
of the two endpoints as @expr{x}. Then @expr{theta} is an angle pointing
|
|
to the right, in the range -90 to 90 degrees. (We could use radians, but
|
|
it would feel like cheating to refer to @cpiover{2} radians while trying
|
|
to estimate @cpi{}!)
|
|
|
|
In fact, since the field of lines is infinite we can choose the
|
|
coordinates 0 and 1 for the lines on either side of the leftmost
|
|
endpoint. The rightmost endpoint will be between 0 and 1 if the
|
|
match does not cross a line, or between 1 and 2 if it does. So:
|
|
Pick random @expr{x} and
|
|
@texline @math{\theta},
|
|
@infoline @expr{theta},
|
|
compute
|
|
@texline @math{x + \cos \theta},
|
|
@infoline @expr{x + cos(theta)},
|
|
and count how many of the results are greater than one. Simple!
|
|
|
|
We can make this go a bit faster by using the @kbd{v .} and @kbd{t .}
|
|
commands.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [0.52, 0.71, ..., 0.72] 2: [0.52, 0.71, ..., 0.72]
|
|
. 1: [78.4, 64.5, ..., -42.9]
|
|
.
|
|
|
|
v . t . 1. v b 100 @key{RET} V M k r 180. v b 100 @key{RET} V M k r 90 -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(The next step may be slow, depending on the speed of your computer.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0.52, 0.71, ..., 0.72] 1: [0.72, 1.14, ..., 1.45]
|
|
1: [0.20, 0.43, ..., 0.73] .
|
|
.
|
|
|
|
m d V M C +
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [0, 1, ..., 1] 1: 0.64 1: 3.125
|
|
. . .
|
|
|
|
1 V M a > V R + 100 / 2 @key{TAB} /
|
|
@end group
|
|
@end smallexample
|
|
|
|
Let's try the third method, too. We'll use random integers up to
|
|
one million. The @kbd{k r} command with an integer argument picks
|
|
a random integer.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1000000, 1000000, ..., 1000000] 2: [78489, 527587, ..., 814975]
|
|
1: [1000000, 1000000, ..., 1000000] 1: [324014, 358783, ..., 955450]
|
|
. .
|
|
|
|
1000000 v b 100 @key{RET} @key{RET} V M k r @key{TAB} V M k r
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [1, 1, ..., 25] 1: [1, 1, ..., 0] 1: 0.56
|
|
. . .
|
|
|
|
V M k g 1 V M a = V R + 100 /
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: 10.714 1: 3.273
|
|
. .
|
|
|
|
6 @key{TAB} / Q
|
|
@end group
|
|
@end smallexample
|
|
|
|
For a proof of this property of the GCD function, see section 4.5.2,
|
|
exercise 10, of Knuth's @emph{Art of Computer Programming}, volume II.
|
|
|
|
If you typed @kbd{v .} and @kbd{t .} before, type them again to
|
|
return to full-sized display of vectors.
|
|
|
|
@node List Answer 13, List Answer 14, List Answer 12, Answers to Exercises
|
|
@subsection List Tutorial Exercise 13
|
|
|
|
@noindent
|
|
First, we put the string on the stack as a vector of ASCII codes.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [84, 101, 115, ..., 51]
|
|
.
|
|
|
|
"Testing, 1, 2, 3 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that the @kbd{"} key, like @kbd{$}, initiates algebraic entry so
|
|
there was no need to type an apostrophe. Also, Calc didn't mind that
|
|
we omitted the closing @kbd{"}. (The same goes for all closing delimiters
|
|
like @kbd{)} and @kbd{]} at the end of a formula.
|
|
|
|
We'll show two different approaches here. In the first, we note that
|
|
if the input vector is @expr{[a, b, c, d]}, then the hash code is
|
|
@expr{3 (3 (3a + b) + c) + d = 27a + 9b + 3c + d}. In other words,
|
|
it's a sum of descending powers of three times the ASCII codes.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [84, 101, 115, ..., 51] 2: [84, 101, 115, ..., 51]
|
|
1: 16 1: [15, 14, 13, ..., 0]
|
|
. .
|
|
|
|
@key{RET} v l v x 16 @key{RET} -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: [84, 101, 115, ..., 51] 1: 1960915098 1: 121
|
|
1: [14348907, ..., 1] . .
|
|
.
|
|
|
|
3 @key{TAB} V M ^ * 511 %
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Once again, @kbd{*} elegantly summarizes most of the computation.
|
|
But there's an even more elegant approach: Reduce the formula
|
|
@kbd{3 $$ + $} across the vector. Recall that this represents a
|
|
function of two arguments that computes its first argument times three
|
|
plus its second argument.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [84, 101, 115, ..., 51] 1: 1960915098
|
|
. .
|
|
|
|
"Testing, 1, 2, 3 @key{RET} V R ' 3$$+$ @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
If you did the decimal arithmetic exercise, this will be familiar.
|
|
Basically, we're turning a base-3 vector of digits into an integer,
|
|
except that our ``digits'' are much larger than real digits.
|
|
|
|
Instead of typing @kbd{511 %} again to reduce the result, we can be
|
|
cleverer still and notice that rather than computing a huge integer
|
|
and taking the modulo at the end, we can take the modulo at each step
|
|
without affecting the result. While this means there are more
|
|
arithmetic operations, the numbers we operate on remain small so
|
|
the operations are faster.
|
|
|
|
@smallexample
|
|
@group
|
|
1: [84, 101, 115, ..., 51] 1: 121
|
|
. .
|
|
|
|
"Testing, 1, 2, 3 @key{RET} V R ' (3$$+$)%511 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Why does this work? Think about a two-step computation:
|
|
@w{@expr{3 (3a + b) + c}}. Taking a result modulo 511 basically means
|
|
subtracting off enough 511's to put the result in the desired range.
|
|
So the result when we take the modulo after every step is,
|
|
|
|
@ifinfo
|
|
@example
|
|
3 (3 a + b - 511 m) + c - 511 n
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ 3 (3 a + b - 511 m) + c - 511 n $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
for some suitable integers @expr{m} and @expr{n}. Expanding out by
|
|
the distributive law yields
|
|
|
|
@ifinfo
|
|
@example
|
|
9 a + 3 b + c - 511*3 m - 511 n
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ 9 a + 3 b + c - 511\times3 m - 511 n $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
The @expr{m} term in the latter formula is redundant because any
|
|
contribution it makes could just as easily be made by the @expr{n}
|
|
term. So we can take it out to get an equivalent formula with
|
|
@expr{n' = 3m + n},
|
|
|
|
@ifinfo
|
|
@example
|
|
9 a + 3 b + c - 511 n'
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ 9 a + 3 b + c - 511 n' $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
which is just the formula for taking the modulo only at the end of
|
|
the calculation. Therefore the two methods are essentially the same.
|
|
|
|
Later in the tutorial we will encounter @dfn{modulo forms}, which
|
|
basically automate the idea of reducing every intermediate result
|
|
modulo some value @var{m}.
|
|
|
|
@node List Answer 14, Types Answer 1, List Answer 13, Answers to Exercises
|
|
@subsection List Tutorial Exercise 14
|
|
|
|
We want to use @kbd{H V U} to nest a function which adds a random
|
|
step to an @expr{(x,y)} coordinate. The function is a bit long, but
|
|
otherwise the problem is quite straightforward.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0, 0] 1: [ [ 0, 0 ]
|
|
1: 50 [ 0.4288, -0.1695 ]
|
|
. [ -0.4787, -0.9027 ]
|
|
...
|
|
|
|
[0,0] 50 H V U ' <# + [random(2.0)-1, random(2.0)-1]> @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Just as the text recommended, we used @samp{< >} nameless function
|
|
notation to keep the two @code{random} calls from being evaluated
|
|
before nesting even begins.
|
|
|
|
We now have a vector of @expr{[x, y]} sub-vectors, which by Calc's
|
|
rules acts like a matrix. We can transpose this matrix and unpack
|
|
to get a pair of vectors, @expr{x} and @expr{y}, suitable for graphing.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [ 0, 0.4288, -0.4787, ... ]
|
|
1: [ 0, -0.1696, -0.9027, ... ]
|
|
.
|
|
|
|
v t v u g f
|
|
@end group
|
|
@end smallexample
|
|
|
|
Incidentally, because the @expr{x} and @expr{y} are completely
|
|
independent in this case, we could have done two separate commands
|
|
to create our @expr{x} and @expr{y} vectors of numbers directly.
|
|
|
|
To make a random walk of unit steps, we note that @code{sincos} of
|
|
a random direction exactly gives us an @expr{[x, y]} step of unit
|
|
length; in fact, the new nesting function is even briefer, though
|
|
we might want to lower the precision a bit for it.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [0, 0] 1: [ [ 0, 0 ]
|
|
1: 50 [ 0.1318, 0.9912 ]
|
|
. [ -0.5965, 0.3061 ]
|
|
...
|
|
|
|
[0,0] 50 m d p 6 @key{RET} H V U ' <# + sincos(random(360.0))> @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Another @kbd{v t v u g f} sequence will graph this new random walk.
|
|
|
|
An interesting twist on these random walk functions would be to use
|
|
complex numbers instead of 2-vectors to represent points on the plane.
|
|
In the first example, we'd use something like @samp{random + random*(0,1)},
|
|
and in the second we could use polar complex numbers with random phase
|
|
angles. (This exercise was first suggested in this form by Randal
|
|
Schwartz.)
|
|
|
|
@node Types Answer 1, Types Answer 2, List Answer 14, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 1
|
|
|
|
@noindent
|
|
If the number is the square root of @cpi{} times a rational number,
|
|
then its square, divided by @cpi{}, should be a rational number.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1.26508260337 1: 0.509433962268 1: 2486645810:4881193627
|
|
. . .
|
|
|
|
2 ^ P / c F
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Technically speaking this is a rational number, but not one that is
|
|
likely to have arisen in the original problem. More likely, it just
|
|
happens to be the fraction which most closely represents some
|
|
irrational number to within 12 digits.
|
|
|
|
But perhaps our result was not quite exact. Let's reduce the
|
|
precision slightly and try again:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 0.509433962268 1: 27:53
|
|
. .
|
|
|
|
U p 10 @key{RET} c F
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Aha! It's unlikely that an irrational number would equal a fraction
|
|
this simple to within ten digits, so our original number was probably
|
|
@texline @math{\sqrt{27 \pi / 53}}.
|
|
@infoline @expr{sqrt(27 pi / 53)}.
|
|
|
|
Notice that we didn't need to re-round the number when we reduced the
|
|
precision. Remember, arithmetic operations always round their inputs
|
|
to the current precision before they begin.
|
|
|
|
@node Types Answer 2, Types Answer 3, Types Answer 1, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 2
|
|
|
|
@noindent
|
|
@samp{inf / inf = nan}. Perhaps @samp{1} is the ``obvious'' answer.
|
|
But if @w{@samp{17 inf = inf}}, then @samp{17 inf / inf = inf / inf = 17}, too.
|
|
|
|
@samp{exp(inf) = inf}. It's tempting to say that the exponential
|
|
of infinity must be ``bigger'' than ``regular'' infinity, but as
|
|
far as Calc is concerned all infinities are as just as big.
|
|
In other words, as @expr{x} goes to infinity, @expr{e^x} also goes
|
|
to infinity, but the fact the @expr{e^x} grows much faster than
|
|
@expr{x} is not relevant here.
|
|
|
|
@samp{exp(-inf) = 0}. Here we have a finite answer even though
|
|
the input is infinite.
|
|
|
|
@samp{sqrt(-inf) = (0, 1) inf}. Remember that @expr{(0, 1)}
|
|
represents the imaginary number @expr{i}. Here's a derivation:
|
|
@samp{sqrt(-inf) = @w{sqrt((-1) * inf)} = sqrt(-1) * sqrt(inf)}.
|
|
The first part is, by definition, @expr{i}; the second is @code{inf}
|
|
because, once again, all infinities are the same size.
|
|
|
|
@samp{sqrt(uinf) = uinf}. In fact, we do know something about the
|
|
direction because @code{sqrt} is defined to return a value in the
|
|
right half of the complex plane. But Calc has no notation for this,
|
|
so it settles for the conservative answer @code{uinf}.
|
|
|
|
@samp{abs(uinf) = inf}. No matter which direction @expr{x} points,
|
|
@samp{abs(x)} always points along the positive real axis.
|
|
|
|
@samp{ln(0) = -inf}. Here we have an infinite answer to a finite
|
|
input. As in the @expr{1 / 0} case, Calc will only use infinities
|
|
here if you have turned on Infinite mode. Otherwise, it will
|
|
treat @samp{ln(0)} as an error.
|
|
|
|
@node Types Answer 3, Types Answer 4, Types Answer 2, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 3
|
|
|
|
@noindent
|
|
We can make @samp{inf - inf} be any real number we like, say,
|
|
@expr{a}, just by claiming that we added @expr{a} to the first
|
|
infinity but not to the second. This is just as true for complex
|
|
values of @expr{a}, so @code{nan} can stand for a complex number.
|
|
(And, similarly, @code{uinf} can stand for an infinity that points
|
|
in any direction in the complex plane, such as @samp{(0, 1) inf}).
|
|
|
|
In fact, we can multiply the first @code{inf} by two. Surely
|
|
@w{@samp{2 inf - inf = inf}}, but also @samp{2 inf - inf = inf - inf = nan}.
|
|
So @code{nan} can even stand for infinity. Obviously it's just
|
|
as easy to make it stand for minus infinity as for plus infinity.
|
|
|
|
The moral of this story is that ``infinity'' is a slippery fish
|
|
indeed, and Calc tries to handle it by having a very simple model
|
|
for infinities (only the direction counts, not the ``size''); but
|
|
Calc is careful to write @code{nan} any time this simple model is
|
|
unable to tell what the true answer is.
|
|
|
|
@node Types Answer 4, Types Answer 5, Types Answer 3, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 4
|
|
|
|
@smallexample
|
|
@group
|
|
2: 0@@ 47' 26" 1: 0@@ 2' 47.411765"
|
|
1: 17 .
|
|
.
|
|
|
|
0@@ 47' 26" @key{RET} 17 /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The average song length is two minutes and 47.4 seconds.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 0@@ 2' 47.411765" 1: 0@@ 3' 7.411765" 1: 0@@ 53' 6.000005"
|
|
1: 0@@ 0' 20" . .
|
|
.
|
|
|
|
20" + 17 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The album would be 53 minutes and 6 seconds long.
|
|
|
|
@node Types Answer 5, Types Answer 6, Types Answer 4, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 5
|
|
|
|
@noindent
|
|
Let's suppose it's January 14, 1991. The easiest thing to do is
|
|
to keep trying 13ths of months until Calc reports a Friday.
|
|
We can do this by manually entering dates, or by using @kbd{t I}:
|
|
|
|
@smallexample
|
|
@group
|
|
1: <Wed Feb 13, 1991> 1: <Wed Mar 13, 1991> 1: <Sat Apr 13, 1991>
|
|
. . .
|
|
|
|
' <2/13> @key{RET} @key{DEL} ' <3/13> @key{RET} t I
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Calc assumes the current year if you don't say otherwise.)
|
|
|
|
This is getting tedious---we can keep advancing the date by typing
|
|
@kbd{t I} over and over again, but let's automate the job by using
|
|
vector mapping. The @kbd{t I} command actually takes a second
|
|
``how-many-months'' argument, which defaults to one. This
|
|
argument is exactly what we want to map over:
|
|
|
|
@smallexample
|
|
@group
|
|
2: <Sat Apr 13, 1991> 1: [<Mon May 13, 1991>, <Thu Jun 13, 1991>,
|
|
1: [1, 2, 3, 4, 5, 6] <Sat Jul 13, 1991>, <Tue Aug 13, 1991>,
|
|
. <Fri Sep 13, 1991>, <Sun Oct 13, 1991>]
|
|
.
|
|
|
|
v x 6 @key{RET} V M t I
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Et voil@`a, September 13, 1991 is a Friday.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 242
|
|
.
|
|
|
|
' <sep 13> - <jan 14> @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
And the answer to our original question: 242 days to go.
|
|
|
|
@node Types Answer 6, Types Answer 7, Types Answer 5, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 6
|
|
|
|
@noindent
|
|
The full rule for leap years is that they occur in every year divisible
|
|
by four, except that they don't occur in years divisible by 100, except
|
|
that they @emph{do} in years divisible by 400. We could work out the
|
|
answer by carefully counting the years divisible by four and the
|
|
exceptions, but there is a much simpler way that works even if we
|
|
don't know the leap year rule.
|
|
|
|
Let's assume the present year is 1991. Years have 365 days, except
|
|
that leap years (whenever they occur) have 366 days. So let's count
|
|
the number of days between now and then, and compare that to the
|
|
number of years times 365. The number of extra days we find must be
|
|
equal to the number of leap years there were.
|
|
|
|
@smallexample
|
|
@group
|
|
1: <Mon Jan 1, 10001> 2: <Mon Jan 1, 10001> 1: 2925593
|
|
. 1: <Tue Jan 1, 1991> .
|
|
.
|
|
|
|
' <jan 1 10001> @key{RET} ' <jan 1 1991> @key{RET} -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
3: 2925593 2: 2925593 2: 2925593 1: 1943
|
|
2: 10001 1: 8010 1: 2923650 .
|
|
1: 1991 . .
|
|
.
|
|
|
|
10001 @key{RET} 1991 - 365 * -
|
|
@end group
|
|
@end smallexample
|
|
|
|
@c [fix-ref Date Forms]
|
|
@noindent
|
|
There will be 1943 leap years before the year 10001. (Assuming,
|
|
of course, that the algorithm for computing leap years remains
|
|
unchanged for that long. @xref{Date Forms}, for some interesting
|
|
background information in that regard.)
|
|
|
|
@node Types Answer 7, Types Answer 8, Types Answer 6, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 7
|
|
|
|
@noindent
|
|
The relative errors must be converted to absolute errors so that
|
|
@samp{+/-} notation may be used.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1. 2: 1.
|
|
. 1: 0.2
|
|
.
|
|
|
|
20 @key{RET} .05 * 4 @key{RET} .05 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now we simply chug through the formula.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 19.7392088022 1: 394.78 +/- 19.739 1: 6316.5 +/- 706.21
|
|
. . .
|
|
|
|
2 P 2 ^ * 20 p 1 * 4 p .2 @key{RET} 2 ^ *
|
|
@end group
|
|
@end smallexample
|
|
|
|
It turns out the @kbd{v u} command will unpack an error form as
|
|
well as a vector. This saves us some retyping of numbers.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 6316.5 +/- 706.21 2: 6316.5 +/- 706.21
|
|
2: 6316.5 1: 0.1118
|
|
1: 706.21 .
|
|
.
|
|
|
|
@key{RET} v u @key{TAB} /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Thus the volume is 6316 cubic centimeters, within about 11 percent.
|
|
|
|
@node Types Answer 8, Types Answer 9, Types Answer 7, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 8
|
|
|
|
@noindent
|
|
The first answer is pretty simple: @samp{1 / (0 .. 10) = (0.1 .. inf)}.
|
|
Since a number in the interval @samp{(0 .. 10)} can get arbitrarily
|
|
close to zero, its reciprocal can get arbitrarily large, so the answer
|
|
is an interval that effectively means, ``any number greater than 0.1''
|
|
but with no upper bound.
|
|
|
|
The second answer, similarly, is @samp{1 / (-10 .. 0) = (-inf .. -0.1)}.
|
|
|
|
Calc normally treats division by zero as an error, so that the formula
|
|
@w{@samp{1 / 0}} is left unsimplified. Our third problem,
|
|
@w{@samp{1 / [0 .. 10]}}, also (potentially) divides by zero because zero
|
|
is now a member of the interval. So Calc leaves this one unevaluated, too.
|
|
|
|
If you turn on Infinite mode by pressing @kbd{m i}, you will
|
|
instead get the answer @samp{[0.1 .. inf]}, which includes infinity
|
|
as a possible value.
|
|
|
|
The fourth calculation, @samp{1 / (-10 .. 10)}, has the same problem.
|
|
Zero is buried inside the interval, but it's still a possible value.
|
|
It's not hard to see that the actual result of @samp{1 / (-10 .. 10)}
|
|
will be either greater than @mathit{0.1}, or less than @mathit{-0.1}. Thus
|
|
the interval goes from minus infinity to plus infinity, with a ``hole''
|
|
in it from @mathit{-0.1} to @mathit{0.1}. Calc doesn't have any way to
|
|
represent this, so it just reports @samp{[-inf .. inf]} as the answer.
|
|
It may be disappointing to hear ``the answer lies somewhere between
|
|
minus infinity and plus infinity, inclusive,'' but that's the best
|
|
that interval arithmetic can do in this case.
|
|
|
|
@node Types Answer 9, Types Answer 10, Types Answer 8, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 9
|
|
|
|
@smallexample
|
|
@group
|
|
1: [-3 .. 3] 2: [-3 .. 3] 2: [0 .. 9]
|
|
. 1: [0 .. 9] 1: [-9 .. 9]
|
|
. .
|
|
|
|
[ 3 n .. 3 ] @key{RET} 2 ^ @key{TAB} @key{RET} *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In the first case the result says, ``if a number is between @mathit{-3} and
|
|
3, its square is between 0 and 9.'' The second case says, ``the product
|
|
of two numbers each between @mathit{-3} and 3 is between @mathit{-9} and 9.''
|
|
|
|
An interval form is not a number; it is a symbol that can stand for
|
|
many different numbers. Two identical-looking interval forms can stand
|
|
for different numbers.
|
|
|
|
The same issue arises when you try to square an error form.
|
|
|
|
@node Types Answer 10, Types Answer 11, Types Answer 9, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 10
|
|
|
|
@noindent
|
|
Testing the first number, we might arbitrarily choose 17 for @expr{x}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 17 mod 811749613 2: 17 mod 811749613 1: 533694123 mod 811749613
|
|
. 811749612 .
|
|
.
|
|
|
|
17 M 811749613 @key{RET} 811749612 ^
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Since 533694123 is (considerably) different from 1, the number 811749613
|
|
must not be prime.
|
|
|
|
It's awkward to type the number in twice as we did above. There are
|
|
various ways to avoid this, and algebraic entry is one. In fact, using
|
|
a vector mapping operation we can perform several tests at once. Let's
|
|
use this method to test the second number.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [17, 42, 100000] 1: [1 mod 15485863, 1 mod ... ]
|
|
1: 15485863 .
|
|
.
|
|
|
|
[17 42 100000] 15485863 @key{RET} V M ' ($$ mod $)^($-1) @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The result is three ones (modulo @expr{n}), so it's very probable that
|
|
15485863 is prime. (In fact, this number is the millionth prime.)
|
|
|
|
Note that the functions @samp{($$^($-1)) mod $} or @samp{$$^($-1) % $}
|
|
would have been hopelessly inefficient, since they would have calculated
|
|
the power using full integer arithmetic.
|
|
|
|
Calc has a @kbd{k p} command that does primality testing. For small
|
|
numbers it does an exact test; for large numbers it uses a variant
|
|
of the Fermat test we used here. You can use @kbd{k p} repeatedly
|
|
to prove that a large integer is prime with any desired probability.
|
|
|
|
@node Types Answer 11, Types Answer 12, Types Answer 10, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 11
|
|
|
|
@noindent
|
|
There are several ways to insert a calculated number into an HMS form.
|
|
One way to convert a number of seconds to an HMS form is simply to
|
|
multiply the number by an HMS form representing one second:
|
|
|
|
@smallexample
|
|
@group
|
|
1: 31415926.5359 2: 31415926.5359 1: 8726@@ 38' 46.5359"
|
|
. 1: 0@@ 0' 1" .
|
|
.
|
|
|
|
P 1e7 * 0@@ 0' 1" *
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: 8726@@ 38' 46.5359" 1: 6@@ 6' 2.5359" mod 24@@ 0' 0"
|
|
1: 15@@ 27' 16" mod 24@@ 0' 0" .
|
|
.
|
|
|
|
x time @key{RET} +
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
It will be just after six in the morning.
|
|
|
|
The algebraic @code{hms} function can also be used to build an
|
|
HMS form:
|
|
|
|
@smallexample
|
|
@group
|
|
1: hms(0, 0, 10000000. pi) 1: 8726@@ 38' 46.5359"
|
|
. .
|
|
|
|
' hms(0, 0, 1e7 pi) @key{RET} =
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @kbd{=} key is necessary to evaluate the symbol @samp{pi} to
|
|
the actual number 3.14159...
|
|
|
|
@node Types Answer 12, Types Answer 13, Types Answer 11, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 12
|
|
|
|
@noindent
|
|
As we recall, there are 17 songs of about 2 minutes and 47 seconds
|
|
each.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 0@@ 2' 47" 1: [0@@ 3' 7" .. 0@@ 3' 47"]
|
|
1: [0@@ 0' 20" .. 0@@ 1' 0"] .
|
|
.
|
|
|
|
[ 0@@ 20" .. 0@@ 1' ] +
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [0@@ 52' 59." .. 1@@ 4' 19."]
|
|
.
|
|
|
|
17 *
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
No matter how long it is, the album will fit nicely on one CD.
|
|
|
|
@node Types Answer 13, Types Answer 14, Types Answer 12, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 13
|
|
|
|
@noindent
|
|
Type @kbd{' 1 yr @key{RET} u c s @key{RET}}. The answer is 31557600 seconds.
|
|
|
|
@node Types Answer 14, Types Answer 15, Types Answer 13, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 14
|
|
|
|
@noindent
|
|
How long will it take for a signal to get from one end of the computer
|
|
to the other?
|
|
|
|
@smallexample
|
|
@group
|
|
1: m / c 1: 3.3356 ns
|
|
. .
|
|
|
|
' 1 m / c @key{RET} u c ns @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Recall, @samp{c} is a ``unit'' corresponding to the speed of light.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 3.3356 ns 1: 0.81356 ns / ns 1: 0.81356
|
|
2: 4.1 ns . .
|
|
.
|
|
|
|
' 4.1 ns @key{RET} / u s
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Thus a signal could take up to 81 percent of a clock cycle just to
|
|
go from one place to another inside the computer, assuming the signal
|
|
could actually attain the full speed of light. Pretty tight!
|
|
|
|
@node Types Answer 15, Algebra Answer 1, Types Answer 14, Answers to Exercises
|
|
@subsection Types Tutorial Exercise 15
|
|
|
|
@noindent
|
|
The speed limit is 55 miles per hour on most highways. We want to
|
|
find the ratio of Sam's speed to the US speed limit.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 55 mph 2: 55 mph 3: 11 hr mph / yd
|
|
. 1: 5 yd / hr .
|
|
.
|
|
|
|
' 55 mph @key{RET} ' 5 yd/hr @key{RET} /
|
|
@end group
|
|
@end smallexample
|
|
|
|
The @kbd{u s} command cancels out these units to get a plain
|
|
number. Now we take the logarithm base two to find the final
|
|
answer, assuming that each successive pill doubles his speed.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 19360. 2: 19360. 1: 14.24
|
|
. 1: 2 .
|
|
.
|
|
|
|
u s 2 B
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Thus Sam can take up to 14 pills without a worry.
|
|
|
|
@node Algebra Answer 1, Algebra Answer 2, Types Answer 15, Answers to Exercises
|
|
@subsection Algebra Tutorial Exercise 1
|
|
|
|
@noindent
|
|
@c [fix-ref Declarations]
|
|
The result @samp{sqrt(x)^2} is simplified back to @expr{x} by the
|
|
Calculator, but @samp{sqrt(x^2)} is not. (Consider what happens
|
|
if @w{@expr{x = -4}}.) If @expr{x} is real, this formula could be
|
|
simplified to @samp{abs(x)}, but for general complex arguments even
|
|
that is not safe. (@xref{Declarations}, for a way to tell Calc
|
|
that @expr{x} is known to be real.)
|
|
|
|
@node Algebra Answer 2, Algebra Answer 3, Algebra Answer 1, Answers to Exercises
|
|
@subsection Algebra Tutorial Exercise 2
|
|
|
|
@noindent
|
|
Suppose our roots are @expr{[a, b, c]}. We want a polynomial which
|
|
is zero when @expr{x} is any of these values. The trivial polynomial
|
|
@expr{x-a} is zero when @expr{x=a}, so the product @expr{(x-a)(x-b)(x-c)}
|
|
will do the job. We can use @kbd{a c x} to write this in a more
|
|
familiar form.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 34 x - 24 x^3 1: [1.19023, -1.19023, 0]
|
|
. .
|
|
|
|
r 2 a P x @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [x - 1.19023, x + 1.19023, x] 1: (x - 1.19023) (x + 1.19023) x
|
|
. .
|
|
|
|
V M ' x-$ @key{RET} V R *
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: x^3 - 1.41666 x 1: 34 x - 24 x^3
|
|
. .
|
|
|
|
a c x @key{RET} 24 n * a x
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Sure enough, our answer (multiplied by a suitable constant) is the
|
|
same as the original polynomial.
|
|
|
|
@node Algebra Answer 3, Algebra Answer 4, Algebra Answer 2, Answers to Exercises
|
|
@subsection Algebra Tutorial Exercise 3
|
|
|
|
@smallexample
|
|
@group
|
|
1: x sin(pi x) 1: (sin(pi x) - pi x cos(pi x)) / pi^2
|
|
. .
|
|
|
|
' x sin(pi x) @key{RET} m r a i x @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [y, 1]
|
|
2: (sin(pi x) - pi x cos(pi x)) / pi^2
|
|
.
|
|
|
|
' [y,1] @key{RET} @key{TAB}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [(sin(pi y) - pi y cos(pi y)) / pi^2, (sin(pi) - pi cos(pi)) / pi^2]
|
|
.
|
|
|
|
V M $ @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: (sin(pi y) - pi y cos(pi y)) / pi^2 + (pi cos(pi) - sin(pi)) / pi^2
|
|
.
|
|
|
|
V R -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: (sin(3.14159 y) - 3.14159 y cos(3.14159 y)) / 9.8696 - 0.3183
|
|
.
|
|
|
|
=
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [0., -0.95493, 0.63662, -1.5915, 1.2732]
|
|
.
|
|
|
|
v x 5 @key{RET} @key{TAB} V M $ @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node Algebra Answer 4, Rewrites Answer 1, Algebra Answer 3, Answers to Exercises
|
|
@subsection Algebra Tutorial Exercise 4
|
|
|
|
@noindent
|
|
The hard part is that @kbd{V R +} is no longer sufficient to add up all
|
|
the contributions from the slices, since the slices have varying
|
|
coefficients. So first we must come up with a vector of these
|
|
coefficients. Here's one way:
|
|
|
|
@smallexample
|
|
@group
|
|
2: -1 2: 3 1: [4, 2, ..., 4]
|
|
1: [1, 2, ..., 9] 1: [-1, 1, ..., -1] .
|
|
. .
|
|
|
|
1 n v x 9 @key{RET} V M ^ 3 @key{TAB} -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: [4, 2, ..., 4, 1] 1: [1, 4, 2, ..., 4, 1]
|
|
. .
|
|
|
|
1 | 1 @key{TAB} |
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now we compute the function values. Note that for this method we need
|
|
eleven values, including both endpoints of the desired interval.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 4, 2, ..., 4, 1]
|
|
1: [1, 1.1, 1.2, ... , 1.8, 1.9, 2.]
|
|
.
|
|
|
|
11 @key{RET} 1 @key{RET} .1 @key{RET} C-u v x
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: [1, 4, 2, ..., 4, 1]
|
|
1: [0., 0.084941, 0.16993, ... ]
|
|
.
|
|
|
|
' sin(x) ln(x) @key{RET} m r p 5 @key{RET} V M $ @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Once again this calls for @kbd{V M * V R +}; a simple @kbd{*} does the
|
|
same thing.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 11.22 1: 1.122 1: 0.374
|
|
. . .
|
|
|
|
* .1 * 3 /
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Wow! That's even better than the result from the Taylor series method.
|
|
|
|
@node Rewrites Answer 1, Rewrites Answer 2, Algebra Answer 4, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 1
|
|
|
|
@noindent
|
|
We'll use Big mode to make the formulas more readable.
|
|
|
|
@smallexample
|
|
@group
|
|
___
|
|
2 + V 2
|
|
1: (2 + sqrt(2)) / (1 + sqrt(2)) 1: --------
|
|
. ___
|
|
1 + V 2
|
|
|
|
.
|
|
|
|
' (2+sqrt(2)) / (1+sqrt(2)) @key{RET} d B
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Multiplying by the conjugate helps because @expr{(a+b) (a-b) = a^2 - b^2}.
|
|
|
|
@smallexample
|
|
@group
|
|
___ ___
|
|
1: (2 + V 2 ) (V 2 - 1)
|
|
.
|
|
|
|
a r a/(b+c) := a*(b-c) / (b^2-c^2) @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
___ ___
|
|
1: 2 + V 2 - 2 1: V 2
|
|
. .
|
|
|
|
a r a*(b+c) := a*b + a*c a s
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(We could have used @kbd{a x} instead of a rewrite rule for the
|
|
second step.)
|
|
|
|
The multiply-by-conjugate rule turns out to be useful in many
|
|
different circumstances, such as when the denominator involves
|
|
sines and cosines or the imaginary constant @code{i}.
|
|
|
|
@node Rewrites Answer 2, Rewrites Answer 3, Rewrites Answer 1, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 2
|
|
|
|
@noindent
|
|
Here is the rule set:
|
|
|
|
@smallexample
|
|
@group
|
|
[ fib(n) := fib(n, 1, 1) :: integer(n) :: n >= 1,
|
|
fib(1, x, y) := x,
|
|
fib(n, x, y) := fib(n-1, y, x+y) ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The first rule turns a one-argument @code{fib} that people like to write
|
|
into a three-argument @code{fib} that makes computation easier. The
|
|
second rule converts back from three-argument form once the computation
|
|
is done. The third rule does the computation itself. It basically
|
|
says that if @expr{x} and @expr{y} are two consecutive Fibonacci numbers,
|
|
then @expr{y} and @expr{x+y} are the next (overlapping) pair of Fibonacci
|
|
numbers.
|
|
|
|
Notice that because the number @expr{n} was ``validated'' by the
|
|
conditions on the first rule, there is no need to put conditions on
|
|
the other rules because the rule set would never get that far unless
|
|
the input were valid. That further speeds computation, since no
|
|
extra conditions need to be checked at every step.
|
|
|
|
Actually, a user with a nasty sense of humor could enter a bad
|
|
three-argument @code{fib} call directly, say, @samp{fib(0, 1, 1)},
|
|
which would get the rules into an infinite loop. One thing that would
|
|
help keep this from happening by accident would be to use something like
|
|
@samp{ZzFib} instead of @code{fib} as the name of the three-argument
|
|
function.
|
|
|
|
@node Rewrites Answer 3, Rewrites Answer 4, Rewrites Answer 2, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 3
|
|
|
|
@noindent
|
|
He got an infinite loop. First, Calc did as expected and rewrote
|
|
@w{@samp{2 + 3 x}} to @samp{f(2, 3, x)}. Then it looked for ways to
|
|
apply the rule again, and found that @samp{f(2, 3, x)} looks like
|
|
@samp{a + b x} with @w{@samp{a = 0}} and @samp{b = 1}, so it rewrote to
|
|
@samp{f(0, 1, f(2, 3, x))}. It then wrapped another @samp{f(0, 1, ...)}
|
|
around that, and so on, ad infinitum. Joe should have used @kbd{M-1 a r}
|
|
to make sure the rule applied only once.
|
|
|
|
(Actually, even the first step didn't work as he expected. What Calc
|
|
really gives for @kbd{M-1 a r} in this situation is @samp{f(3 x, 1, 2)},
|
|
treating 2 as the ``variable,'' and @samp{3 x} as a constant being added
|
|
to it. While this may seem odd, it's just as valid a solution as the
|
|
``obvious'' one. One way to fix this would be to add the condition
|
|
@samp{:: variable(x)} to the rule, to make sure the thing that matches
|
|
@samp{x} is indeed a variable, or to change @samp{x} to @samp{quote(x)}
|
|
on the lefthand side, so that the rule matches the actual variable
|
|
@samp{x} rather than letting @samp{x} stand for something else.)
|
|
|
|
@node Rewrites Answer 4, Rewrites Answer 5, Rewrites Answer 3, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 4
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex seq
|
|
Here is a suitable set of rules to solve the first part of the problem:
|
|
|
|
@smallexample
|
|
@group
|
|
[ seq(n, c) := seq(n/2, c+1) :: n%2 = 0,
|
|
seq(n, c) := seq(3n+1, c+1) :: n%2 = 1 :: n > 1 ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
Given the initial formula @samp{seq(6, 0)}, application of these
|
|
rules produces the following sequence of formulas:
|
|
|
|
@example
|
|
seq( 3, 1)
|
|
seq(10, 2)
|
|
seq( 5, 3)
|
|
seq(16, 4)
|
|
seq( 8, 5)
|
|
seq( 4, 6)
|
|
seq( 2, 7)
|
|
seq( 1, 8)
|
|
@end example
|
|
|
|
@noindent
|
|
whereupon neither of the rules match, and rewriting stops.
|
|
|
|
We can pretty this up a bit with a couple more rules:
|
|
|
|
@smallexample
|
|
@group
|
|
[ seq(n) := seq(n, 0),
|
|
seq(1, c) := c,
|
|
... ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Now, given @samp{seq(6)} as the starting configuration, we get 8
|
|
as the result.
|
|
|
|
The change to return a vector is quite simple:
|
|
|
|
@smallexample
|
|
@group
|
|
[ seq(n) := seq(n, []) :: integer(n) :: n > 0,
|
|
seq(1, v) := v | 1,
|
|
seq(n, v) := seq(n/2, v | n) :: n%2 = 0,
|
|
seq(n, v) := seq(3n+1, v | n) :: n%2 = 1 ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Given @samp{seq(6)}, the result is @samp{[6, 3, 10, 5, 16, 8, 4, 2, 1]}.
|
|
|
|
Notice that the @expr{n > 1} guard is no longer necessary on the last
|
|
rule since the @expr{n = 1} case is now detected by another rule.
|
|
But a guard has been added to the initial rule to make sure the
|
|
initial value is suitable before the computation begins.
|
|
|
|
While still a good idea, this guard is not as vitally important as it
|
|
was for the @code{fib} function, since calling, say, @samp{seq(x, [])}
|
|
will not get into an infinite loop. Calc will not be able to prove
|
|
the symbol @samp{x} is either even or odd, so none of the rules will
|
|
apply and the rewrites will stop right away.
|
|
|
|
@node Rewrites Answer 5, Rewrites Answer 6, Rewrites Answer 4, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 5
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex nterms
|
|
If @expr{x} is the sum @expr{a + b}, then `@tfn{nterms(}@var{x}@tfn{)}' must
|
|
be `@tfn{nterms(}@var{a}@tfn{)}' plus `@tfn{nterms(}@var{b}@tfn{)}'. If @expr{x}
|
|
is not a sum, then `@tfn{nterms(}@var{x}@tfn{)}' = 1.
|
|
|
|
@smallexample
|
|
@group
|
|
[ nterms(a + b) := nterms(a) + nterms(b),
|
|
nterms(x) := 1 ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Here we have taken advantage of the fact that earlier rules always
|
|
match before later rules; @samp{nterms(x)} will only be tried if we
|
|
already know that @samp{x} is not a sum.
|
|
|
|
@node Rewrites Answer 6, Programming Answer 1, Rewrites Answer 5, Answers to Exercises
|
|
@subsection Rewrites Tutorial Exercise 6
|
|
|
|
@noindent
|
|
Here is a rule set that will do the job:
|
|
|
|
@smallexample
|
|
@group
|
|
[ a*(b + c) := a*b + a*c,
|
|
opt(a) O(x^n) + opt(b) O(x^m) := O(x^n) :: n <= m
|
|
:: constant(a) :: constant(b),
|
|
opt(a) O(x^n) + opt(b) x^m := O(x^n) :: n <= m
|
|
:: constant(a) :: constant(b),
|
|
a O(x^n) := O(x^n) :: constant(a),
|
|
x^opt(m) O(x^n) := O(x^(n+m)),
|
|
O(x^n) O(x^m) := O(x^(n+m)) ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
If we really want the @kbd{+} and @kbd{*} keys to operate naturally
|
|
on power series, we should put these rules in @code{EvalRules}. For
|
|
testing purposes, it is better to put them in a different variable,
|
|
say, @code{O}, first.
|
|
|
|
The first rule just expands products of sums so that the rest of the
|
|
rules can assume they have an expanded-out polynomial to work with.
|
|
Note that this rule does not mention @samp{O} at all, so it will
|
|
apply to any product-of-sum it encounters---this rule may surprise
|
|
you if you put it into @code{EvalRules}!
|
|
|
|
In the second rule, the sum of two O's is changed to the smaller O.
|
|
The optional constant coefficients are there mostly so that
|
|
@samp{O(x^2) - O(x^3)} and @samp{O(x^3) - O(x^2)} are handled
|
|
as well as @samp{O(x^2) + O(x^3)}.
|
|
|
|
The third rule absorbs higher powers of @samp{x} into O's.
|
|
|
|
The fourth rule says that a constant times a negligible quantity
|
|
is still negligible. (This rule will also match @samp{O(x^3) / 4},
|
|
with @samp{a = 1/4}.)
|
|
|
|
The fifth rule rewrites, for example, @samp{x^2 O(x^3)} to @samp{O(x^5)}.
|
|
(It is easy to see that if one of these forms is negligible, the other
|
|
is, too.) Notice the @samp{x^opt(m)} to pick up terms like
|
|
@w{@samp{x O(x^3)}}. Optional powers will match @samp{x} as @samp{x^1}
|
|
but not 1 as @samp{x^0}. This turns out to be exactly what we want here.
|
|
|
|
The sixth rule is the corresponding rule for products of two O's.
|
|
|
|
Another way to solve this problem would be to create a new ``data type''
|
|
that represents truncated power series. We might represent these as
|
|
function calls @samp{series(@var{coefs}, @var{x})} where @var{coefs} is
|
|
a vector of coefficients for @expr{x^0}, @expr{x^1}, @expr{x^2}, and so
|
|
on. Rules would exist for sums and products of such @code{series}
|
|
objects, and as an optional convenience could also know how to combine a
|
|
@code{series} object with a normal polynomial. (With this, and with a
|
|
rule that rewrites @samp{O(x^n)} to the equivalent @code{series} form,
|
|
you could still enter power series in exactly the same notation as
|
|
before.) Operations on such objects would probably be more efficient,
|
|
although the objects would be a bit harder to read.
|
|
|
|
@c [fix-ref Compositions]
|
|
Some other symbolic math programs provide a power series data type
|
|
similar to this. Mathematica, for example, has an object that looks
|
|
like @samp{PowerSeries[@var{x}, @var{x0}, @var{coefs}, @var{nmin},
|
|
@var{nmax}, @var{den}]}, where @var{x0} is the point about which the
|
|
power series is taken (we've been assuming this was always zero),
|
|
and @var{nmin}, @var{nmax}, and @var{den} allow pseudo-power-series
|
|
with fractional or negative powers. Also, the @code{PowerSeries}
|
|
objects have a special display format that makes them look like
|
|
@samp{2 x^2 + O(x^4)} when they are printed out. (@xref{Compositions},
|
|
for a way to do this in Calc, although for something as involved as
|
|
this it would probably be better to write the formatting routine
|
|
in Lisp.)
|
|
|
|
@node Programming Answer 1, Programming Answer 2, Rewrites Answer 6, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 1
|
|
|
|
@noindent
|
|
Just enter the formula @samp{ninteg(sin(t)/t, t, 0, x)}, type
|
|
@kbd{Z F}, and answer the questions. Since this formula contains two
|
|
variables, the default argument list will be @samp{(t x)}. We want to
|
|
change this to @samp{(x)} since @expr{t} is really a dummy variable
|
|
to be used within @code{ninteg}.
|
|
|
|
The exact keystrokes are @kbd{Z F s Si @key{RET} @key{RET} C-b C-b @key{DEL} @key{DEL} @key{RET} y}.
|
|
(The @kbd{C-b C-b @key{DEL} @key{DEL}} are what fix the argument list.)
|
|
|
|
@node Programming Answer 2, Programming Answer 3, Programming Answer 1, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 2
|
|
|
|
@noindent
|
|
One way is to move the number to the top of the stack, operate on
|
|
it, then move it back: @kbd{C-x ( M-@key{TAB} n M-@key{TAB} M-@key{TAB} C-x )}.
|
|
|
|
Another way is to negate the top three stack entries, then negate
|
|
again the top two stack entries: @kbd{C-x ( M-3 n M-2 n C-x )}.
|
|
|
|
Finally, it turns out that a negative prefix argument causes a
|
|
command like @kbd{n} to operate on the specified stack entry only,
|
|
which is just what we want: @kbd{C-x ( M-- 3 n C-x )}.
|
|
|
|
Just for kicks, let's also do it algebraically:
|
|
@w{@kbd{C-x ( ' -$$$, $$, $ @key{RET} C-x )}}.
|
|
|
|
@node Programming Answer 3, Programming Answer 4, Programming Answer 2, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 3
|
|
|
|
@noindent
|
|
Each of these functions can be computed using the stack, or using
|
|
algebraic entry, whichever way you prefer:
|
|
|
|
@noindent
|
|
Computing
|
|
@texline @math{\displaystyle{\sin x \over x}}:
|
|
@infoline @expr{sin(x) / x}:
|
|
|
|
Using the stack: @kbd{C-x ( @key{RET} S @key{TAB} / C-x )}.
|
|
|
|
Using algebraic entry: @kbd{C-x ( ' sin($)/$ @key{RET} C-x )}.
|
|
|
|
@noindent
|
|
Computing the logarithm:
|
|
|
|
Using the stack: @kbd{C-x ( @key{TAB} B C-x )}
|
|
|
|
Using algebraic entry: @kbd{C-x ( ' log($,$$) @key{RET} C-x )}.
|
|
|
|
@noindent
|
|
Computing the vector of integers:
|
|
|
|
Using the stack: @kbd{C-x ( 1 @key{RET} 1 C-u v x C-x )}. (Recall that
|
|
@kbd{C-u v x} takes the vector size, starting value, and increment
|
|
from the stack.)
|
|
|
|
Alternatively: @kbd{C-x ( ~ v x C-x )}. (The @kbd{~} key pops a
|
|
number from the stack and uses it as the prefix argument for the
|
|
next command.)
|
|
|
|
Using algebraic entry: @kbd{C-x ( ' index($) @key{RET} C-x )}.
|
|
|
|
@node Programming Answer 4, Programming Answer 5, Programming Answer 3, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 4
|
|
|
|
@noindent
|
|
Here's one way: @kbd{C-x ( @key{RET} V R + @key{TAB} v l / C-x )}.
|
|
|
|
@node Programming Answer 5, Programming Answer 6, Programming Answer 4, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 5
|
|
|
|
@smallexample
|
|
@group
|
|
2: 1 1: 1.61803398502 2: 1.61803398502
|
|
1: 20 . 1: 1.61803398875
|
|
. .
|
|
|
|
1 @key{RET} 20 Z < & 1 + Z > I H P
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This answer is quite accurate.
|
|
|
|
@node Programming Answer 6, Programming Answer 7, Programming Answer 5, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 6
|
|
|
|
@noindent
|
|
Here is the matrix:
|
|
|
|
@example
|
|
[ [ 0, 1 ] * [a, b] = [b, a + b]
|
|
[ 1, 1 ] ]
|
|
@end example
|
|
|
|
@noindent
|
|
Thus @samp{[0, 1; 1, 1]^n * [1, 1]} computes Fibonacci numbers @expr{n+1}
|
|
and @expr{n+2}. Here's one program that does the job:
|
|
|
|
@example
|
|
C-x ( ' [0, 1; 1, 1] ^ ($-1) * [1, 1] @key{RET} v u @key{DEL} C-x )
|
|
@end example
|
|
|
|
@noindent
|
|
This program is quite efficient because Calc knows how to raise a
|
|
matrix (or other value) to the power @expr{n} in only
|
|
@texline @math{\log_2 n}
|
|
@infoline @expr{log(n,2)}
|
|
steps. For example, this program can compute the 1000th Fibonacci
|
|
number (a 209-digit integer!) in about 10 steps; even though the
|
|
@kbd{Z < ... Z >} solution had much simpler steps, it would have
|
|
required so many steps that it would not have been practical.
|
|
|
|
@node Programming Answer 7, Programming Answer 8, Programming Answer 6, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 7
|
|
|
|
@noindent
|
|
The trick here is to compute the harmonic numbers differently, so that
|
|
the loop counter itself accumulates the sum of reciprocals. We use
|
|
a separate variable to hold the integer counter.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1 2: 1 1: .
|
|
. 1: 4
|
|
.
|
|
|
|
1 t 1 1 @key{RET} 4 Z ( t 2 r 1 1 + s 1 & Z )
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The body of the loop goes as follows: First save the harmonic sum
|
|
so far in variable 2. Then delete it from the stack; the for loop
|
|
itself will take care of remembering it for us. Next, recall the
|
|
count from variable 1, add one to it, and feed its reciprocal to
|
|
the for loop to use as the step value. The for loop will increase
|
|
the ``loop counter'' by that amount and keep going until the
|
|
loop counter exceeds 4.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 31 3: 31
|
|
1: 3.99498713092 2: 3.99498713092
|
|
. 1: 4.02724519544
|
|
.
|
|
|
|
r 1 r 2 @key{RET} 31 & +
|
|
@end group
|
|
@end smallexample
|
|
|
|
Thus we find that the 30th harmonic number is 3.99, and the 31st
|
|
harmonic number is 4.02.
|
|
|
|
@node Programming Answer 8, Programming Answer 9, Programming Answer 7, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 8
|
|
|
|
@noindent
|
|
The first step is to compute the derivative @expr{f'(x)} and thus
|
|
the formula
|
|
@texline @math{\displaystyle{x - {f(x) \over f'(x)}}}.
|
|
@infoline @expr{x - f(x)/f'(x)}.
|
|
|
|
(Because this definition is long, it will be repeated in concise form
|
|
below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
|
|
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
|
|
keystrokes without executing them. In the following diagrams we'll
|
|
pretend Calc actually executed the keystrokes as you typed them,
|
|
just for purposes of illustration.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: sin(cos(x)) - 0.5 3: 4.5
|
|
1: 4.5 2: sin(cos(x)) - 0.5
|
|
. 1: -(sin(x) cos(cos(x)))
|
|
.
|
|
|
|
' sin(cos(x))-0.5 @key{RET} 4.5 m r C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET}
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: 4.5
|
|
1: x + (sin(cos(x)) - 0.5) / sin(x) cos(cos(x))
|
|
.
|
|
|
|
/ ' x @key{RET} @key{TAB} - t 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now, we enter the loop. We'll use a repeat loop with a 20-repetition
|
|
limit just in case the method fails to converge for some reason.
|
|
(Normally, the @w{@kbd{Z /}} command will stop the loop before all 20
|
|
repetitions are done.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 4.5 3: 4.5 2: 4.5
|
|
. 2: x + (sin(cos(x)) ... 1: 5.24196456928
|
|
1: 4.5 .
|
|
.
|
|
|
|
20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
This is the new guess for @expr{x}. Now we compare it with the
|
|
old one to see if we've converged.
|
|
|
|
@smallexample
|
|
@group
|
|
3: 5.24196 2: 5.24196 1: 5.24196 1: 5.26345856348
|
|
2: 5.24196 1: 0 . .
|
|
1: 4.5 .
|
|
.
|
|
|
|
@key{RET} M-@key{TAB} a = Z / Z > Z ' C-x )
|
|
@end group
|
|
@end smallexample
|
|
|
|
The loop converges in just a few steps to this value. To check
|
|
the result, we can simply substitute it back into the equation.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 5.26345856348
|
|
1: 0.499999999997
|
|
.
|
|
|
|
@key{RET} ' sin(cos($)) @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Let's test the new definition again:
|
|
|
|
@smallexample
|
|
@group
|
|
2: x^2 - 9 1: 3.
|
|
1: 1 .
|
|
.
|
|
|
|
' x^2-9 @key{RET} 1 X
|
|
@end group
|
|
@end smallexample
|
|
|
|
Once again, here's the full Newton's Method definition:
|
|
|
|
@example
|
|
@group
|
|
C-x ( Z ` @key{TAB} @key{RET} a d x @key{RET} / ' x @key{RET} @key{TAB} - t 1
|
|
20 Z < @key{RET} r 1 @key{TAB} s l x @key{RET}
|
|
@key{RET} M-@key{TAB} a = Z /
|
|
Z >
|
|
Z '
|
|
C-x )
|
|
@end group
|
|
@end example
|
|
|
|
@c [fix-ref Nesting and Fixed Points]
|
|
It turns out that Calc has a built-in command for applying a formula
|
|
repeatedly until it converges to a number. @xref{Nesting and Fixed Points},
|
|
to see how to use it.
|
|
|
|
@c [fix-ref Root Finding]
|
|
Also, of course, @kbd{a R} is a built-in command that uses Newton's
|
|
method (among others) to look for numerical solutions to any equation.
|
|
@xref{Root Finding}.
|
|
|
|
@node Programming Answer 9, Programming Answer 10, Programming Answer 8, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 9
|
|
|
|
@noindent
|
|
The first step is to adjust @expr{z} to be greater than 5. A simple
|
|
``for'' loop will do the job here. If @expr{z} is less than 5, we
|
|
reduce the problem using
|
|
@texline @math{\psi(z) = \psi(z+1) - 1/z}.
|
|
@infoline @expr{psi(z) = psi(z+1) - 1/z}. We go
|
|
on to compute
|
|
@texline @math{\psi(z+1)},
|
|
@infoline @expr{psi(z+1)},
|
|
and remember to add back a factor of @expr{-1/z} when we're done. This
|
|
step is repeated until @expr{z > 5}.
|
|
|
|
(Because this definition is long, it will be repeated in concise form
|
|
below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
|
|
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
|
|
keystrokes without executing them. In the following diagrams we'll
|
|
pretend Calc actually executed the keystrokes as you typed them,
|
|
just for purposes of illustration.)
|
|
|
|
@smallexample
|
|
@group
|
|
1: 1. 1: 1.
|
|
. .
|
|
|
|
1.0 @key{RET} C-x ( Z ` s 1 0 t 2
|
|
@end group
|
|
@end smallexample
|
|
|
|
Here, variable 1 holds @expr{z} and variable 2 holds the adjustment
|
|
factor. If @expr{z < 5}, we use a loop to increase it.
|
|
|
|
(By the way, we started with @samp{1.0} instead of the integer 1 because
|
|
otherwise the calculation below will try to do exact fractional arithmetic,
|
|
and will never converge because fractions compare equal only if they
|
|
are exactly equal, not just equal to within the current precision.)
|
|
|
|
@smallexample
|
|
@group
|
|
3: 1. 2: 1. 1: 6.
|
|
2: 1. 1: 1 .
|
|
1: 5 .
|
|
.
|
|
|
|
@key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now we compute the initial part of the sum:
|
|
@texline @math{\ln z - {1 \over 2z}}
|
|
@infoline @expr{ln(z) - 1/2z}
|
|
minus the adjustment factor.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 1.79175946923 2: 1.7084261359 1: -0.57490719743
|
|
1: 0.0833333333333 1: 2.28333333333 .
|
|
. .
|
|
|
|
L r 1 2 * & - r 2 -
|
|
@end group
|
|
@end smallexample
|
|
|
|
Now we evaluate the series. We'll use another ``for'' loop counting
|
|
up the value of @expr{2 n}. (Calc does have a summation command,
|
|
@kbd{a +}, but we'll use loops just to get more practice with them.)
|
|
|
|
@smallexample
|
|
@group
|
|
3: -0.5749 3: -0.5749 4: -0.5749 2: -0.5749
|
|
2: 2 2: 1:6 3: 1:6 1: 2.3148e-3
|
|
1: 40 1: 2 2: 2 .
|
|
. . 1: 36.
|
|
.
|
|
|
|
2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
3: -0.5749 3: -0.5772 2: -0.5772 1: -0.577215664892
|
|
2: -0.5749 2: -0.5772 1: 0 .
|
|
1: 2.3148e-3 1: -0.5749 .
|
|
. .
|
|
|
|
@key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z / 2 Z ) Z ' C-x )
|
|
@end group
|
|
@end smallexample
|
|
|
|
This is the value of
|
|
@texline @math{-\gamma},
|
|
@infoline @expr{- gamma},
|
|
with a slight bit of roundoff error. To get a full 12 digits, let's use
|
|
a higher precision:
|
|
|
|
@smallexample
|
|
@group
|
|
2: -0.577215664892 2: -0.577215664892
|
|
1: 1. 1: -0.577215664901532
|
|
|
|
1. @key{RET} p 16 @key{RET} X
|
|
@end group
|
|
@end smallexample
|
|
|
|
Here's the complete sequence of keystrokes:
|
|
|
|
@example
|
|
@group
|
|
C-x ( Z ` s 1 0 t 2
|
|
@key{RET} 5 a < Z [ 5 Z ( & s + 2 1 s + 1 1 Z ) r 1 Z ]
|
|
L r 1 2 * & - r 2 -
|
|
2 @key{RET} 40 Z ( @key{RET} k b @key{TAB} @key{RET} r 1 @key{TAB} ^ * /
|
|
@key{TAB} @key{RET} M-@key{TAB} - @key{RET} M-@key{TAB} a = Z /
|
|
2 Z )
|
|
Z '
|
|
C-x )
|
|
@end group
|
|
@end example
|
|
|
|
@node Programming Answer 10, Programming Answer 11, Programming Answer 9, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 10
|
|
|
|
@noindent
|
|
Taking the derivative of a term of the form @expr{x^n} will produce
|
|
a term like
|
|
@texline @math{n x^{n-1}}.
|
|
@infoline @expr{n x^(n-1)}.
|
|
Taking the derivative of a constant
|
|
produces zero. From this it is easy to see that the @expr{n}th
|
|
derivative of a polynomial, evaluated at @expr{x = 0}, will equal the
|
|
coefficient on the @expr{x^n} term times @expr{n!}.
|
|
|
|
(Because this definition is long, it will be repeated in concise form
|
|
below. You can use @w{@kbd{C-x * m}} to load it from there. While you are
|
|
entering a @kbd{Z ` Z '} body in a macro, Calc simply collects
|
|
keystrokes without executing them. In the following diagrams we'll
|
|
pretend Calc actually executed the keystrokes as you typed them,
|
|
just for purposes of illustration.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: 5 x^4 + (x + 1)^2 3: 5 x^4 + (x + 1)^2
|
|
1: 6 2: 0
|
|
. 1: 6
|
|
.
|
|
|
|
' 5 x^4 + (x+1)^2 @key{RET} 6 C-x ( Z ` [ ] t 1 0 @key{TAB}
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Variable 1 will accumulate the vector of coefficients.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 0 3: 0 2: 5 x^4 + ...
|
|
1: 5 x^4 + ... 2: 5 x^4 + ... 1: 1
|
|
. 1: 1 .
|
|
.
|
|
|
|
Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that @kbd{s | 1} appends the top-of-stack value to the vector
|
|
in a variable; it is completely analogous to @kbd{s + 1}. We could
|
|
have written instead, @kbd{r 1 @key{TAB} | t 1}.
|
|
|
|
@smallexample
|
|
@group
|
|
1: 20 x^3 + 2 x + 2 1: 0 1: [1, 2, 1, 0, 5, 0, 0]
|
|
. . .
|
|
|
|
a d x @key{RET} 1 Z ) @key{DEL} r 1 Z ' C-x )
|
|
@end group
|
|
@end smallexample
|
|
|
|
To convert back, a simple method is just to map the coefficients
|
|
against a table of powers of @expr{x}.
|
|
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 1, 0, 5, 0, 0] 2: [1, 2, 1, 0, 5, 0, 0]
|
|
1: 6 1: [0, 1, 2, 3, 4, 5, 6]
|
|
. .
|
|
|
|
6 @key{RET} 1 + 0 @key{RET} 1 C-u v x
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
2: [1, 2, 1, 0, 5, 0, 0] 2: 1 + 2 x + x^2 + 5 x^4
|
|
1: [1, x, x^2, x^3, ... ] .
|
|
.
|
|
|
|
' x @key{RET} @key{TAB} V M ^ *
|
|
@end group
|
|
@end smallexample
|
|
|
|
Once again, here are the whole polynomial to/from vector programs:
|
|
|
|
@example
|
|
@group
|
|
C-x ( Z ` [ ] t 1 0 @key{TAB}
|
|
Z ( @key{TAB} @key{RET} 0 s l x @key{RET} M-@key{TAB} ! / s | 1
|
|
a d x @key{RET}
|
|
1 Z ) r 1
|
|
Z '
|
|
C-x )
|
|
|
|
C-x ( 1 + 0 @key{RET} 1 C-u v x ' x @key{RET} @key{TAB} V M ^ * C-x )
|
|
@end group
|
|
@end example
|
|
|
|
@node Programming Answer 11, Programming Answer 12, Programming Answer 10, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 11
|
|
|
|
@noindent
|
|
First we define a dummy program to go on the @kbd{z s} key. The true
|
|
@w{@kbd{z s}} key is supposed to take two numbers from the stack and
|
|
return one number, so @key{DEL} as a dummy definition will make
|
|
sure the stack comes out right.
|
|
|
|
@smallexample
|
|
@group
|
|
2: 4 1: 4 2: 4
|
|
1: 2 . 1: 2
|
|
. .
|
|
|
|
4 @key{RET} 2 C-x ( @key{DEL} C-x ) Z K s @key{RET} 2
|
|
@end group
|
|
@end smallexample
|
|
|
|
The last step replaces the 2 that was eaten during the creation
|
|
of the dummy @kbd{z s} command. Now we move on to the real
|
|
definition. The recurrence needs to be rewritten slightly,
|
|
to the form @expr{s(n,m) = s(n-1,m-1) - (n-1) s(n-1,m)}.
|
|
|
|
(Because this definition is long, it will be repeated in concise form
|
|
below. You can use @kbd{C-x * m} to load it from there.)
|
|
|
|
@smallexample
|
|
@group
|
|
2: 4 4: 4 3: 4 2: 4
|
|
1: 2 3: 2 2: 2 1: 2
|
|
. 2: 4 1: 0 .
|
|
1: 2 .
|
|
.
|
|
|
|
C-x ( M-2 @key{RET} a = Z [ @key{DEL} @key{DEL} 1 Z :
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
4: 4 2: 4 2: 3 4: 3 4: 3 3: 3
|
|
3: 2 1: 2 1: 2 3: 2 3: 2 2: 2
|
|
2: 2 . . 2: 3 2: 3 1: 3
|
|
1: 0 1: 2 1: 1 .
|
|
. . .
|
|
|
|
@key{RET} 0 a = Z [ @key{DEL} @key{DEL} 0 Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(Note that the value 3 that our dummy @kbd{z s} produces is not correct;
|
|
it is merely a placeholder that will do just as well for now.)
|
|
|
|
@smallexample
|
|
@group
|
|
3: 3 4: 3 3: 3 2: 3 1: -6
|
|
2: 3 3: 3 2: 3 1: 9 .
|
|
1: 2 2: 3 1: 3 .
|
|
. 1: 2 .
|
|
.
|
|
|
|
M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
|
|
|
|
@end group
|
|
@end smallexample
|
|
@noindent
|
|
@smallexample
|
|
@group
|
|
1: -6 2: 4 1: 11 2: 11
|
|
. 1: 2 . 1: 11
|
|
. .
|
|
|
|
Z ] Z ] C-x ) Z K s @key{RET} @key{DEL} 4 @key{RET} 2 z s M-@key{RET} k s
|
|
@end group
|
|
@end smallexample
|
|
|
|
Even though the result that we got during the definition was highly
|
|
bogus, once the definition is complete the @kbd{z s} command gets
|
|
the right answers.
|
|
|
|
Here's the full program once again:
|
|
|
|
@example
|
|
@group
|
|
C-x ( M-2 @key{RET} a =
|
|
Z [ @key{DEL} @key{DEL} 1
|
|
Z : @key{RET} 0 a =
|
|
Z [ @key{DEL} @key{DEL} 0
|
|
Z : @key{TAB} 1 - @key{TAB} M-2 @key{RET} 1 - z s
|
|
M-@key{TAB} M-@key{TAB} @key{TAB} @key{RET} M-@key{TAB} z s * -
|
|
Z ]
|
|
Z ]
|
|
C-x )
|
|
@end group
|
|
@end example
|
|
|
|
You can read this definition using @kbd{C-x * m} (@code{read-kbd-macro})
|
|
followed by @kbd{Z K s}, without having to make a dummy definition
|
|
first, because @code{read-kbd-macro} doesn't need to execute the
|
|
definition as it reads it in. For this reason, @code{C-x * m} is often
|
|
the easiest way to create recursive programs in Calc.
|
|
|
|
@node Programming Answer 12, , Programming Answer 11, Answers to Exercises
|
|
@subsection Programming Tutorial Exercise 12
|
|
|
|
@noindent
|
|
This turns out to be a much easier way to solve the problem. Let's
|
|
denote Stirling numbers as calls of the function @samp{s}.
|
|
|
|
First, we store the rewrite rules corresponding to the definition of
|
|
Stirling numbers in a convenient variable:
|
|
|
|
@smallexample
|
|
s e StirlingRules @key{RET}
|
|
[ s(n,n) := 1 :: n >= 0,
|
|
s(n,0) := 0 :: n > 0,
|
|
s(n,m) := s(n-1,m-1) - (n-1) s(n-1,m) :: n >= m :: m >= 1 ]
|
|
C-c C-c
|
|
@end smallexample
|
|
|
|
Now, it's just a matter of applying the rules:
|
|
|
|
@smallexample
|
|
@group
|
|
2: 4 1: s(4, 2) 1: 11
|
|
1: 2 . .
|
|
.
|
|
|
|
4 @key{RET} 2 C-x ( ' s($$,$) @key{RET} a r StirlingRules @key{RET} C-x )
|
|
@end group
|
|
@end smallexample
|
|
|
|
As in the case of the @code{fib} rules, it would be useful to put these
|
|
rules in @code{EvalRules} and to add a @samp{:: remember} condition to
|
|
the last rule.
|
|
|
|
@c This ends the table-of-contents kludge from above:
|
|
@tex
|
|
\global\let\chapternofonts=\oldchapternofonts
|
|
@end tex
|
|
|
|
@c [reference]
|
|
|
|
@node Introduction, Data Types, Tutorial, Top
|
|
@chapter Introduction
|
|
|
|
@noindent
|
|
This chapter is the beginning of the Calc reference manual.
|
|
It covers basic concepts such as the stack, algebraic and
|
|
numeric entry, undo, numeric prefix arguments, etc.
|
|
|
|
@c [when-split]
|
|
@c (Chapter 2, the Tutorial, has been printed in a separate volume.)
|
|
|
|
@menu
|
|
* Basic Commands::
|
|
* Help Commands::
|
|
* Stack Basics::
|
|
* Numeric Entry::
|
|
* Algebraic Entry::
|
|
* Quick Calculator::
|
|
* Prefix Arguments::
|
|
* Undo::
|
|
* Error Messages::
|
|
* Multiple Calculators::
|
|
* Troubleshooting Commands::
|
|
@end menu
|
|
|
|
@node Basic Commands, Help Commands, Introduction, Introduction
|
|
@section Basic Commands
|
|
|
|
@noindent
|
|
@pindex calc
|
|
@pindex calc-mode
|
|
@cindex Starting the Calculator
|
|
@cindex Running the Calculator
|
|
To start the Calculator in its standard interface, type @kbd{M-x calc}.
|
|
By default this creates a pair of small windows, @samp{*Calculator*}
|
|
and @samp{*Calc Trail*}. The former displays the contents of the
|
|
Calculator stack and is manipulated exclusively through Calc commands.
|
|
It is possible (though not usually necessary) to create several Calc
|
|
mode buffers each of which has an independent stack, undo list, and
|
|
mode settings. There is exactly one Calc Trail buffer; it records a
|
|
list of the results of all calculations that have been done. The
|
|
Calc Trail buffer uses a variant of Calc mode, so Calculator commands
|
|
still work when the trail buffer's window is selected. It is possible
|
|
to turn the trail window off, but the @samp{*Calc Trail*} buffer itself
|
|
still exists and is updated silently. @xref{Trail Commands}.
|
|
|
|
@kindex C-x * c
|
|
@kindex C-x * *
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
In most installations, the @kbd{C-x * c} key sequence is a more
|
|
convenient way to start the Calculator. Also, @kbd{C-x * *}
|
|
is a synonym for @kbd{C-x * c} unless you last used Calc
|
|
in its Keypad mode.
|
|
|
|
@kindex x
|
|
@kindex M-x
|
|
@pindex calc-execute-extended-command
|
|
Most Calc commands use one or two keystrokes. Lower- and upper-case
|
|
letters are distinct. Commands may also be entered in full @kbd{M-x} form;
|
|
for some commands this is the only form. As a convenience, the @kbd{x}
|
|
key (@code{calc-execute-extended-command})
|
|
is like @kbd{M-x} except that it enters the initial string @samp{calc-}
|
|
for you. For example, the following key sequences are equivalent:
|
|
@kbd{S}, @kbd{M-x calc-sin @key{RET}}, @kbd{x sin @key{RET}}.
|
|
|
|
@cindex Extensions module
|
|
@cindex @file{calc-ext} module
|
|
The Calculator exists in many parts. When you type @kbd{C-x * c}, the
|
|
Emacs ``auto-load'' mechanism will bring in only the first part, which
|
|
contains the basic arithmetic functions. The other parts will be
|
|
auto-loaded the first time you use the more advanced commands like trig
|
|
functions or matrix operations. This is done to improve the response time
|
|
of the Calculator in the common case when all you need to do is a
|
|
little arithmetic. If for some reason the Calculator fails to load an
|
|
extension module automatically, you can force it to load all the
|
|
extensions by using the @kbd{C-x * L} (@code{calc-load-everything})
|
|
command. @xref{Mode Settings}.
|
|
|
|
If you type @kbd{M-x calc} or @kbd{C-x * c} with any numeric prefix argument,
|
|
the Calculator is loaded if necessary, but it is not actually started.
|
|
If the argument is positive, the @file{calc-ext} extensions are also
|
|
loaded if necessary. User-written Lisp code that wishes to make use
|
|
of Calc's arithmetic routines can use @samp{(calc 0)} or @samp{(calc 1)}
|
|
to auto-load the Calculator.
|
|
|
|
@kindex C-x * b
|
|
@pindex full-calc
|
|
If you type @kbd{C-x * b}, then next time you use @kbd{C-x * c} you
|
|
will get a Calculator that uses the full height of the Emacs screen.
|
|
When full-screen mode is on, @kbd{C-x * c} runs the @code{full-calc}
|
|
command instead of @code{calc}. From the Unix shell you can type
|
|
@samp{emacs -f full-calc} to start a new Emacs specifically for use
|
|
as a calculator. When Calc is started from the Emacs command line
|
|
like this, Calc's normal ``quit'' commands actually quit Emacs itself.
|
|
|
|
@kindex C-x * o
|
|
@pindex calc-other-window
|
|
The @kbd{C-x * o} command is like @kbd{C-x * c} except that the Calc
|
|
window is not actually selected. If you are already in the Calc
|
|
window, @kbd{C-x * o} switches you out of it. (The regular Emacs
|
|
@kbd{C-x o} command would also work for this, but it has a
|
|
tendency to drop you into the Calc Trail window instead, which
|
|
@kbd{C-x * o} takes care not to do.)
|
|
|
|
@ignore
|
|
@mindex C-x * q
|
|
@end ignore
|
|
For one quick calculation, you can type @kbd{C-x * q} (@code{quick-calc})
|
|
which prompts you for a formula (like @samp{2+3/4}). The result is
|
|
displayed at the bottom of the Emacs screen without ever creating
|
|
any special Calculator windows. @xref{Quick Calculator}.
|
|
|
|
@ignore
|
|
@mindex C-x * k
|
|
@end ignore
|
|
Finally, if you are using the X window system you may want to try
|
|
@kbd{C-x * k} (@code{calc-keypad}) which runs Calc with a
|
|
``calculator keypad'' picture as well as a stack display. Click on
|
|
the keys with the mouse to operate the calculator. @xref{Keypad Mode}.
|
|
|
|
@kindex q
|
|
@pindex calc-quit
|
|
@cindex Quitting the Calculator
|
|
@cindex Exiting the Calculator
|
|
The @kbd{q} key (@code{calc-quit}) exits Calc mode and closes the
|
|
Calculator's window(s). It does not delete the Calculator buffers.
|
|
If you type @kbd{M-x calc} again, the Calculator will reappear with the
|
|
contents of the stack intact. Typing @kbd{C-x * c} or @kbd{C-x * *}
|
|
again from inside the Calculator buffer is equivalent to executing
|
|
@code{calc-quit}; you can think of @kbd{C-x * *} as toggling the
|
|
Calculator on and off.
|
|
|
|
@kindex C-x * x
|
|
The @kbd{C-x * x} command also turns the Calculator off, no matter which
|
|
user interface (standard, Keypad, or Embedded) is currently active.
|
|
It also cancels @code{calc-edit} mode if used from there.
|
|
|
|
@kindex d @key{SPC}
|
|
@pindex calc-refresh
|
|
@cindex Refreshing a garbled display
|
|
@cindex Garbled displays, refreshing
|
|
The @kbd{d @key{SPC}} key sequence (@code{calc-refresh}) redraws the contents
|
|
of the Calculator buffer from memory. Use this if the contents of the
|
|
buffer have been damaged somehow.
|
|
|
|
@ignore
|
|
@mindex o
|
|
@end ignore
|
|
The @kbd{o} key (@code{calc-realign}) moves the cursor back to its
|
|
``home'' position at the bottom of the Calculator buffer.
|
|
|
|
@kindex <
|
|
@kindex >
|
|
@pindex calc-scroll-left
|
|
@pindex calc-scroll-right
|
|
@cindex Horizontal scrolling
|
|
@cindex Scrolling
|
|
@cindex Wide text, scrolling
|
|
The @kbd{<} and @kbd{>} keys are bound to @code{calc-scroll-left} and
|
|
@code{calc-scroll-right}. These are just like the normal horizontal
|
|
scrolling commands except that they scroll one half-screen at a time by
|
|
default. (Calc formats its output to fit within the bounds of the
|
|
window whenever it can.)
|
|
|
|
@kindex @{
|
|
@kindex @}
|
|
@pindex calc-scroll-down
|
|
@pindex calc-scroll-up
|
|
@cindex Vertical scrolling
|
|
The @kbd{@{} and @kbd{@}} keys are bound to @code{calc-scroll-down}
|
|
and @code{calc-scroll-up}. They scroll up or down by one-half the
|
|
height of the Calc window.
|
|
|
|
@kindex C-x * 0
|
|
@pindex calc-reset
|
|
The @kbd{C-x * 0} command (@code{calc-reset}; that's @kbd{C-x *} followed
|
|
by a zero) resets the Calculator to its initial state. This clears
|
|
the stack, resets all the modes to their initial values (the values
|
|
that were saved with @kbd{m m} (@code{calc-save-modes})), clears the
|
|
caches (@pxref{Caches}), and so on. (It does @emph{not} erase the
|
|
values of any variables.) With an argument of 0, Calc will be reset to
|
|
its default state; namely, the modes will be given their default values.
|
|
With a positive prefix argument, @kbd{C-x * 0} preserves the contents of
|
|
the stack but resets everything else to its initial state; with a
|
|
negative prefix argument, @kbd{C-x * 0} preserves the contents of the
|
|
stack but resets everything else to its default state.
|
|
|
|
@pindex calc-version
|
|
The @kbd{M-x calc-version} command displays the current version number
|
|
of Calc and the name of the person who installed it on your system.
|
|
(This information is also present in the @samp{*Calc Trail*} buffer,
|
|
and in the output of the @kbd{h h} command.)
|
|
|
|
@node Help Commands, Stack Basics, Basic Commands, Introduction
|
|
@section Help Commands
|
|
|
|
@noindent
|
|
@cindex Help commands
|
|
@kindex ?
|
|
@pindex calc-help
|
|
The @kbd{?} key (@code{calc-help}) displays a series of brief help messages.
|
|
Some keys (such as @kbd{b} and @kbd{d}) are prefix keys, like Emacs'
|
|
@key{ESC} and @kbd{C-x} prefixes. You can type
|
|
@kbd{?} after a prefix to see a list of commands beginning with that
|
|
prefix. (If the message includes @samp{[MORE]}, press @kbd{?} again
|
|
to see additional commands for that prefix.)
|
|
|
|
@kindex h h
|
|
@pindex calc-full-help
|
|
The @kbd{h h} (@code{calc-full-help}) command displays all the @kbd{?}
|
|
responses at once. When printed, this makes a nice, compact (three pages)
|
|
summary of Calc keystrokes.
|
|
|
|
In general, the @kbd{h} key prefix introduces various commands that
|
|
provide help within Calc. Many of the @kbd{h} key functions are
|
|
Calc-specific analogues to the @kbd{C-h} functions for Emacs help.
|
|
|
|
@kindex h i
|
|
@kindex C-x * i
|
|
@kindex i
|
|
@pindex calc-info
|
|
The @kbd{h i} (@code{calc-info}) command runs the Emacs Info system
|
|
to read this manual on-line. This is basically the same as typing
|
|
@kbd{C-h i} (the regular way to run the Info system), then, if Info
|
|
is not already in the Calc manual, selecting the beginning of the
|
|
manual. The @kbd{C-x * i} command is another way to read the Calc
|
|
manual; it is different from @kbd{h i} in that it works any time,
|
|
not just inside Calc. The plain @kbd{i} key is also equivalent to
|
|
@kbd{h i}, though this key is obsolete and may be replaced with a
|
|
different command in a future version of Calc.
|
|
|
|
@kindex h t
|
|
@kindex C-x * t
|
|
@pindex calc-tutorial
|
|
The @kbd{h t} (@code{calc-tutorial}) command runs the Info system on
|
|
the Tutorial section of the Calc manual. It is like @kbd{h i},
|
|
except that it selects the starting node of the tutorial rather
|
|
than the beginning of the whole manual. (It actually selects the
|
|
node ``Interactive Tutorial'' which tells a few things about
|
|
using the Info system before going on to the actual tutorial.)
|
|
The @kbd{C-x * t} key is equivalent to @kbd{h t} (but it works at
|
|
all times).
|
|
|
|
@kindex h s
|
|
@kindex C-x * s
|
|
@pindex calc-info-summary
|
|
The @kbd{h s} (@code{calc-info-summary}) command runs the Info system
|
|
on the Summary node of the Calc manual. @xref{Summary}. The @kbd{C-x * s}
|
|
key is equivalent to @kbd{h s}.
|
|
|
|
@kindex h k
|
|
@pindex calc-describe-key
|
|
The @kbd{h k} (@code{calc-describe-key}) command looks up a key
|
|
sequence in the Calc manual. For example, @kbd{h k H a S} looks
|
|
up the documentation on the @kbd{H a S} (@code{calc-solve-for})
|
|
command. This works by looking up the textual description of
|
|
the key(s) in the Key Index of the manual, then jumping to the
|
|
node indicated by the index.
|
|
|
|
Most Calc commands do not have traditional Emacs documentation
|
|
strings, since the @kbd{h k} command is both more convenient and
|
|
more instructive. This means the regular Emacs @kbd{C-h k}
|
|
(@code{describe-key}) command will not be useful for Calc keystrokes.
|
|
|
|
@kindex h c
|
|
@pindex calc-describe-key-briefly
|
|
The @kbd{h c} (@code{calc-describe-key-briefly}) command reads a
|
|
key sequence and displays a brief one-line description of it at
|
|
the bottom of the screen. It looks for the key sequence in the
|
|
Summary node of the Calc manual; if it doesn't find the sequence
|
|
there, it acts just like its regular Emacs counterpart @kbd{C-h c}
|
|
(@code{describe-key-briefly}). For example, @kbd{h c H a S}
|
|
gives the description:
|
|
|
|
@smallexample
|
|
H a S runs calc-solve-for: a `H a S' v => fsolve(a,v) (?=notes)
|
|
@end smallexample
|
|
|
|
@noindent
|
|
which means the command @kbd{H a S} or @kbd{H M-x calc-solve-for}
|
|
takes a value @expr{a} from the stack, prompts for a value @expr{v},
|
|
then applies the algebraic function @code{fsolve} to these values.
|
|
The @samp{?=notes} message means you can now type @kbd{?} to see
|
|
additional notes from the summary that apply to this command.
|
|
|
|
@kindex h f
|
|
@pindex calc-describe-function
|
|
The @kbd{h f} (@code{calc-describe-function}) command looks up an
|
|
algebraic function or a command name in the Calc manual. Enter an
|
|
algebraic function name to look up that function in the Function
|
|
Index or enter a command name beginning with @samp{calc-} to look it
|
|
up in the Command Index. This command will also look up operator
|
|
symbols that can appear in algebraic formulas, like @samp{%} and
|
|
@samp{=>}.
|
|
|
|
@kindex h v
|
|
@pindex calc-describe-variable
|
|
The @kbd{h v} (@code{calc-describe-variable}) command looks up a
|
|
variable in the Calc manual. Enter a variable name like @code{pi} or
|
|
@code{PlotRejects}.
|
|
|
|
@kindex h b
|
|
@pindex describe-bindings
|
|
The @kbd{h b} (@code{calc-describe-bindings}) command is just like
|
|
@kbd{C-h b}, except that only local (Calc-related) key bindings are
|
|
listed.
|
|
|
|
@kindex h n
|
|
The @kbd{h n} or @kbd{h C-n} (@code{calc-view-news}) command displays
|
|
the ``news'' or change history of Calc. This is kept in the file
|
|
@file{README}, which Calc looks for in the same directory as the Calc
|
|
source files.
|
|
|
|
@kindex h C-c
|
|
@kindex h C-d
|
|
@kindex h C-w
|
|
The @kbd{h C-c}, @kbd{h C-d}, and @kbd{h C-w} keys display copying,
|
|
distribution, and warranty information about Calc. These work by
|
|
pulling up the appropriate parts of the ``Copying'' or ``Reporting
|
|
Bugs'' sections of the manual.
|
|
|
|
@node Stack Basics, Numeric Entry, Help Commands, Introduction
|
|
@section Stack Basics
|
|
|
|
@noindent
|
|
@cindex Stack basics
|
|
@c [fix-tut RPN Calculations and the Stack]
|
|
Calc uses RPN notation. If you are not familiar with RPN, @pxref{RPN
|
|
Tutorial}.
|
|
|
|
To add the numbers 1 and 2 in Calc you would type the keys:
|
|
@kbd{1 @key{RET} 2 +}.
|
|
(@key{RET} corresponds to the @key{ENTER} key on most calculators.)
|
|
The first three keystrokes ``push'' the numbers 1 and 2 onto the stack. The
|
|
@kbd{+} key always ``pops'' the top two numbers from the stack, adds them,
|
|
and pushes the result (3) back onto the stack. This number is ready for
|
|
further calculations: @kbd{5 -} pushes 5 onto the stack, then pops the
|
|
3 and 5, subtracts them, and pushes the result (@mathit{-2}).
|
|
|
|
Note that the ``top'' of the stack actually appears at the @emph{bottom}
|
|
of the buffer. A line containing a single @samp{.} character signifies
|
|
the end of the buffer; Calculator commands operate on the number(s)
|
|
directly above this line. The @kbd{d t} (@code{calc-truncate-stack})
|
|
command allows you to move the @samp{.} marker up and down in the stack;
|
|
@pxref{Truncating the Stack}.
|
|
|
|
@kindex d l
|
|
@pindex calc-line-numbering
|
|
Stack elements are numbered consecutively, with number 1 being the top of
|
|
the stack. These line numbers are ordinarily displayed on the lefthand side
|
|
of the window. The @kbd{d l} (@code{calc-line-numbering}) command controls
|
|
whether these numbers appear. (Line numbers may be turned off since they
|
|
slow the Calculator down a bit and also clutter the display.)
|
|
|
|
@kindex o
|
|
@pindex calc-realign
|
|
The unshifted letter @kbd{o} (@code{calc-realign}) command repositions
|
|
the cursor to its top-of-stack ``home'' position. It also undoes any
|
|
horizontal scrolling in the window. If you give it a numeric prefix
|
|
argument, it instead moves the cursor to the specified stack element.
|
|
|
|
The @key{RET} (or equivalent @key{SPC}) key is only required to separate
|
|
two consecutive numbers.
|
|
(After all, if you typed @kbd{1 2} by themselves the Calculator
|
|
would enter the number 12.) If you press @key{RET} or @key{SPC} @emph{not}
|
|
right after typing a number, the key duplicates the number on the top of
|
|
the stack. @kbd{@key{RET} *} is thus a handy way to square a number.
|
|
|
|
The @key{DEL} key pops and throws away the top number on the stack.
|
|
The @key{TAB} key swaps the top two objects on the stack.
|
|
@xref{Stack and Trail}, for descriptions of these and other stack-related
|
|
commands.
|
|
|
|
@node Numeric Entry, Algebraic Entry, Stack Basics, Introduction
|
|
@section Numeric Entry
|
|
|
|
@noindent
|
|
@kindex 0-9
|
|
@kindex .
|
|
@kindex e
|
|
@cindex Numeric entry
|
|
@cindex Entering numbers
|
|
Pressing a digit or other numeric key begins numeric entry using the
|
|
minibuffer. The number is pushed on the stack when you press the @key{RET}
|
|
or @key{SPC} keys. If you press any other non-numeric key, the number is
|
|
pushed onto the stack and the appropriate operation is performed. If
|
|
you press a numeric key which is not valid, the key is ignored.
|
|
|
|
@cindex Minus signs
|
|
@cindex Negative numbers, entering
|
|
@kindex _
|
|
There are three different concepts corresponding to the word ``minus,''
|
|
typified by @expr{a-b} (subtraction), @expr{-x}
|
|
(change-sign), and @expr{-5} (negative number). Calc uses three
|
|
different keys for these operations, respectively:
|
|
@kbd{-}, @kbd{n}, and @kbd{_} (the underscore). The @kbd{-} key subtracts
|
|
the two numbers on the top of the stack. The @kbd{n} key changes the sign
|
|
of the number on the top of the stack or the number currently being entered.
|
|
The @kbd{_} key begins entry of a negative number or changes the sign of
|
|
the number currently being entered. The following sequences all enter the
|
|
number @mathit{-5} onto the stack: @kbd{0 @key{RET} 5 -}, @kbd{5 n @key{RET}},
|
|
@kbd{5 @key{RET} n}, @kbd{_ 5 @key{RET}}, @kbd{5 _ @key{RET}}.
|
|
|
|
Some other keys are active during numeric entry, such as @kbd{#} for
|
|
non-decimal numbers, @kbd{:} for fractions, and @kbd{@@} for HMS forms.
|
|
These notations are described later in this manual with the corresponding
|
|
data types. @xref{Data Types}.
|
|
|
|
During numeric entry, the only editing key available is @key{DEL}.
|
|
|
|
@node Algebraic Entry, Quick Calculator, Numeric Entry, Introduction
|
|
@section Algebraic Entry
|
|
|
|
@noindent
|
|
@kindex '
|
|
@pindex calc-algebraic-entry
|
|
@cindex Algebraic notation
|
|
@cindex Formulas, entering
|
|
Calculations can also be entered in algebraic form. This is accomplished
|
|
by typing the apostrophe key, @kbd{'}, followed by the expression in
|
|
standard format: @kbd{@key{'} 2+3*4 @key{RET}} computes
|
|
@texline @math{2+(3\times4) = 14}
|
|
@infoline @expr{2+(3*4) = 14}
|
|
and pushes that on the stack. If you wish you can
|
|
ignore the RPN aspect of Calc altogether and simply enter algebraic
|
|
expressions in this way. You may want to use @key{DEL} every so often to
|
|
clear previous results off the stack.
|
|
|
|
You can press the apostrophe key during normal numeric entry to switch
|
|
the half-entered number into Algebraic entry mode. One reason to do this
|
|
would be to use the full Emacs cursor motion and editing keys, which are
|
|
available during algebraic entry but not during numeric entry.
|
|
|
|
In the same vein, during either numeric or algebraic entry you can
|
|
press @kbd{`} (backquote) to switch to @code{calc-edit} mode, where
|
|
you complete your half-finished entry in a separate buffer.
|
|
@xref{Editing Stack Entries}.
|
|
|
|
@kindex m a
|
|
@pindex calc-algebraic-mode
|
|
@cindex Algebraic Mode
|
|
If you prefer algebraic entry, you can use the command @kbd{m a}
|
|
(@code{calc-algebraic-mode}) to set Algebraic mode. In this mode,
|
|
digits and other keys that would normally start numeric entry instead
|
|
start full algebraic entry; as long as your formula begins with a digit
|
|
you can omit the apostrophe. Open parentheses and square brackets also
|
|
begin algebraic entry. You can still do RPN calculations in this mode,
|
|
but you will have to press @key{RET} to terminate every number:
|
|
@kbd{2 @key{RET} 3 @key{RET} * 4 @key{RET} +} would accomplish the same
|
|
thing as @kbd{2*3+4 @key{RET}}.
|
|
|
|
@cindex Incomplete Algebraic Mode
|
|
If you give a numeric prefix argument like @kbd{C-u} to the @kbd{m a}
|
|
command, it enables Incomplete Algebraic mode; this is like regular
|
|
Algebraic mode except that it applies to the @kbd{(} and @kbd{[} keys
|
|
only. Numeric keys still begin a numeric entry in this mode.
|
|
|
|
@kindex m t
|
|
@pindex calc-total-algebraic-mode
|
|
@cindex Total Algebraic Mode
|
|
The @kbd{m t} (@code{calc-total-algebraic-mode}) gives you an even
|
|
stronger algebraic-entry mode, in which @emph{all} regular letter and
|
|
punctuation keys begin algebraic entry. Use this if you prefer typing
|
|
@w{@kbd{sqrt( )}} instead of @kbd{Q}, @w{@kbd{factor( )}} instead of
|
|
@kbd{a f}, and so on. To type regular Calc commands when you are in
|
|
Total Algebraic mode, hold down the @key{META} key. Thus @kbd{M-q}
|
|
is the command to quit Calc, @kbd{M-p} sets the precision, and
|
|
@kbd{M-m t} (or @kbd{M-m M-t}, if you prefer) turns Total Algebraic
|
|
mode back off again. Meta keys also terminate algebraic entry, so
|
|
that @kbd{2+3 M-S} is equivalent to @kbd{2+3 @key{RET} M-S}. The symbol
|
|
@samp{Alg*} will appear in the mode line whenever you are in this mode.
|
|
|
|
Pressing @kbd{'} (the apostrophe) a second time re-enters the previous
|
|
algebraic formula. You can then use the normal Emacs editing keys to
|
|
modify this formula to your liking before pressing @key{RET}.
|
|
|
|
@kindex $
|
|
@cindex Formulas, referring to stack
|
|
Within a formula entered from the keyboard, the symbol @kbd{$}
|
|
represents the number on the top of the stack. If an entered formula
|
|
contains any @kbd{$} characters, the Calculator replaces the top of
|
|
stack with that formula rather than simply pushing the formula onto the
|
|
stack. Thus, @kbd{' 1+2 @key{RET}} pushes 3 on the stack, and @kbd{$*2
|
|
@key{RET}} replaces it with 6. Note that the @kbd{$} key always
|
|
initiates algebraic entry; the @kbd{'} is unnecessary if @kbd{$} is the
|
|
first character in the new formula.
|
|
|
|
Higher stack elements can be accessed from an entered formula with the
|
|
symbols @kbd{$$}, @kbd{$$$}, and so on. The number of stack elements
|
|
removed (to be replaced by the entered values) equals the number of dollar
|
|
signs in the longest such symbol in the formula. For example, @samp{$$+$$$}
|
|
adds the second and third stack elements, replacing the top three elements
|
|
with the answer. (All information about the top stack element is thus lost
|
|
since no single @samp{$} appears in this formula.)
|
|
|
|
A slightly different way to refer to stack elements is with a dollar
|
|
sign followed by a number: @samp{$1}, @samp{$2}, and so on are much
|
|
like @samp{$}, @samp{$$}, etc., except that stack entries referred
|
|
to numerically are not replaced by the algebraic entry. That is, while
|
|
@samp{$+1} replaces 5 on the stack with 6, @samp{$1+1} leaves the 5
|
|
on the stack and pushes an additional 6.
|
|
|
|
If a sequence of formulas are entered separated by commas, each formula
|
|
is pushed onto the stack in turn. For example, @samp{1,2,3} pushes
|
|
those three numbers onto the stack (leaving the 3 at the top), and
|
|
@samp{$+1,$-1} replaces a 5 on the stack with 4 followed by 6. Also,
|
|
@samp{$,$$} exchanges the top two elements of the stack, just like the
|
|
@key{TAB} key.
|
|
|
|
You can finish an algebraic entry with @kbd{M-=} or @kbd{M-@key{RET}} instead
|
|
of @key{RET}. This uses @kbd{=} to evaluate the variables in each
|
|
formula that goes onto the stack. (Thus @kbd{' pi @key{RET}} pushes
|
|
the variable @samp{pi}, but @kbd{' pi M-@key{RET}} pushes 3.1415.)
|
|
|
|
If you finish your algebraic entry by pressing @key{LFD} (or @kbd{C-j})
|
|
instead of @key{RET}, Calc disables the default simplifications
|
|
(as if by @kbd{m O}; @pxref{Simplification Modes}) while the entry
|
|
is being pushed on the stack. Thus @kbd{' 1+2 @key{RET}} pushes 3
|
|
on the stack, but @kbd{' 1+2 @key{LFD}} pushes the formula @expr{1+2};
|
|
you might then press @kbd{=} when it is time to evaluate this formula.
|
|
|
|
@node Quick Calculator, Prefix Arguments, Algebraic Entry, Introduction
|
|
@section ``Quick Calculator'' Mode
|
|
|
|
@noindent
|
|
@kindex C-x * q
|
|
@pindex quick-calc
|
|
@cindex Quick Calculator
|
|
There is another way to invoke the Calculator if all you need to do
|
|
is make one or two quick calculations. Type @kbd{C-x * q} (or
|
|
@kbd{M-x quick-calc}), then type any formula as an algebraic entry.
|
|
The Calculator will compute the result and display it in the echo
|
|
area, without ever actually putting up a Calc window.
|
|
|
|
You can use the @kbd{$} character in a Quick Calculator formula to
|
|
refer to the previous Quick Calculator result. Older results are
|
|
not retained; the Quick Calculator has no effect on the full
|
|
Calculator's stack or trail. If you compute a result and then
|
|
forget what it was, just run @code{C-x * q} again and enter
|
|
@samp{$} as the formula.
|
|
|
|
If this is the first time you have used the Calculator in this Emacs
|
|
session, the @kbd{C-x * q} command will create the @code{*Calculator*}
|
|
buffer and perform all the usual initializations; it simply will
|
|
refrain from putting that buffer up in a new window. The Quick
|
|
Calculator refers to the @code{*Calculator*} buffer for all mode
|
|
settings. Thus, for example, to set the precision that the Quick
|
|
Calculator uses, simply run the full Calculator momentarily and use
|
|
the regular @kbd{p} command.
|
|
|
|
If you use @code{C-x * q} from inside the Calculator buffer, the
|
|
effect is the same as pressing the apostrophe key (algebraic entry).
|
|
|
|
The result of a Quick calculation is placed in the Emacs ``kill ring''
|
|
as well as being displayed. A subsequent @kbd{C-y} command will
|
|
yank the result into the editing buffer. You can also use this
|
|
to yank the result into the next @kbd{C-x * q} input line as a more
|
|
explicit alternative to @kbd{$} notation, or to yank the result
|
|
into the Calculator stack after typing @kbd{C-x * c}.
|
|
|
|
If you finish your formula by typing @key{LFD} (or @kbd{C-j}) instead
|
|
of @key{RET}, the result is inserted immediately into the current
|
|
buffer rather than going into the kill ring.
|
|
|
|
Quick Calculator results are actually evaluated as if by the @kbd{=}
|
|
key (which replaces variable names by their stored values, if any).
|
|
If the formula you enter is an assignment to a variable using the
|
|
@samp{:=} operator, say, @samp{foo := 2 + 3} or @samp{foo := foo + 1},
|
|
then the result of the evaluation is stored in that Calc variable.
|
|
@xref{Store and Recall}.
|
|
|
|
If the result is an integer and the current display radix is decimal,
|
|
the number will also be displayed in hex and octal formats. If the
|
|
integer is in the range from 1 to 126, it will also be displayed as
|
|
an ASCII character.
|
|
|
|
For example, the quoted character @samp{"x"} produces the vector
|
|
result @samp{[120]} (because 120 is the ASCII code of the lower-case
|
|
`x'; @pxref{Strings}). Since this is a vector, not an integer, it
|
|
is displayed only according to the current mode settings. But
|
|
running Quick Calc again and entering @samp{120} will produce the
|
|
result @samp{120 (16#78, 8#170, x)} which shows the number in its
|
|
decimal, hexadecimal, octal, and ASCII forms.
|
|
|
|
Please note that the Quick Calculator is not any faster at loading
|
|
or computing the answer than the full Calculator; the name ``quick''
|
|
merely refers to the fact that it's much less hassle to use for
|
|
small calculations.
|
|
|
|
@node Prefix Arguments, Undo, Quick Calculator, Introduction
|
|
@section Numeric Prefix Arguments
|
|
|
|
@noindent
|
|
Many Calculator commands use numeric prefix arguments. Some, such as
|
|
@kbd{d s} (@code{calc-sci-notation}), set a parameter to the value of
|
|
the prefix argument or use a default if you don't use a prefix.
|
|
Others (like @kbd{d f} (@code{calc-fix-notation})) require an argument
|
|
and prompt for a number if you don't give one as a prefix.
|
|
|
|
As a rule, stack-manipulation commands accept a numeric prefix argument
|
|
which is interpreted as an index into the stack. A positive argument
|
|
operates on the top @var{n} stack entries; a negative argument operates
|
|
on the @var{n}th stack entry in isolation; and a zero argument operates
|
|
on the entire stack.
|
|
|
|
Most commands that perform computations (such as the arithmetic and
|
|
scientific functions) accept a numeric prefix argument that allows the
|
|
operation to be applied across many stack elements. For unary operations
|
|
(that is, functions of one argument like absolute value or complex
|
|
conjugate), a positive prefix argument applies that function to the top
|
|
@var{n} stack entries simultaneously, and a negative argument applies it
|
|
to the @var{n}th stack entry only. For binary operations (functions of
|
|
two arguments like addition, GCD, and vector concatenation), a positive
|
|
prefix argument ``reduces'' the function across the top @var{n}
|
|
stack elements (for example, @kbd{C-u 5 +} sums the top 5 stack entries;
|
|
@pxref{Reducing and Mapping}), and a negative argument maps the next-to-top
|
|
@var{n} stack elements with the top stack element as a second argument
|
|
(for example, @kbd{7 c-u -5 +} adds 7 to the top 5 stack elements).
|
|
This feature is not available for operations which use the numeric prefix
|
|
argument for some other purpose.
|
|
|
|
Numeric prefixes are specified the same way as always in Emacs: Press
|
|
a sequence of @key{META}-digits, or press @key{ESC} followed by digits,
|
|
or press @kbd{C-u} followed by digits. Some commands treat plain
|
|
@kbd{C-u} (without any actual digits) specially.
|
|
|
|
@kindex ~
|
|
@pindex calc-num-prefix
|
|
You can type @kbd{~} (@code{calc-num-prefix}) to pop an integer from the
|
|
top of the stack and enter it as the numeric prefix for the next command.
|
|
For example, @kbd{C-u 16 p} sets the precision to 16 digits; an alternate
|
|
(silly) way to do this would be @kbd{2 @key{RET} 4 ^ ~ p}, i.e., compute 2
|
|
to the fourth power and set the precision to that value.
|
|
|
|
Conversely, if you have typed a numeric prefix argument the @kbd{~} key
|
|
pushes it onto the stack in the form of an integer.
|
|
|
|
@node Undo, Error Messages, Prefix Arguments, Introduction
|
|
@section Undoing Mistakes
|
|
|
|
@noindent
|
|
@kindex U
|
|
@kindex C-_
|
|
@pindex calc-undo
|
|
@cindex Mistakes, undoing
|
|
@cindex Undoing mistakes
|
|
@cindex Errors, undoing
|
|
The shift-@kbd{U} key (@code{calc-undo}) undoes the most recent operation.
|
|
If that operation added or dropped objects from the stack, those objects
|
|
are removed or restored. If it was a ``store'' operation, you are
|
|
queried whether or not to restore the variable to its original value.
|
|
The @kbd{U} key may be pressed any number of times to undo successively
|
|
farther back in time; with a numeric prefix argument it undoes a
|
|
specified number of operations. The undo history is cleared only by the
|
|
@kbd{q} (@code{calc-quit}) command. (Recall that @kbd{C-x * c} is
|
|
synonymous with @code{calc-quit} while inside the Calculator; this
|
|
also clears the undo history.)
|
|
|
|
Currently the mode-setting commands (like @code{calc-precision}) are not
|
|
undoable. You can undo past a point where you changed a mode, but you
|
|
will need to reset the mode yourself.
|
|
|
|
@kindex D
|
|
@pindex calc-redo
|
|
@cindex Redoing after an Undo
|
|
The shift-@kbd{D} key (@code{calc-redo}) redoes an operation that was
|
|
mistakenly undone. Pressing @kbd{U} with a negative prefix argument is
|
|
equivalent to executing @code{calc-redo}. You can redo any number of
|
|
times, up to the number of recent consecutive undo commands. Redo
|
|
information is cleared whenever you give any command that adds new undo
|
|
information, i.e., if you undo, then enter a number on the stack or make
|
|
any other change, then it will be too late to redo.
|
|
|
|
@kindex M-@key{RET}
|
|
@pindex calc-last-args
|
|
@cindex Last-arguments feature
|
|
@cindex Arguments, restoring
|
|
The @kbd{M-@key{RET}} key (@code{calc-last-args}) is like undo in that
|
|
it restores the arguments of the most recent command onto the stack;
|
|
however, it does not remove the result of that command. Given a numeric
|
|
prefix argument, this command applies to the @expr{n}th most recent
|
|
command which removed items from the stack; it pushes those items back
|
|
onto the stack.
|
|
|
|
The @kbd{K} (@code{calc-keep-args}) command provides a related function
|
|
to @kbd{M-@key{RET}}. @xref{Stack and Trail}.
|
|
|
|
It is also possible to recall previous results or inputs using the trail.
|
|
@xref{Trail Commands}.
|
|
|
|
The standard Emacs @kbd{C-_} undo key is recognized as a synonym for @kbd{U}.
|
|
|
|
@node Error Messages, Multiple Calculators, Undo, Introduction
|
|
@section Error Messages
|
|
|
|
@noindent
|
|
@kindex w
|
|
@pindex calc-why
|
|
@cindex Errors, messages
|
|
@cindex Why did an error occur?
|
|
Many situations that would produce an error message in other calculators
|
|
simply create unsimplified formulas in the Emacs Calculator. For example,
|
|
@kbd{1 @key{RET} 0 /} pushes the formula @expr{1 / 0}; @w{@kbd{0 L}} pushes
|
|
the formula @samp{ln(0)}. Floating-point overflow and underflow are also
|
|
reasons for this to happen.
|
|
|
|
When a function call must be left in symbolic form, Calc usually
|
|
produces a message explaining why. Messages that are probably
|
|
surprising or indicative of user errors are displayed automatically.
|
|
Other messages are simply kept in Calc's memory and are displayed only
|
|
if you type @kbd{w} (@code{calc-why}). You can also press @kbd{w} if
|
|
the same computation results in several messages. (The first message
|
|
will end with @samp{[w=more]} in this case.)
|
|
|
|
@kindex d w
|
|
@pindex calc-auto-why
|
|
The @kbd{d w} (@code{calc-auto-why}) command controls when error messages
|
|
are displayed automatically. (Calc effectively presses @kbd{w} for you
|
|
after your computation finishes.) By default, this occurs only for
|
|
``important'' messages. The other possible modes are to report
|
|
@emph{all} messages automatically, or to report none automatically (so
|
|
that you must always press @kbd{w} yourself to see the messages).
|
|
|
|
@node Multiple Calculators, Troubleshooting Commands, Error Messages, Introduction
|
|
@section Multiple Calculators
|
|
|
|
@noindent
|
|
@pindex another-calc
|
|
It is possible to have any number of Calc mode buffers at once.
|
|
Usually this is done by executing @kbd{M-x another-calc}, which
|
|
is similar to @kbd{C-x * c} except that if a @samp{*Calculator*}
|
|
buffer already exists, a new, independent one with a name of the
|
|
form @samp{*Calculator*<@var{n}>} is created. You can also use the
|
|
command @code{calc-mode} to put any buffer into Calculator mode, but
|
|
this would ordinarily never be done.
|
|
|
|
The @kbd{q} (@code{calc-quit}) command does not destroy a Calculator buffer;
|
|
it only closes its window. Use @kbd{M-x kill-buffer} to destroy a
|
|
Calculator buffer.
|
|
|
|
Each Calculator buffer keeps its own stack, undo list, and mode settings
|
|
such as precision, angular mode, and display formats. In Emacs terms,
|
|
variables such as @code{calc-stack} are buffer-local variables. The
|
|
global default values of these variables are used only when a new
|
|
Calculator buffer is created. The @code{calc-quit} command saves
|
|
the stack and mode settings of the buffer being quit as the new defaults.
|
|
|
|
There is only one trail buffer, @samp{*Calc Trail*}, used by all
|
|
Calculator buffers.
|
|
|
|
@node Troubleshooting Commands, , Multiple Calculators, Introduction
|
|
@section Troubleshooting Commands
|
|
|
|
@noindent
|
|
This section describes commands you can use in case a computation
|
|
incorrectly fails or gives the wrong answer.
|
|
|
|
@xref{Reporting Bugs}, if you find a problem that appears to be due
|
|
to a bug or deficiency in Calc.
|
|
|
|
@menu
|
|
* Autoloading Problems::
|
|
* Recursion Depth::
|
|
* Caches::
|
|
* Debugging Calc::
|
|
@end menu
|
|
|
|
@node Autoloading Problems, Recursion Depth, Troubleshooting Commands, Troubleshooting Commands
|
|
@subsection Autoloading Problems
|
|
|
|
@noindent
|
|
The Calc program is split into many component files; components are
|
|
loaded automatically as you use various commands that require them.
|
|
Occasionally Calc may lose track of when a certain component is
|
|
necessary; typically this means you will type a command and it won't
|
|
work because some function you've never heard of was undefined.
|
|
|
|
@kindex C-x * L
|
|
@pindex calc-load-everything
|
|
If this happens, the easiest workaround is to type @kbd{C-x * L}
|
|
(@code{calc-load-everything}) to force all the parts of Calc to be
|
|
loaded right away. This will cause Emacs to take up a lot more
|
|
memory than it would otherwise, but it's guaranteed to fix the problem.
|
|
|
|
@node Recursion Depth, Caches, Autoloading Problems, Troubleshooting Commands
|
|
@subsection Recursion Depth
|
|
|
|
@noindent
|
|
@kindex M
|
|
@kindex I M
|
|
@pindex calc-more-recursion-depth
|
|
@pindex calc-less-recursion-depth
|
|
@cindex Recursion depth
|
|
@cindex ``Computation got stuck'' message
|
|
@cindex @code{max-lisp-eval-depth}
|
|
@cindex @code{max-specpdl-size}
|
|
Calc uses recursion in many of its calculations. Emacs Lisp keeps a
|
|
variable @code{max-lisp-eval-depth} which limits the amount of recursion
|
|
possible in an attempt to recover from program bugs. If a calculation
|
|
ever halts incorrectly with the message ``Computation got stuck or
|
|
ran too long,'' use the @kbd{M} command (@code{calc-more-recursion-depth})
|
|
to increase this limit. (Of course, this will not help if the
|
|
calculation really did get stuck due to some problem inside Calc.)
|
|
|
|
The limit is always increased (multiplied) by a factor of two. There
|
|
is also an @kbd{I M} (@code{calc-less-recursion-depth}) command which
|
|
decreases this limit by a factor of two, down to a minimum value of 200.
|
|
The default value is 1000.
|
|
|
|
These commands also double or halve @code{max-specpdl-size}, another
|
|
internal Lisp recursion limit. The minimum value for this limit is 600.
|
|
|
|
@node Caches, Debugging Calc, Recursion Depth, Troubleshooting Commands
|
|
@subsection Caches
|
|
|
|
@noindent
|
|
@cindex Caches
|
|
@cindex Flushing caches
|
|
Calc saves certain values after they have been computed once. For
|
|
example, the @kbd{P} (@code{calc-pi}) command initially ``knows'' the
|
|
constant @cpi{} to about 20 decimal places; if the current precision
|
|
is greater than this, it will recompute @cpi{} using a series
|
|
approximation. This value will not need to be recomputed ever again
|
|
unless you raise the precision still further. Many operations such as
|
|
logarithms and sines make use of similarly cached values such as
|
|
@cpiover{4} and
|
|
@texline @math{\ln 2}.
|
|
@infoline @expr{ln(2)}.
|
|
The visible effect of caching is that
|
|
high-precision computations may seem to do extra work the first time.
|
|
Other things cached include powers of two (for the binary arithmetic
|
|
functions), matrix inverses and determinants, symbolic integrals, and
|
|
data points computed by the graphing commands.
|
|
|
|
@pindex calc-flush-caches
|
|
If you suspect a Calculator cache has become corrupt, you can use the
|
|
@code{calc-flush-caches} command to reset all caches to the empty state.
|
|
(This should only be necessary in the event of bugs in the Calculator.)
|
|
The @kbd{C-x * 0} (with the zero key) command also resets caches along
|
|
with all other aspects of the Calculator's state.
|
|
|
|
@node Debugging Calc, , Caches, Troubleshooting Commands
|
|
@subsection Debugging Calc
|
|
|
|
@noindent
|
|
A few commands exist to help in the debugging of Calc commands.
|
|
@xref{Programming}, to see the various ways that you can write
|
|
your own Calc commands.
|
|
|
|
@kindex Z T
|
|
@pindex calc-timing
|
|
The @kbd{Z T} (@code{calc-timing}) command turns on and off a mode
|
|
in which the timing of slow commands is reported in the Trail.
|
|
Any Calc command that takes two seconds or longer writes a line
|
|
to the Trail showing how many seconds it took. This value is
|
|
accurate only to within one second.
|
|
|
|
All steps of executing a command are included; in particular, time
|
|
taken to format the result for display in the stack and trail is
|
|
counted. Some prompts also count time taken waiting for them to
|
|
be answered, while others do not; this depends on the exact
|
|
implementation of the command. For best results, if you are timing
|
|
a sequence that includes prompts or multiple commands, define a
|
|
keyboard macro to run the whole sequence at once. Calc's @kbd{X}
|
|
command (@pxref{Keyboard Macros}) will then report the time taken
|
|
to execute the whole macro.
|
|
|
|
Another advantage of the @kbd{X} command is that while it is
|
|
executing, the stack and trail are not updated from step to step.
|
|
So if you expect the output of your test sequence to leave a result
|
|
that may take a long time to format and you don't wish to count
|
|
this formatting time, end your sequence with a @key{DEL} keystroke
|
|
to clear the result from the stack. When you run the sequence with
|
|
@kbd{X}, Calc will never bother to format the large result.
|
|
|
|
Another thing @kbd{Z T} does is to increase the Emacs variable
|
|
@code{gc-cons-threshold} to a much higher value (two million; the
|
|
usual default in Calc is 250,000) for the duration of each command.
|
|
This generally prevents garbage collection during the timing of
|
|
the command, though it may cause your Emacs process to grow
|
|
abnormally large. (Garbage collection time is a major unpredictable
|
|
factor in the timing of Emacs operations.)
|
|
|
|
Another command that is useful when debugging your own Lisp
|
|
extensions to Calc is @kbd{M-x calc-pass-errors}, which disables
|
|
the error handler that changes the ``@code{max-lisp-eval-depth}
|
|
exceeded'' message to the much more friendly ``Computation got
|
|
stuck or ran too long.'' This handler interferes with the Emacs
|
|
Lisp debugger's @code{debug-on-error} mode. Errors are reported
|
|
in the handler itself rather than at the true location of the
|
|
error. After you have executed @code{calc-pass-errors}, Lisp
|
|
errors will be reported correctly but the user-friendly message
|
|
will be lost.
|
|
|
|
@node Data Types, Stack and Trail, Introduction, Top
|
|
@chapter Data Types
|
|
|
|
@noindent
|
|
This chapter discusses the various types of objects that can be placed
|
|
on the Calculator stack, how they are displayed, and how they are
|
|
entered. (@xref{Data Type Formats}, for information on how these data
|
|
types are represented as underlying Lisp objects.)
|
|
|
|
Integers, fractions, and floats are various ways of describing real
|
|
numbers. HMS forms also for many purposes act as real numbers. These
|
|
types can be combined to form complex numbers, modulo forms, error forms,
|
|
or interval forms. (But these last four types cannot be combined
|
|
arbitrarily:@: error forms may not contain modulo forms, for example.)
|
|
Finally, all these types of numbers may be combined into vectors,
|
|
matrices, or algebraic formulas.
|
|
|
|
@menu
|
|
* Integers:: The most basic data type.
|
|
* Fractions:: This and above are called @dfn{rationals}.
|
|
* Floats:: This and above are called @dfn{reals}.
|
|
* Complex Numbers:: This and above are called @dfn{numbers}.
|
|
* Infinities::
|
|
* Vectors and Matrices::
|
|
* Strings::
|
|
* HMS Forms::
|
|
* Date Forms::
|
|
* Modulo Forms::
|
|
* Error Forms::
|
|
* Interval Forms::
|
|
* Incomplete Objects::
|
|
* Variables::
|
|
* Formulas::
|
|
@end menu
|
|
|
|
@node Integers, Fractions, Data Types, Data Types
|
|
@section Integers
|
|
|
|
@noindent
|
|
@cindex Integers
|
|
The Calculator stores integers to arbitrary precision. Addition,
|
|
subtraction, and multiplication of integers always yields an exact
|
|
integer result. (If the result of a division or exponentiation of
|
|
integers is not an integer, it is expressed in fractional or
|
|
floating-point form according to the current Fraction mode.
|
|
@xref{Fraction Mode}.)
|
|
|
|
A decimal integer is represented as an optional sign followed by a
|
|
sequence of digits. Grouping (@pxref{Grouping Digits}) can be used to
|
|
insert a comma at every third digit for display purposes, but you
|
|
must not type commas during the entry of numbers.
|
|
|
|
@kindex #
|
|
A non-decimal integer is represented as an optional sign, a radix
|
|
between 2 and 36, a @samp{#} symbol, and one or more digits. For radix 11
|
|
and above, the letters A through Z (upper- or lower-case) count as
|
|
digits and do not terminate numeric entry mode. @xref{Radix Modes}, for how
|
|
to set the default radix for display of integers. Numbers of any radix
|
|
may be entered at any time. If you press @kbd{#} at the beginning of a
|
|
number, the current display radix is used.
|
|
|
|
@node Fractions, Floats, Integers, Data Types
|
|
@section Fractions
|
|
|
|
@noindent
|
|
@cindex Fractions
|
|
A @dfn{fraction} is a ratio of two integers. Fractions are traditionally
|
|
written ``2/3'' but Calc uses the notation @samp{2:3}. (The @kbd{/} key
|
|
performs RPN division; the following two sequences push the number
|
|
@samp{2:3} on the stack: @kbd{2 :@: 3 @key{RET}}, or @kbd{2 @key{RET} 3 /}
|
|
assuming Fraction mode has been enabled.)
|
|
When the Calculator produces a fractional result it always reduces it to
|
|
simplest form, which may in fact be an integer.
|
|
|
|
Fractions may also be entered in a three-part form, where @samp{2:3:4}
|
|
represents two-and-three-quarters. @xref{Fraction Formats}, for fraction
|
|
display formats.
|
|
|
|
Non-decimal fractions are entered and displayed as
|
|
@samp{@var{radix}#@var{num}:@var{denom}} (or in the analogous three-part
|
|
form). The numerator and denominator always use the same radix.
|
|
|
|
@node Floats, Complex Numbers, Fractions, Data Types
|
|
@section Floats
|
|
|
|
@noindent
|
|
@cindex Floating-point numbers
|
|
A floating-point number or @dfn{float} is a number stored in scientific
|
|
notation. The number of significant digits in the fractional part is
|
|
governed by the current floating precision (@pxref{Precision}). The
|
|
range of acceptable values is from
|
|
@texline @math{10^{-3999999}}
|
|
@infoline @expr{10^-3999999}
|
|
(inclusive) to
|
|
@texline @math{10^{4000000}}
|
|
@infoline @expr{10^4000000}
|
|
(exclusive), plus the corresponding negative values and zero.
|
|
|
|
Calculations that would exceed the allowable range of values (such
|
|
as @samp{exp(exp(20))}) are left in symbolic form by Calc. The
|
|
messages ``floating-point overflow'' or ``floating-point underflow''
|
|
indicate that during the calculation a number would have been produced
|
|
that was too large or too close to zero, respectively, to be represented
|
|
by Calc. This does not necessarily mean the final result would have
|
|
overflowed, just that an overflow occurred while computing the result.
|
|
(In fact, it could report an underflow even though the final result
|
|
would have overflowed!)
|
|
|
|
If a rational number and a float are mixed in a calculation, the result
|
|
will in general be expressed as a float. Commands that require an integer
|
|
value (such as @kbd{k g} [@code{gcd}]) will also accept integer-valued
|
|
floats, i.e., floating-point numbers with nothing after the decimal point.
|
|
|
|
Floats are identified by the presence of a decimal point and/or an
|
|
exponent. In general a float consists of an optional sign, digits
|
|
including an optional decimal point, and an optional exponent consisting
|
|
of an @samp{e}, an optional sign, and up to seven exponent digits.
|
|
For example, @samp{23.5e-2} is 23.5 times ten to the minus-second power,
|
|
or 0.235.
|
|
|
|
Floating-point numbers are normally displayed in decimal notation with
|
|
all significant figures shown. Exceedingly large or small numbers are
|
|
displayed in scientific notation. Various other display options are
|
|
available. @xref{Float Formats}.
|
|
|
|
@cindex Accuracy of calculations
|
|
Floating-point numbers are stored in decimal, not binary. The result
|
|
of each operation is rounded to the nearest value representable in the
|
|
number of significant digits specified by the current precision,
|
|
rounding away from zero in the case of a tie. Thus (in the default
|
|
display mode) what you see is exactly what you get. Some operations such
|
|
as square roots and transcendental functions are performed with several
|
|
digits of extra precision and then rounded down, in an effort to make the
|
|
final result accurate to the full requested precision. However,
|
|
accuracy is not rigorously guaranteed. If you suspect the validity of a
|
|
result, try doing the same calculation in a higher precision. The
|
|
Calculator's arithmetic is not intended to be IEEE-conformant in any
|
|
way.
|
|
|
|
While floats are always @emph{stored} in decimal, they can be entered
|
|
and displayed in any radix just like integers and fractions. The
|
|
notation @samp{@var{radix}#@var{ddd}.@var{ddd}} is a floating-point
|
|
number whose digits are in the specified radix. Note that the @samp{.}
|
|
is more aptly referred to as a ``radix point'' than as a decimal
|
|
point in this case. The number @samp{8#123.4567} is defined as
|
|
@samp{8#1234567 * 8^-4}. If the radix is 14 or less, you can use
|
|
@samp{e} notation to write a non-decimal number in scientific notation.
|
|
The exponent is written in decimal, and is considered to be a power
|
|
of the radix: @samp{8#1234567e-4}. If the radix is 15 or above, the
|
|
letter @samp{e} is a digit, so scientific notation must be written
|
|
out, e.g., @samp{16#123.4567*16^2}. The first two exercises of the
|
|
Modes Tutorial explore some of the properties of non-decimal floats.
|
|
|
|
@node Complex Numbers, Infinities, Floats, Data Types
|
|
@section Complex Numbers
|
|
|
|
@noindent
|
|
@cindex Complex numbers
|
|
There are two supported formats for complex numbers: rectangular and
|
|
polar. The default format is rectangular, displayed in the form
|
|
@samp{(@var{real},@var{imag})} where @var{real} is the real part and
|
|
@var{imag} is the imaginary part, each of which may be any real number.
|
|
Rectangular complex numbers can also be displayed in @samp{@var{a}+@var{b}i}
|
|
notation; @pxref{Complex Formats}.
|
|
|
|
Polar complex numbers are displayed in the form
|
|
@texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'
|
|
@infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'
|
|
where @var{r} is the nonnegative magnitude and
|
|
@texline @math{\theta}
|
|
@infoline @var{theta}
|
|
is the argument or phase angle. The range of
|
|
@texline @math{\theta}
|
|
@infoline @var{theta}
|
|
depends on the current angular mode (@pxref{Angular Modes}); it is
|
|
generally between @mathit{-180} and @mathit{+180} degrees or the equivalent range
|
|
in radians.
|
|
|
|
Complex numbers are entered in stages using incomplete objects.
|
|
@xref{Incomplete Objects}.
|
|
|
|
Operations on rectangular complex numbers yield rectangular complex
|
|
results, and similarly for polar complex numbers. Where the two types
|
|
are mixed, or where new complex numbers arise (as for the square root of
|
|
a negative real), the current @dfn{Polar mode} is used to determine the
|
|
type. @xref{Polar Mode}.
|
|
|
|
A complex result in which the imaginary part is zero (or the phase angle
|
|
is 0 or 180 degrees or @cpi{} radians) is automatically converted to a real
|
|
number.
|
|
|
|
@node Infinities, Vectors and Matrices, Complex Numbers, Data Types
|
|
@section Infinities
|
|
|
|
@noindent
|
|
@cindex Infinity
|
|
@cindex @code{inf} variable
|
|
@cindex @code{uinf} variable
|
|
@cindex @code{nan} variable
|
|
@vindex inf
|
|
@vindex uinf
|
|
@vindex nan
|
|
The word @code{inf} represents the mathematical concept of @dfn{infinity}.
|
|
Calc actually has three slightly different infinity-like values:
|
|
@code{inf}, @code{uinf}, and @code{nan}. These are just regular
|
|
variable names (@pxref{Variables}); you should avoid using these
|
|
names for your own variables because Calc gives them special
|
|
treatment. Infinities, like all variable names, are normally
|
|
entered using algebraic entry.
|
|
|
|
Mathematically speaking, it is not rigorously correct to treat
|
|
``infinity'' as if it were a number, but mathematicians often do
|
|
so informally. When they say that @samp{1 / inf = 0}, what they
|
|
really mean is that @expr{1 / x}, as @expr{x} becomes larger and
|
|
larger, becomes arbitrarily close to zero. So you can imagine
|
|
that if @expr{x} got ``all the way to infinity,'' then @expr{1 / x}
|
|
would go all the way to zero. Similarly, when they say that
|
|
@samp{exp(inf) = inf}, they mean that
|
|
@texline @math{e^x}
|
|
@infoline @expr{exp(x)}
|
|
grows without bound as @expr{x} grows. The symbol @samp{-inf} likewise
|
|
stands for an infinitely negative real value; for example, we say that
|
|
@samp{exp(-inf) = 0}. You can have an infinity pointing in any
|
|
direction on the complex plane: @samp{sqrt(-inf) = i inf}.
|
|
|
|
The same concept of limits can be used to define @expr{1 / 0}. We
|
|
really want the value that @expr{1 / x} approaches as @expr{x}
|
|
approaches zero. But if all we have is @expr{1 / 0}, we can't
|
|
tell which direction @expr{x} was coming from. If @expr{x} was
|
|
positive and decreasing toward zero, then we should say that
|
|
@samp{1 / 0 = inf}. But if @expr{x} was negative and increasing
|
|
toward zero, the answer is @samp{1 / 0 = -inf}. In fact, @expr{x}
|
|
could be an imaginary number, giving the answer @samp{i inf} or
|
|
@samp{-i inf}. Calc uses the special symbol @samp{uinf} to mean
|
|
@dfn{undirected infinity}, i.e., a value which is infinitely
|
|
large but with an unknown sign (or direction on the complex plane).
|
|
|
|
Calc actually has three modes that say how infinities are handled.
|
|
Normally, infinities never arise from calculations that didn't
|
|
already have them. Thus, @expr{1 / 0} is treated simply as an
|
|
error and left unevaluated. The @kbd{m i} (@code{calc-infinite-mode})
|
|
command (@pxref{Infinite Mode}) enables a mode in which
|
|
@expr{1 / 0} evaluates to @code{uinf} instead. There is also
|
|
an alternative type of infinite mode which says to treat zeros
|
|
as if they were positive, so that @samp{1 / 0 = inf}. While this
|
|
is less mathematically correct, it may be the answer you want in
|
|
some cases.
|
|
|
|
Since all infinities are ``as large'' as all others, Calc simplifies,
|
|
e.g., @samp{5 inf} to @samp{inf}. Another example is
|
|
@samp{5 - inf = -inf}, where the @samp{-inf} is so large that
|
|
adding a finite number like five to it does not affect it.
|
|
Note that @samp{a - inf} also results in @samp{-inf}; Calc assumes
|
|
that variables like @code{a} always stand for finite quantities.
|
|
Just to show that infinities really are all the same size,
|
|
note that @samp{sqrt(inf) = inf^2 = exp(inf) = inf} in Calc's
|
|
notation.
|
|
|
|
It's not so easy to define certain formulas like @samp{0 * inf} and
|
|
@samp{inf / inf}. Depending on where these zeros and infinities
|
|
came from, the answer could be literally anything. The latter
|
|
formula could be the limit of @expr{x / x} (giving a result of one),
|
|
or @expr{2 x / x} (giving two), or @expr{x^2 / x} (giving @code{inf}),
|
|
or @expr{x / x^2} (giving zero). Calc uses the symbol @code{nan}
|
|
to represent such an @dfn{indeterminate} value. (The name ``nan''
|
|
comes from analogy with the ``NAN'' concept of IEEE standard
|
|
arithmetic; it stands for ``Not A Number.'' This is somewhat of a
|
|
misnomer, since @code{nan} @emph{does} stand for some number or
|
|
infinity, it's just that @emph{which} number it stands for
|
|
cannot be determined.) In Calc's notation, @samp{0 * inf = nan}
|
|
and @samp{inf / inf = nan}. A few other common indeterminate
|
|
expressions are @samp{inf - inf} and @samp{inf ^ 0}. Also,
|
|
@samp{0 / 0 = nan} if you have turned on Infinite mode
|
|
(as described above).
|
|
|
|
Infinities are especially useful as parts of @dfn{intervals}.
|
|
@xref{Interval Forms}.
|
|
|
|
@node Vectors and Matrices, Strings, Infinities, Data Types
|
|
@section Vectors and Matrices
|
|
|
|
@noindent
|
|
@cindex Vectors
|
|
@cindex Plain vectors
|
|
@cindex Matrices
|
|
The @dfn{vector} data type is flexible and general. A vector is simply a
|
|
list of zero or more data objects. When these objects are numbers, the
|
|
whole is a vector in the mathematical sense. When these objects are
|
|
themselves vectors of equal (nonzero) length, the whole is a @dfn{matrix}.
|
|
A vector which is not a matrix is referred to here as a @dfn{plain vector}.
|
|
|
|
A vector is displayed as a list of values separated by commas and enclosed
|
|
in square brackets: @samp{[1, 2, 3]}. Thus the following is a 2 row by
|
|
3 column matrix: @samp{[[1, 2, 3], [4, 5, 6]]}. Vectors, like complex
|
|
numbers, are entered as incomplete objects. @xref{Incomplete Objects}.
|
|
During algebraic entry, vectors are entered all at once in the usual
|
|
brackets-and-commas form. Matrices may be entered algebraically as nested
|
|
vectors, or using the shortcut notation @w{@samp{[1, 2, 3; 4, 5, 6]}},
|
|
with rows separated by semicolons. The commas may usually be omitted
|
|
when entering vectors: @samp{[1 2 3]}. Curly braces may be used in
|
|
place of brackets: @samp{@{1, 2, 3@}}, but the commas are required in
|
|
this case.
|
|
|
|
Traditional vector and matrix arithmetic is also supported;
|
|
@pxref{Basic Arithmetic} and @pxref{Matrix Functions}.
|
|
Many other operations are applied to vectors element-wise. For example,
|
|
the complex conjugate of a vector is a vector of the complex conjugates
|
|
of its elements.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex vec
|
|
Algebraic functions for building vectors include @samp{vec(a, b, c)}
|
|
to build @samp{[a, b, c]}, @samp{cvec(a, n, m)} to build an
|
|
@texline @math{n\times m}
|
|
@infoline @var{n}x@var{m}
|
|
matrix of @samp{a}s, and @samp{index(n)} to build a vector of integers
|
|
from 1 to @samp{n}.
|
|
|
|
@node Strings, HMS Forms, Vectors and Matrices, Data Types
|
|
@section Strings
|
|
|
|
@noindent
|
|
@kindex "
|
|
@cindex Strings
|
|
@cindex Character strings
|
|
Character strings are not a special data type in the Calculator.
|
|
Rather, a string is represented simply as a vector all of whose
|
|
elements are integers in the range 0 to 255 (ASCII codes). You can
|
|
enter a string at any time by pressing the @kbd{"} key. Quotation
|
|
marks and backslashes are written @samp{\"} and @samp{\\}, respectively,
|
|
inside strings. Other notations introduced by backslashes are:
|
|
|
|
@example
|
|
@group
|
|
\a 7 \^@@ 0
|
|
\b 8 \^a-z 1-26
|
|
\e 27 \^[ 27
|
|
\f 12 \^\\ 28
|
|
\n 10 \^] 29
|
|
\r 13 \^^ 30
|
|
\t 9 \^_ 31
|
|
\^? 127
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
Finally, a backslash followed by three octal digits produces any
|
|
character from its ASCII code.
|
|
|
|
@kindex d "
|
|
@pindex calc-display-strings
|
|
Strings are normally displayed in vector-of-integers form. The
|
|
@w{@kbd{d "}} (@code{calc-display-strings}) command toggles a mode in
|
|
which any vectors of small integers are displayed as quoted strings
|
|
instead.
|
|
|
|
The backslash notations shown above are also used for displaying
|
|
strings. Characters 128 and above are not translated by Calc; unless
|
|
you have an Emacs modified for 8-bit fonts, these will show up in
|
|
backslash-octal-digits notation. For characters below 32, and
|
|
for character 127, Calc uses the backslash-letter combination if
|
|
there is one, or otherwise uses a @samp{\^} sequence.
|
|
|
|
The only Calc feature that uses strings is @dfn{compositions};
|
|
@pxref{Compositions}. Strings also provide a convenient
|
|
way to do conversions between ASCII characters and integers.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex string
|
|
There is a @code{string} function which provides a different display
|
|
format for strings. Basically, @samp{string(@var{s})}, where @var{s}
|
|
is a vector of integers in the proper range, is displayed as the
|
|
corresponding string of characters with no surrounding quotation
|
|
marks or other modifications. Thus @samp{string("ABC")} (or
|
|
@samp{string([65 66 67])}) will look like @samp{ABC} on the stack.
|
|
This happens regardless of whether @w{@kbd{d "}} has been used. The
|
|
only way to turn it off is to use @kbd{d U} (unformatted language
|
|
mode) which will display @samp{string("ABC")} instead.
|
|
|
|
Control characters are displayed somewhat differently by @code{string}.
|
|
Characters below 32, and character 127, are shown using @samp{^} notation
|
|
(same as shown above, but without the backslash). The quote and
|
|
backslash characters are left alone, as are characters 128 and above.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex bstring
|
|
The @code{bstring} function is just like @code{string} except that
|
|
the resulting string is breakable across multiple lines if it doesn't
|
|
fit all on one line. Potential break points occur at every space
|
|
character in the string.
|
|
|
|
@node HMS Forms, Date Forms, Strings, Data Types
|
|
@section HMS Forms
|
|
|
|
@noindent
|
|
@cindex Hours-minutes-seconds forms
|
|
@cindex Degrees-minutes-seconds forms
|
|
@dfn{HMS} stands for Hours-Minutes-Seconds; when used as an angular
|
|
argument, the interpretation is Degrees-Minutes-Seconds. All functions
|
|
that operate on angles accept HMS forms. These are interpreted as
|
|
degrees regardless of the current angular mode. It is also possible to
|
|
use HMS as the angular mode so that calculated angles are expressed in
|
|
degrees, minutes, and seconds.
|
|
|
|
@kindex @@
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex ' (HMS forms)
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex " (HMS forms)
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex h (HMS forms)
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex o (HMS forms)
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex m (HMS forms)
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s (HMS forms)
|
|
The default format for HMS values is
|
|
@samp{@var{hours}@@ @var{mins}' @var{secs}"}. During entry, the letters
|
|
@samp{h} (for ``hours'') or
|
|
@samp{o} (approximating the ``degrees'' symbol) are accepted as well as
|
|
@samp{@@}, @samp{m} is accepted in place of @samp{'}, and @samp{s} is
|
|
accepted in place of @samp{"}.
|
|
The @var{hours} value is an integer (or integer-valued float).
|
|
The @var{mins} value is an integer or integer-valued float between 0 and 59.
|
|
The @var{secs} value is a real number between 0 (inclusive) and 60
|
|
(exclusive). A positive HMS form is interpreted as @var{hours} +
|
|
@var{mins}/60 + @var{secs}/3600. A negative HMS form is interpreted
|
|
as @mathit{- @var{hours}} @mathit{-} @var{mins}/60 @mathit{-} @var{secs}/3600.
|
|
Display format for HMS forms is quite flexible. @xref{HMS Formats}.
|
|
|
|
HMS forms can be added and subtracted. When they are added to numbers,
|
|
the numbers are interpreted according to the current angular mode. HMS
|
|
forms can also be multiplied and divided by real numbers. Dividing
|
|
two HMS forms produces a real-valued ratio of the two angles.
|
|
|
|
@pindex calc-time
|
|
@cindex Time of day
|
|
Just for kicks, @kbd{M-x calc-time} pushes the current time of day on
|
|
the stack as an HMS form.
|
|
|
|
@node Date Forms, Modulo Forms, HMS Forms, Data Types
|
|
@section Date Forms
|
|
|
|
@noindent
|
|
@cindex Date forms
|
|
A @dfn{date form} represents a date and possibly an associated time.
|
|
Simple date arithmetic is supported: Adding a number to a date
|
|
produces a new date shifted by that many days; adding an HMS form to
|
|
a date shifts it by that many hours. Subtracting two date forms
|
|
computes the number of days between them (represented as a simple
|
|
number). Many other operations, such as multiplying two date forms,
|
|
are nonsensical and are not allowed by Calc.
|
|
|
|
Date forms are entered and displayed enclosed in @samp{< >} brackets.
|
|
The default format is, e.g., @samp{<Wed Jan 9, 1991>} for dates,
|
|
or @samp{<3:32:20pm Wed Jan 9, 1991>} for dates with times.
|
|
Input is flexible; date forms can be entered in any of the usual
|
|
notations for dates and times. @xref{Date Formats}.
|
|
|
|
Date forms are stored internally as numbers, specifically the number
|
|
of days since midnight on the morning of January 1 of the year 1 AD.
|
|
If the internal number is an integer, the form represents a date only;
|
|
if the internal number is a fraction or float, the form represents
|
|
a date and time. For example, @samp{<6:00am Wed Jan 9, 1991>}
|
|
is represented by the number 726842.25. The standard precision of
|
|
12 decimal digits is enough to ensure that a (reasonable) date and
|
|
time can be stored without roundoff error.
|
|
|
|
If the current precision is greater than 12, date forms will keep
|
|
additional digits in the seconds position. For example, if the
|
|
precision is 15, the seconds will keep three digits after the
|
|
decimal point. Decreasing the precision below 12 may cause the
|
|
time part of a date form to become inaccurate. This can also happen
|
|
if astronomically high years are used, though this will not be an
|
|
issue in everyday (or even everymillennium) use. Note that date
|
|
forms without times are stored as exact integers, so roundoff is
|
|
never an issue for them.
|
|
|
|
You can use the @kbd{v p} (@code{calc-pack}) and @kbd{v u}
|
|
(@code{calc-unpack}) commands to get at the numerical representation
|
|
of a date form. @xref{Packing and Unpacking}.
|
|
|
|
Date forms can go arbitrarily far into the future or past. Negative
|
|
year numbers represent years BC. Calc uses a combination of the
|
|
Gregorian and Julian calendars, following the history of Great
|
|
Britain and the British colonies. This is the same calendar that
|
|
is used by the @code{cal} program in most Unix implementations.
|
|
|
|
@cindex Julian calendar
|
|
@cindex Gregorian calendar
|
|
Some historical background: The Julian calendar was created by
|
|
Julius Caesar in the year 46 BC as an attempt to fix the gradual
|
|
drift caused by the lack of leap years in the calendar used
|
|
until that time. The Julian calendar introduced an extra day in
|
|
all years divisible by four. After some initial confusion, the
|
|
calendar was adopted around the year we call 8 AD. Some centuries
|
|
later it became apparent that the Julian year of 365.25 days was
|
|
itself not quite right. In 1582 Pope Gregory XIII introduced the
|
|
Gregorian calendar, which added the new rule that years divisible
|
|
by 100, but not by 400, were not to be considered leap years
|
|
despite being divisible by four. Many countries delayed adoption
|
|
of the Gregorian calendar because of religious differences;
|
|
in Britain it was put off until the year 1752, by which time
|
|
the Julian calendar had fallen eleven days behind the true
|
|
seasons. So the switch to the Gregorian calendar in early
|
|
September 1752 introduced a discontinuity: The day after
|
|
Sep 2, 1752 is Sep 14, 1752. Calc follows this convention.
|
|
To take another example, Russia waited until 1918 before
|
|
adopting the new calendar, and thus needed to remove thirteen
|
|
days (between Feb 1, 1918 and Feb 14, 1918). This means that
|
|
Calc's reckoning will be inconsistent with Russian history between
|
|
1752 and 1918, and similarly for various other countries.
|
|
|
|
Today's timekeepers introduce an occasional ``leap second'' as
|
|
well, but Calc does not take these minor effects into account.
|
|
(If it did, it would have to report a non-integer number of days
|
|
between, say, @samp{<12:00am Mon Jan 1, 1900>} and
|
|
@samp{<12:00am Sat Jan 1, 2000>}.)
|
|
|
|
Calc uses the Julian calendar for all dates before the year 1752,
|
|
including dates BC when the Julian calendar technically had not
|
|
yet been invented. Thus the claim that day number @mathit{-10000} is
|
|
called ``August 16, 28 BC'' should be taken with a grain of salt.
|
|
|
|
Please note that there is no ``year 0''; the day before
|
|
@samp{<Sat Jan 1, +1>} is @samp{<Fri Dec 31, -1>}. These are
|
|
days 0 and @mathit{-1} respectively in Calc's internal numbering scheme.
|
|
|
|
@cindex Julian day counting
|
|
Another day counting system in common use is, confusingly, also
|
|
called ``Julian.'' It was invented in 1583 by Joseph Justus
|
|
Scaliger, who named it in honor of his father Julius Caesar
|
|
Scaliger. For obscure reasons he chose to start his day
|
|
numbering on Jan 1, 4713 BC at noon, which in Calc's scheme
|
|
is @mathit{-1721423.5} (recall that Calc starts at midnight instead
|
|
of noon). Thus to convert a Calc date code obtained by
|
|
unpacking a date form into a Julian day number, simply add
|
|
1721423.5. The Julian code for @samp{6:00am Jan 9, 1991}
|
|
is 2448265.75. The built-in @kbd{t J} command performs
|
|
this conversion for you.
|
|
|
|
@cindex Unix time format
|
|
The Unix operating system measures time as an integer number of
|
|
seconds since midnight, Jan 1, 1970. To convert a Calc date
|
|
value into a Unix time stamp, first subtract 719164 (the code
|
|
for @samp{<Jan 1, 1970>}), then multiply by 86400 (the number of
|
|
seconds in a day) and press @kbd{R} to round to the nearest
|
|
integer. If you have a date form, you can simply subtract the
|
|
day @samp{<Jan 1, 1970>} instead of unpacking and subtracting
|
|
719164. Likewise, divide by 86400 and add @samp{<Jan 1, 1970>}
|
|
to convert from Unix time to a Calc date form. (Note that
|
|
Unix normally maintains the time in the GMT time zone; you may
|
|
need to subtract five hours to get New York time, or eight hours
|
|
for California time. The same is usually true of Julian day
|
|
counts.) The built-in @kbd{t U} command performs these
|
|
conversions.
|
|
|
|
@node Modulo Forms, Error Forms, Date Forms, Data Types
|
|
@section Modulo Forms
|
|
|
|
@noindent
|
|
@cindex Modulo forms
|
|
A @dfn{modulo form} is a real number which is taken modulo (i.e., within
|
|
an integer multiple of) some value @var{M}. Arithmetic modulo @var{M}
|
|
often arises in number theory. Modulo forms are written
|
|
`@var{a} @tfn{mod} @var{M}',
|
|
where @var{a} and @var{M} are real numbers or HMS forms, and
|
|
@texline @math{0 \le a < M}.
|
|
@infoline @expr{0 <= a < @var{M}}.
|
|
In many applications @expr{a} and @expr{M} will be
|
|
integers but this is not required.
|
|
|
|
@ignore
|
|
@mindex M
|
|
@end ignore
|
|
@kindex M (modulo forms)
|
|
@ignore
|
|
@mindex mod
|
|
@end ignore
|
|
@tindex mod (operator)
|
|
To create a modulo form during numeric entry, press the shift-@kbd{M}
|
|
key to enter the word @samp{mod}. As a special convenience, pressing
|
|
shift-@kbd{M} a second time automatically enters the value of @expr{M}
|
|
that was most recently used before. During algebraic entry, either
|
|
type @samp{mod} by hand or press @kbd{M-m} (that's @kbd{@key{META}-m}).
|
|
Once again, pressing this a second time enters the current modulo.
|
|
|
|
Modulo forms are not to be confused with the modulo operator @samp{%}.
|
|
The expression @samp{27 % 10} means to compute 27 modulo 10 to produce
|
|
the result 7. Further computations treat this 7 as just a regular integer.
|
|
The expression @samp{27 mod 10} produces the result @samp{7 mod 10};
|
|
further computations with this value are again reduced modulo 10 so that
|
|
the result always lies in the desired range.
|
|
|
|
When two modulo forms with identical @expr{M}'s are added or multiplied,
|
|
the Calculator simply adds or multiplies the values, then reduces modulo
|
|
@expr{M}. If one argument is a modulo form and the other a plain number,
|
|
the plain number is treated like a compatible modulo form. It is also
|
|
possible to raise modulo forms to powers; the result is the value raised
|
|
to the power, then reduced modulo @expr{M}. (When all values involved
|
|
are integers, this calculation is done much more efficiently than
|
|
actually computing the power and then reducing.)
|
|
|
|
@cindex Modulo division
|
|
Two modulo forms `@var{a} @tfn{mod} @var{M}' and `@var{b} @tfn{mod} @var{M}'
|
|
can be divided if @expr{a}, @expr{b}, and @expr{M} are all
|
|
integers. The result is the modulo form which, when multiplied by
|
|
`@var{b} @tfn{mod} @var{M}', produces `@var{a} @tfn{mod} @var{M}'. If
|
|
there is no solution to this equation (which can happen only when
|
|
@expr{M} is non-prime), or if any of the arguments are non-integers, the
|
|
division is left in symbolic form. Other operations, such as square
|
|
roots, are not yet supported for modulo forms. (Note that, although
|
|
@w{`@tfn{(}@var{a} @tfn{mod} @var{M}@tfn{)^.5}'} will compute a ``modulo square root''
|
|
in the sense of reducing
|
|
@texline @math{\sqrt a}
|
|
@infoline @expr{sqrt(a)}
|
|
modulo @expr{M}, this is not a useful definition from the
|
|
number-theoretical point of view.)
|
|
|
|
It is possible to mix HMS forms and modulo forms. For example, an
|
|
HMS form modulo 24 could be used to manipulate clock times; an HMS
|
|
form modulo 360 would be suitable for angles. Making the modulo @expr{M}
|
|
also be an HMS form eliminates troubles that would arise if the angular
|
|
mode were inadvertently set to Radians, in which case
|
|
@w{@samp{2@@ 0' 0" mod 24}} would be interpreted as two degrees modulo
|
|
24 radians!
|
|
|
|
Modulo forms cannot have variables or formulas for components. If you
|
|
enter the formula @samp{(x + 2) mod 5}, Calc propagates the modulus
|
|
to each of the coefficients: @samp{(1 mod 5) x + (2 mod 5)}.
|
|
|
|
You can use @kbd{v p} and @kbd{%} to modify modulo forms.
|
|
@xref{Packing and Unpacking}. @xref{Basic Arithmetic}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex makemod
|
|
The algebraic function @samp{makemod(a, m)} builds the modulo form
|
|
@w{@samp{a mod m}}.
|
|
|
|
@node Error Forms, Interval Forms, Modulo Forms, Data Types
|
|
@section Error Forms
|
|
|
|
@noindent
|
|
@cindex Error forms
|
|
@cindex Standard deviations
|
|
An @dfn{error form} is a number with an associated standard
|
|
deviation, as in @samp{2.3 +/- 0.12}. The notation
|
|
@texline `@var{x} @tfn{+/-} @math{\sigma}'
|
|
@infoline `@var{x} @tfn{+/-} sigma'
|
|
stands for an uncertain value which follows
|
|
a normal or Gaussian distribution of mean @expr{x} and standard
|
|
deviation or ``error''
|
|
@texline @math{\sigma}.
|
|
@infoline @expr{sigma}.
|
|
Both the mean and the error can be either numbers or
|
|
formulas. Generally these are real numbers but the mean may also be
|
|
complex. If the error is negative or complex, it is changed to its
|
|
absolute value. An error form with zero error is converted to a
|
|
regular number by the Calculator.
|
|
|
|
All arithmetic and transcendental functions accept error forms as input.
|
|
Operations on the mean-value part work just like operations on regular
|
|
numbers. The error part for any function @expr{f(x)} (such as
|
|
@texline @math{\sin x}
|
|
@infoline @expr{sin(x)})
|
|
is defined by the error of @expr{x} times the derivative of @expr{f}
|
|
evaluated at the mean value of @expr{x}. For a two-argument function
|
|
@expr{f(x,y)} (such as addition) the error is the square root of the sum
|
|
of the squares of the errors due to @expr{x} and @expr{y}.
|
|
@tex
|
|
$$ \eqalign{
|
|
f(x \hbox{\code{ +/- }} \sigma)
|
|
&= f(x) \hbox{\code{ +/- }} \sigma \left| {df(x) \over dx} \right| \cr
|
|
f(x \hbox{\code{ +/- }} \sigma_x, y \hbox{\code{ +/- }} \sigma_y)
|
|
&= f(x,y) \hbox{\code{ +/- }}
|
|
\sqrt{\left(\sigma_x \left| {\partial f(x,y) \over \partial x}
|
|
\right| \right)^2
|
|
+\left(\sigma_y \left| {\partial f(x,y) \over \partial y}
|
|
\right| \right)^2 } \cr
|
|
} $$
|
|
@end tex
|
|
Note that this
|
|
definition assumes the errors in @expr{x} and @expr{y} are uncorrelated.
|
|
A side effect of this definition is that @samp{(2 +/- 1) * (2 +/- 1)}
|
|
is not the same as @samp{(2 +/- 1)^2}; the former represents the product
|
|
of two independent values which happen to have the same probability
|
|
distributions, and the latter is the product of one random value with itself.
|
|
The former will produce an answer with less error, since on the average
|
|
the two independent errors can be expected to cancel out.
|
|
|
|
Consult a good text on error analysis for a discussion of the proper use
|
|
of standard deviations. Actual errors often are neither Gaussian-distributed
|
|
nor uncorrelated, and the above formulas are valid only when errors
|
|
are small. As an example, the error arising from
|
|
@texline `@tfn{sin(}@var{x} @tfn{+/-} @math{\sigma}@tfn{)}'
|
|
@infoline `@tfn{sin(}@var{x} @tfn{+/-} @var{sigma}@tfn{)}'
|
|
is
|
|
@texline `@math{\sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
|
|
@infoline `@var{sigma} @tfn{abs(cos(}@var{x}@tfn{))}'.
|
|
When @expr{x} is close to zero,
|
|
@texline @math{\cos x}
|
|
@infoline @expr{cos(x)}
|
|
is close to one so the error in the sine is close to
|
|
@texline @math{\sigma};
|
|
@infoline @expr{sigma};
|
|
this makes sense, since
|
|
@texline @math{\sin x}
|
|
@infoline @expr{sin(x)}
|
|
is approximately @expr{x} near zero, so a given error in @expr{x} will
|
|
produce about the same error in the sine. Likewise, near 90 degrees
|
|
@texline @math{\cos x}
|
|
@infoline @expr{cos(x)}
|
|
is nearly zero and so the computed error is
|
|
small: The sine curve is nearly flat in that region, so an error in @expr{x}
|
|
has relatively little effect on the value of
|
|
@texline @math{\sin x}.
|
|
@infoline @expr{sin(x)}.
|
|
However, consider @samp{sin(90 +/- 1000)}. The cosine of 90 is zero, so
|
|
Calc will report zero error! We get an obviously wrong result because
|
|
we have violated the small-error approximation underlying the error
|
|
analysis. If the error in @expr{x} had been small, the error in
|
|
@texline @math{\sin x}
|
|
@infoline @expr{sin(x)}
|
|
would indeed have been negligible.
|
|
|
|
@ignore
|
|
@mindex p
|
|
@end ignore
|
|
@kindex p (error forms)
|
|
@tindex +/-
|
|
To enter an error form during regular numeric entry, use the @kbd{p}
|
|
(``plus-or-minus'') key to type the @samp{+/-} symbol. (If you try actually
|
|
typing @samp{+/-} the @kbd{+} key will be interpreted as the Calculator's
|
|
@kbd{+} command!) Within an algebraic formula, you can press @kbd{M-p} to
|
|
type the @samp{+/-} symbol, or type it out by hand.
|
|
|
|
Error forms and complex numbers can be mixed; the formulas shown above
|
|
are used for complex numbers, too; note that if the error part evaluates
|
|
to a complex number its absolute value (or the square root of the sum of
|
|
the squares of the absolute values of the two error contributions) is
|
|
used. Mathematically, this corresponds to a radially symmetric Gaussian
|
|
distribution of numbers on the complex plane. However, note that Calc
|
|
considers an error form with real components to represent a real number,
|
|
not a complex distribution around a real mean.
|
|
|
|
Error forms may also be composed of HMS forms. For best results, both
|
|
the mean and the error should be HMS forms if either one is.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex sdev
|
|
The algebraic function @samp{sdev(a, b)} builds the error form @samp{a +/- b}.
|
|
|
|
@node Interval Forms, Incomplete Objects, Error Forms, Data Types
|
|
@section Interval Forms
|
|
|
|
@noindent
|
|
@cindex Interval forms
|
|
An @dfn{interval} is a subset of consecutive real numbers. For example,
|
|
the interval @samp{[2 ..@: 4]} represents all the numbers from 2 to 4,
|
|
inclusive. If you multiply it by the interval @samp{[0.5 ..@: 2]} you
|
|
obtain @samp{[1 ..@: 8]}. This calculation represents the fact that if
|
|
you multiply some number in the range @samp{[2 ..@: 4]} by some other
|
|
number in the range @samp{[0.5 ..@: 2]}, your result will lie in the range
|
|
from 1 to 8. Interval arithmetic is used to get a worst-case estimate
|
|
of the possible range of values a computation will produce, given the
|
|
set of possible values of the input.
|
|
|
|
@ifinfo
|
|
Calc supports several varieties of intervals, including @dfn{closed}
|
|
intervals of the type shown above, @dfn{open} intervals such as
|
|
@samp{(2 ..@: 4)}, which represents the range of numbers from 2 to 4
|
|
@emph{exclusive}, and @dfn{semi-open} intervals in which one end
|
|
uses a round parenthesis and the other a square bracket. In mathematical
|
|
terms,
|
|
@samp{[2 ..@: 4]} means @expr{2 <= x <= 4}, whereas
|
|
@samp{[2 ..@: 4)} represents @expr{2 <= x < 4},
|
|
@samp{(2 ..@: 4]} represents @expr{2 < x <= 4}, and
|
|
@samp{(2 ..@: 4)} represents @expr{2 < x < 4}.
|
|
@end ifinfo
|
|
@tex
|
|
Calc supports several varieties of intervals, including \dfn{closed}
|
|
intervals of the type shown above, \dfn{open} intervals such as
|
|
\samp{(2 ..\: 4)}, which represents the range of numbers from 2 to 4
|
|
\emph{exclusive}, and \dfn{semi-open} intervals in which one end
|
|
uses a round parenthesis and the other a square bracket. In mathematical
|
|
terms,
|
|
$$ \eqalign{
|
|
[2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 \le x \le 4 \cr
|
|
[2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 \le x < 4 \cr
|
|
(2 \hbox{\cite{..}} 4] &\quad\hbox{means}\quad 2 < x \le 4 \cr
|
|
(2 \hbox{\cite{..}} 4) &\quad\hbox{means}\quad 2 < x < 4 \cr
|
|
} $$
|
|
@end tex
|
|
|
|
The lower and upper limits of an interval must be either real numbers
|
|
(or HMS or date forms), or symbolic expressions which are assumed to be
|
|
real-valued, or @samp{-inf} and @samp{inf}. In general the lower limit
|
|
must be less than the upper limit. A closed interval containing only
|
|
one value, @samp{[3 ..@: 3]}, is converted to a plain number (3)
|
|
automatically. An interval containing no values at all (such as
|
|
@samp{[3 ..@: 2]} or @samp{[2 ..@: 2)}) can be represented but is not
|
|
guaranteed to behave well when used in arithmetic. Note that the
|
|
interval @samp{[3 .. inf)} represents all real numbers greater than
|
|
or equal to 3, and @samp{(-inf .. inf)} represents all real numbers.
|
|
In fact, @samp{[-inf .. inf]} represents all real numbers including
|
|
the real infinities.
|
|
|
|
Intervals are entered in the notation shown here, either as algebraic
|
|
formulas, or using incomplete forms. (@xref{Incomplete Objects}.)
|
|
In algebraic formulas, multiple periods in a row are collected from
|
|
left to right, so that @samp{1...1e2} is interpreted as @samp{1.0 ..@: 1e2}
|
|
rather than @samp{1 ..@: 0.1e2}. Add spaces or zeros if you want to
|
|
get the other interpretation. If you omit the lower or upper limit,
|
|
a default of @samp{-inf} or @samp{inf} (respectively) is furnished.
|
|
|
|
Infinite mode also affects operations on intervals
|
|
(@pxref{Infinities}). Calc will always introduce an open infinity,
|
|
as in @samp{1 / (0 .. 2] = [0.5 .. inf)}. But closed infinities,
|
|
@w{@samp{1 / [0 .. 2] = [0.5 .. inf]}}, arise only in Infinite mode;
|
|
otherwise they are left unevaluated. Note that the ``direction'' of
|
|
a zero is not an issue in this case since the zero is always assumed
|
|
to be continuous with the rest of the interval. For intervals that
|
|
contain zero inside them Calc is forced to give the result,
|
|
@samp{1 / (-2 .. 2) = [-inf .. inf]}.
|
|
|
|
While it may seem that intervals and error forms are similar, they are
|
|
based on entirely different concepts of inexact quantities. An error
|
|
form
|
|
@texline `@var{x} @tfn{+/-} @math{\sigma}'
|
|
@infoline `@var{x} @tfn{+/-} @var{sigma}'
|
|
means a variable is random, and its value could
|
|
be anything but is ``probably'' within one
|
|
@texline @math{\sigma}
|
|
@infoline @var{sigma}
|
|
of the mean value @expr{x}. An interval
|
|
`@tfn{[}@var{a} @tfn{..@:} @var{b}@tfn{]}' means a
|
|
variable's value is unknown, but guaranteed to lie in the specified
|
|
range. Error forms are statistical or ``average case'' approximations;
|
|
interval arithmetic tends to produce ``worst case'' bounds on an
|
|
answer.
|
|
|
|
Intervals may not contain complex numbers, but they may contain
|
|
HMS forms or date forms.
|
|
|
|
@xref{Set Operations}, for commands that interpret interval forms
|
|
as subsets of the set of real numbers.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex intv
|
|
The algebraic function @samp{intv(n, a, b)} builds an interval form
|
|
from @samp{a} to @samp{b}; @samp{n} is an integer code which must
|
|
be 0 for @samp{(..)}, 1 for @samp{(..]}, 2 for @samp{[..)}, or
|
|
3 for @samp{[..]}.
|
|
|
|
Please note that in fully rigorous interval arithmetic, care would be
|
|
taken to make sure that the computation of the lower bound rounds toward
|
|
minus infinity, while upper bound computations round toward plus
|
|
infinity. Calc's arithmetic always uses a round-to-nearest mode,
|
|
which means that roundoff errors could creep into an interval
|
|
calculation to produce intervals slightly smaller than they ought to
|
|
be. For example, entering @samp{[1..2]} and pressing @kbd{Q 2 ^}
|
|
should yield the interval @samp{[1..2]} again, but in fact it yields the
|
|
(slightly too small) interval @samp{[1..1.9999999]} due to roundoff
|
|
error.
|
|
|
|
@node Incomplete Objects, Variables, Interval Forms, Data Types
|
|
@section Incomplete Objects
|
|
|
|
@noindent
|
|
@ignore
|
|
@mindex [ ]
|
|
@end ignore
|
|
@kindex [
|
|
@ignore
|
|
@mindex ( )
|
|
@end ignore
|
|
@kindex (
|
|
@kindex ,
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex ]
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex )
|
|
@cindex Incomplete vectors
|
|
@cindex Incomplete complex numbers
|
|
@cindex Incomplete interval forms
|
|
When @kbd{(} or @kbd{[} is typed to begin entering a complex number or
|
|
vector, respectively, the effect is to push an @dfn{incomplete} complex
|
|
number or vector onto the stack. The @kbd{,} key adds the value(s) at
|
|
the top of the stack onto the current incomplete object. The @kbd{)}
|
|
and @kbd{]} keys ``close'' the incomplete object after adding any values
|
|
on the top of the stack in front of the incomplete object.
|
|
|
|
As a result, the sequence of keystrokes @kbd{[ 2 , 3 @key{RET} 2 * , 9 ]}
|
|
pushes the vector @samp{[2, 6, 9]} onto the stack. Likewise, @kbd{( 1 , 2 Q )}
|
|
pushes the complex number @samp{(1, 1.414)} (approximately).
|
|
|
|
If several values lie on the stack in front of the incomplete object,
|
|
all are collected and appended to the object. Thus the @kbd{,} key
|
|
is redundant: @kbd{[ 2 @key{RET} 3 @key{RET} 2 * 9 ]}. Some people
|
|
prefer the equivalent @key{SPC} key to @key{RET}.
|
|
|
|
As a special case, typing @kbd{,} immediately after @kbd{(}, @kbd{[}, or
|
|
@kbd{,} adds a zero or duplicates the preceding value in the list being
|
|
formed. Typing @key{DEL} during incomplete entry removes the last item
|
|
from the list.
|
|
|
|
@kindex ;
|
|
The @kbd{;} key is used in the same way as @kbd{,} to create polar complex
|
|
numbers: @kbd{( 1 ; 2 )}. When entering a vector, @kbd{;} is useful for
|
|
creating a matrix. In particular, @kbd{[ [ 1 , 2 ; 3 , 4 ; 5 , 6 ] ]} is
|
|
equivalent to @kbd{[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ]}.
|
|
|
|
@kindex ..
|
|
@pindex calc-dots
|
|
Incomplete entry is also used to enter intervals. For example,
|
|
@kbd{[ 2 ..@: 4 )} enters a semi-open interval. Note that when you type
|
|
the first period, it will be interpreted as a decimal point, but when
|
|
you type a second period immediately afterward, it is re-interpreted as
|
|
part of the interval symbol. Typing @kbd{..} corresponds to executing
|
|
the @code{calc-dots} command.
|
|
|
|
If you find incomplete entry distracting, you may wish to enter vectors
|
|
and complex numbers as algebraic formulas by pressing the apostrophe key.
|
|
|
|
@node Variables, Formulas, Incomplete Objects, Data Types
|
|
@section Variables
|
|
|
|
@noindent
|
|
@cindex Variables, in formulas
|
|
A @dfn{variable} is somewhere between a storage register on a conventional
|
|
calculator, and a variable in a programming language. (In fact, a Calc
|
|
variable is really just an Emacs Lisp variable that contains a Calc number
|
|
or formula.) A variable's name is normally composed of letters and digits.
|
|
Calc also allows apostrophes and @code{#} signs in variable names.
|
|
(The Calc variable @code{foo} corresponds to the Emacs Lisp variable
|
|
@code{var-foo}, but unless you access the variable from within Emacs
|
|
Lisp, you don't need to worry about it. Variable names in algebraic
|
|
formulas implicitly have @samp{var-} prefixed to their names. The
|
|
@samp{#} character in variable names used in algebraic formulas
|
|
corresponds to a dash @samp{-} in the Lisp variable name. If the name
|
|
contains any dashes, the prefix @samp{var-} is @emph{not} automatically
|
|
added. Thus the two formulas @samp{foo + 1} and @samp{var#foo + 1} both
|
|
refer to the same variable.)
|
|
|
|
In a command that takes a variable name, you can either type the full
|
|
name of a variable, or type a single digit to use one of the special
|
|
convenience variables @code{q0} through @code{q9}. For example,
|
|
@kbd{3 s s 2} stores the number 3 in variable @code{q2}, and
|
|
@w{@kbd{3 s s foo @key{RET}}} stores that number in variable
|
|
@code{foo}.
|
|
|
|
To push a variable itself (as opposed to the variable's value) on the
|
|
stack, enter its name as an algebraic expression using the apostrophe
|
|
(@key{'}) key.
|
|
|
|
@kindex =
|
|
@pindex calc-evaluate
|
|
@cindex Evaluation of variables in a formula
|
|
@cindex Variables, evaluation
|
|
@cindex Formulas, evaluation
|
|
The @kbd{=} (@code{calc-evaluate}) key ``evaluates'' a formula by
|
|
replacing all variables in the formula which have been given values by a
|
|
@code{calc-store} or @code{calc-let} command by their stored values.
|
|
Other variables are left alone. Thus a variable that has not been
|
|
stored acts like an abstract variable in algebra; a variable that has
|
|
been stored acts more like a register in a traditional calculator.
|
|
With a positive numeric prefix argument, @kbd{=} evaluates the top
|
|
@var{n} stack entries; with a negative argument, @kbd{=} evaluates
|
|
the @var{n}th stack entry.
|
|
|
|
@cindex @code{e} variable
|
|
@cindex @code{pi} variable
|
|
@cindex @code{i} variable
|
|
@cindex @code{phi} variable
|
|
@cindex @code{gamma} variable
|
|
@vindex e
|
|
@vindex pi
|
|
@vindex i
|
|
@vindex phi
|
|
@vindex gamma
|
|
A few variables are called @dfn{special constants}. Their names are
|
|
@samp{e}, @samp{pi}, @samp{i}, @samp{phi}, and @samp{gamma}.
|
|
(@xref{Scientific Functions}.) When they are evaluated with @kbd{=},
|
|
their values are calculated if necessary according to the current precision
|
|
or complex polar mode. If you wish to use these symbols for other purposes,
|
|
simply undefine or redefine them using @code{calc-store}.
|
|
|
|
The variables @samp{inf}, @samp{uinf}, and @samp{nan} stand for
|
|
infinite or indeterminate values. It's best not to use them as
|
|
regular variables, since Calc uses special algebraic rules when
|
|
it manipulates them. Calc displays a warning message if you store
|
|
a value into any of these special variables.
|
|
|
|
@xref{Store and Recall}, for a discussion of commands dealing with variables.
|
|
|
|
@node Formulas, , Variables, Data Types
|
|
@section Formulas
|
|
|
|
@noindent
|
|
@cindex Formulas
|
|
@cindex Expressions
|
|
@cindex Operators in formulas
|
|
@cindex Precedence of operators
|
|
When you press the apostrophe key you may enter any expression or formula
|
|
in algebraic form. (Calc uses the terms ``expression'' and ``formula''
|
|
interchangeably.) An expression is built up of numbers, variable names,
|
|
and function calls, combined with various arithmetic operators.
|
|
Parentheses may
|
|
be used to indicate grouping. Spaces are ignored within formulas, except
|
|
that spaces are not permitted within variable names or numbers.
|
|
Arithmetic operators, in order from highest to lowest precedence, and
|
|
with their equivalent function names, are:
|
|
|
|
@samp{_} [@code{subscr}] (subscripts);
|
|
|
|
postfix @samp{%} [@code{percent}] (as in @samp{25% = 0.25});
|
|
|
|
prefix @samp{+} and @samp{-} [@code{neg}] (as in @samp{-x})
|
|
and prefix @samp{!} [@code{lnot}] (logical ``not,'' as in @samp{!x});
|
|
|
|
@samp{+/-} [@code{sdev}] (the standard deviation symbol) and
|
|
@samp{mod} [@code{makemod}] (the symbol for modulo forms);
|
|
|
|
postfix @samp{!} [@code{fact}] (factorial, as in @samp{n!})
|
|
and postfix @samp{!!} [@code{dfact}] (double factorial);
|
|
|
|
@samp{^} [@code{pow}] (raised-to-the-power-of);
|
|
|
|
@samp{*} [@code{mul}];
|
|
|
|
@samp{/} [@code{div}], @samp{%} [@code{mod}] (modulo), and
|
|
@samp{\} [@code{idiv}] (integer division);
|
|
|
|
infix @samp{+} [@code{add}] and @samp{-} [@code{sub}] (as in @samp{x-y});
|
|
|
|
@samp{|} [@code{vconcat}] (vector concatenation);
|
|
|
|
relations @samp{=} [@code{eq}], @samp{!=} [@code{neq}], @samp{<} [@code{lt}],
|
|
@samp{>} [@code{gt}], @samp{<=} [@code{leq}], and @samp{>=} [@code{geq}];
|
|
|
|
@samp{&&} [@code{land}] (logical ``and'');
|
|
|
|
@samp{||} [@code{lor}] (logical ``or'');
|
|
|
|
the C-style ``if'' operator @samp{a?b:c} [@code{if}];
|
|
|
|
@samp{!!!} [@code{pnot}] (rewrite pattern ``not'');
|
|
|
|
@samp{&&&} [@code{pand}] (rewrite pattern ``and'');
|
|
|
|
@samp{|||} [@code{por}] (rewrite pattern ``or'');
|
|
|
|
@samp{:=} [@code{assign}] (for assignments and rewrite rules);
|
|
|
|
@samp{::} [@code{condition}] (rewrite pattern condition);
|
|
|
|
@samp{=>} [@code{evalto}].
|
|
|
|
Note that, unlike in usual computer notation, multiplication binds more
|
|
strongly than division: @samp{a*b/c*d} is equivalent to
|
|
@texline @math{a b \over c d}.
|
|
@infoline @expr{(a*b)/(c*d)}.
|
|
|
|
@cindex Multiplication, implicit
|
|
@cindex Implicit multiplication
|
|
The multiplication sign @samp{*} may be omitted in many cases. In particular,
|
|
if the righthand side is a number, variable name, or parenthesized
|
|
expression, the @samp{*} may be omitted. Implicit multiplication has the
|
|
same precedence as the explicit @samp{*} operator. The one exception to
|
|
the rule is that a variable name followed by a parenthesized expression,
|
|
as in @samp{f(x)},
|
|
is interpreted as a function call, not an implicit @samp{*}. In many
|
|
cases you must use a space if you omit the @samp{*}: @samp{2a} is the
|
|
same as @samp{2*a}, and @samp{a b} is the same as @samp{a*b}, but @samp{ab}
|
|
is a variable called @code{ab}, @emph{not} the product of @samp{a} and
|
|
@samp{b}! Also note that @samp{f (x)} is still a function call.
|
|
|
|
@cindex Implicit comma in vectors
|
|
The rules are slightly different for vectors written with square brackets.
|
|
In vectors, the space character is interpreted (like the comma) as a
|
|
separator of elements of the vector. Thus @w{@samp{[ 2a b+c d ]}} is
|
|
equivalent to @samp{[2*a, b+c, d]}, whereas @samp{2a b+c d} is equivalent
|
|
to @samp{2*a*b + c*d}.
|
|
Note that spaces around the brackets, and around explicit commas, are
|
|
ignored. To force spaces to be interpreted as multiplication you can
|
|
enclose a formula in parentheses as in @samp{[(a b) 2(c d)]}, which is
|
|
interpreted as @samp{[a*b, 2*c*d]}. An implicit comma is also inserted
|
|
between @samp{][}, as in the matrix @samp{[[1 2][3 4]]}.
|
|
|
|
Vectors that contain commas (not embedded within nested parentheses or
|
|
brackets) do not treat spaces specially: @samp{[a b, 2 c d]} is a vector
|
|
of two elements. Also, if it would be an error to treat spaces as
|
|
separators, but not otherwise, then Calc will ignore spaces:
|
|
@w{@samp{[a - b]}} is a vector of one element, but @w{@samp{[a -b]}} is
|
|
a vector of two elements. Finally, vectors entered with curly braces
|
|
instead of square brackets do not give spaces any special treatment.
|
|
When Calc displays a vector that does not contain any commas, it will
|
|
insert parentheses if necessary to make the meaning clear:
|
|
@w{@samp{[(a b)]}}.
|
|
|
|
The expression @samp{5%-2} is ambiguous; is this five-percent minus two,
|
|
or five modulo minus-two? Calc always interprets the leftmost symbol as
|
|
an infix operator preferentially (modulo, in this case), so you would
|
|
need to write @samp{(5%)-2} to get the former interpretation.
|
|
|
|
@cindex Function call notation
|
|
A function call is, e.g., @samp{sin(1+x)}. (The Calc algebraic function
|
|
@code{foo} corresponds to the Emacs Lisp function @code{calcFunc-foo},
|
|
but unless you access the function from within Emacs Lisp, you don't
|
|
need to worry about it.) Most mathematical Calculator commands like
|
|
@code{calc-sin} have function equivalents like @code{sin}.
|
|
If no Lisp function is defined for a function called by a formula, the
|
|
call is left as it is during algebraic manipulation: @samp{f(x+y)} is
|
|
left alone. Beware that many innocent-looking short names like @code{in}
|
|
and @code{re} have predefined meanings which could surprise you; however,
|
|
single letters or single letters followed by digits are always safe to
|
|
use for your own function names. @xref{Function Index}.
|
|
|
|
In the documentation for particular commands, the notation @kbd{H S}
|
|
(@code{calc-sinh}) [@code{sinh}] means that the key sequence @kbd{H S}, the
|
|
command @kbd{M-x calc-sinh}, and the algebraic function @code{sinh(x)} all
|
|
represent the same operation.
|
|
|
|
Commands that interpret (``parse'') text as algebraic formulas include
|
|
algebraic entry (@kbd{'}), editing commands like @kbd{`} which parse
|
|
the contents of the editing buffer when you finish, the @kbd{C-x * g}
|
|
and @w{@kbd{C-x * r}} commands, the @kbd{C-y} command, the X window system
|
|
``paste'' mouse operation, and Embedded mode. All of these operations
|
|
use the same rules for parsing formulas; in particular, language modes
|
|
(@pxref{Language Modes}) affect them all in the same way.
|
|
|
|
When you read a large amount of text into the Calculator (say a vector
|
|
which represents a big set of rewrite rules; @pxref{Rewrite Rules}),
|
|
you may wish to include comments in the text. Calc's formula parser
|
|
ignores the symbol @samp{%%} and anything following it on a line:
|
|
|
|
@example
|
|
[ a + b, %% the sum of "a" and "b"
|
|
c + d,
|
|
%% last line is coming up:
|
|
e + f ]
|
|
@end example
|
|
|
|
@noindent
|
|
This is parsed exactly the same as @samp{[ a + b, c + d, e + f ]}.
|
|
|
|
@xref{Syntax Tables}, for a way to create your own operators and other
|
|
input notations. @xref{Compositions}, for a way to create new display
|
|
formats.
|
|
|
|
@xref{Algebra}, for commands for manipulating formulas symbolically.
|
|
|
|
@node Stack and Trail, Mode Settings, Data Types, Top
|
|
@chapter Stack and Trail Commands
|
|
|
|
@noindent
|
|
This chapter describes the Calc commands for manipulating objects on the
|
|
stack and in the trail buffer. (These commands operate on objects of any
|
|
type, such as numbers, vectors, formulas, and incomplete objects.)
|
|
|
|
@menu
|
|
* Stack Manipulation::
|
|
* Editing Stack Entries::
|
|
* Trail Commands::
|
|
* Keep Arguments::
|
|
@end menu
|
|
|
|
@node Stack Manipulation, Editing Stack Entries, Stack and Trail, Stack and Trail
|
|
@section Stack Manipulation Commands
|
|
|
|
@noindent
|
|
@kindex @key{RET}
|
|
@kindex @key{SPC}
|
|
@pindex calc-enter
|
|
@cindex Duplicating stack entries
|
|
To duplicate the top object on the stack, press @key{RET} or @key{SPC}
|
|
(two equivalent keys for the @code{calc-enter} command).
|
|
Given a positive numeric prefix argument, these commands duplicate
|
|
several elements at the top of the stack.
|
|
Given a negative argument,
|
|
these commands duplicate the specified element of the stack.
|
|
Given an argument of zero, they duplicate the entire stack.
|
|
For example, with @samp{10 20 30} on the stack,
|
|
@key{RET} creates @samp{10 20 30 30},
|
|
@kbd{C-u 2 @key{RET}} creates @samp{10 20 30 20 30},
|
|
@kbd{C-u - 2 @key{RET}} creates @samp{10 20 30 20}, and
|
|
@kbd{C-u 0 @key{RET}} creates @samp{10 20 30 10 20 30}.
|
|
|
|
@kindex @key{LFD}
|
|
@pindex calc-over
|
|
The @key{LFD} (@code{calc-over}) command (on a key marked Line-Feed if you
|
|
have it, else on @kbd{C-j}) is like @code{calc-enter}
|
|
except that the sign of the numeric prefix argument is interpreted
|
|
oppositely. Also, with no prefix argument the default argument is 2.
|
|
Thus with @samp{10 20 30} on the stack, @key{LFD} and @kbd{C-u 2 @key{LFD}}
|
|
are both equivalent to @kbd{C-u - 2 @key{RET}}, producing
|
|
@samp{10 20 30 20}.
|
|
|
|
@kindex @key{DEL}
|
|
@kindex C-d
|
|
@pindex calc-pop
|
|
@cindex Removing stack entries
|
|
@cindex Deleting stack entries
|
|
To remove the top element from the stack, press @key{DEL} (@code{calc-pop}).
|
|
The @kbd{C-d} key is a synonym for @key{DEL}.
|
|
(If the top element is an incomplete object with at least one element, the
|
|
last element is removed from it.) Given a positive numeric prefix argument,
|
|
several elements are removed. Given a negative argument, the specified
|
|
element of the stack is deleted. Given an argument of zero, the entire
|
|
stack is emptied.
|
|
For example, with @samp{10 20 30} on the stack,
|
|
@key{DEL} leaves @samp{10 20},
|
|
@kbd{C-u 2 @key{DEL}} leaves @samp{10},
|
|
@kbd{C-u - 2 @key{DEL}} leaves @samp{10 30}, and
|
|
@kbd{C-u 0 @key{DEL}} leaves an empty stack.
|
|
|
|
@kindex M-@key{DEL}
|
|
@pindex calc-pop-above
|
|
The @kbd{M-@key{DEL}} (@code{calc-pop-above}) command is to @key{DEL} what
|
|
@key{LFD} is to @key{RET}: It interprets the sign of the numeric
|
|
prefix argument in the opposite way, and the default argument is 2.
|
|
Thus @kbd{M-@key{DEL}} by itself removes the second-from-top stack element,
|
|
leaving the first, third, fourth, and so on; @kbd{M-3 M-@key{DEL}} deletes
|
|
the third stack element.
|
|
|
|
@kindex @key{TAB}
|
|
@pindex calc-roll-down
|
|
To exchange the top two elements of the stack, press @key{TAB}
|
|
(@code{calc-roll-down}). Given a positive numeric prefix argument, the
|
|
specified number of elements at the top of the stack are rotated downward.
|
|
Given a negative argument, the entire stack is rotated downward the specified
|
|
number of times. Given an argument of zero, the entire stack is reversed
|
|
top-for-bottom.
|
|
For example, with @samp{10 20 30 40 50} on the stack,
|
|
@key{TAB} creates @samp{10 20 30 50 40},
|
|
@kbd{C-u 3 @key{TAB}} creates @samp{10 20 50 30 40},
|
|
@kbd{C-u - 2 @key{TAB}} creates @samp{40 50 10 20 30}, and
|
|
@kbd{C-u 0 @key{TAB}} creates @samp{50 40 30 20 10}.
|
|
|
|
@kindex M-@key{TAB}
|
|
@pindex calc-roll-up
|
|
The command @kbd{M-@key{TAB}} (@code{calc-roll-up}) is analogous to @key{TAB}
|
|
except that it rotates upward instead of downward. Also, the default
|
|
with no prefix argument is to rotate the top 3 elements.
|
|
For example, with @samp{10 20 30 40 50} on the stack,
|
|
@kbd{M-@key{TAB}} creates @samp{10 20 40 50 30},
|
|
@kbd{C-u 4 M-@key{TAB}} creates @samp{10 30 40 50 20},
|
|
@kbd{C-u - 2 M-@key{TAB}} creates @samp{30 40 50 10 20}, and
|
|
@kbd{C-u 0 M-@key{TAB}} creates @samp{50 40 30 20 10}.
|
|
|
|
A good way to view the operation of @key{TAB} and @kbd{M-@key{TAB}} is in
|
|
terms of moving a particular element to a new position in the stack.
|
|
With a positive argument @var{n}, @key{TAB} moves the top stack
|
|
element down to level @var{n}, making room for it by pulling all the
|
|
intervening stack elements toward the top. @kbd{M-@key{TAB}} moves the
|
|
element at level @var{n} up to the top. (Compare with @key{LFD},
|
|
which copies instead of moving the element in level @var{n}.)
|
|
|
|
With a negative argument @mathit{-@var{n}}, @key{TAB} rotates the stack
|
|
to move the object in level @var{n} to the deepest place in the
|
|
stack, and the object in level @mathit{@var{n}+1} to the top. @kbd{M-@key{TAB}}
|
|
rotates the deepest stack element to be in level @mathit{n}, also
|
|
putting the top stack element in level @mathit{@var{n}+1}.
|
|
|
|
@xref{Selecting Subformulas}, for a way to apply these commands to
|
|
any portion of a vector or formula on the stack.
|
|
|
|
@node Editing Stack Entries, Trail Commands, Stack Manipulation, Stack and Trail
|
|
@section Editing Stack Entries
|
|
|
|
@noindent
|
|
@kindex `
|
|
@pindex calc-edit
|
|
@pindex calc-edit-finish
|
|
@cindex Editing the stack with Emacs
|
|
The backquote, @kbd{`} (@code{calc-edit}) command creates a temporary
|
|
buffer (@samp{*Calc Edit*}) for editing the top-of-stack value using
|
|
regular Emacs commands. With a numeric prefix argument, it edits the
|
|
specified number of stack entries at once. (An argument of zero edits
|
|
the entire stack; a negative argument edits one specific stack entry.)
|
|
|
|
When you are done editing, press @kbd{C-c C-c} to finish and return
|
|
to Calc. The @key{RET} and @key{LFD} keys also work to finish most
|
|
sorts of editing, though in some cases Calc leaves @key{RET} with its
|
|
usual meaning (``insert a newline'') if it's a situation where you
|
|
might want to insert new lines into the editing buffer.
|
|
|
|
When you finish editing, the Calculator parses the lines of text in
|
|
the @samp{*Calc Edit*} buffer as numbers or formulas, replaces the
|
|
original stack elements in the original buffer with these new values,
|
|
then kills the @samp{*Calc Edit*} buffer. The original Calculator buffer
|
|
continues to exist during editing, but for best results you should be
|
|
careful not to change it until you have finished the edit. You can
|
|
also cancel the edit by killing the buffer with @kbd{C-x k}.
|
|
|
|
The formula is normally reevaluated as it is put onto the stack.
|
|
For example, editing @samp{a + 2} to @samp{3 + 2} and pressing
|
|
@kbd{C-c C-c} will push 5 on the stack. If you use @key{LFD} to
|
|
finish, Calc will put the result on the stack without evaluating it.
|
|
|
|
If you give a prefix argument to @kbd{C-c C-c},
|
|
Calc will not kill the @samp{*Calc Edit*} buffer. You can switch
|
|
back to that buffer and continue editing if you wish. However, you
|
|
should understand that if you initiated the edit with @kbd{`}, the
|
|
@kbd{C-c C-c} operation will be programmed to replace the top of the
|
|
stack with the new edited value, and it will do this even if you have
|
|
rearranged the stack in the meanwhile. This is not so much of a problem
|
|
with other editing commands, though, such as @kbd{s e}
|
|
(@code{calc-edit-variable}; @pxref{Operations on Variables}).
|
|
|
|
If the @code{calc-edit} command involves more than one stack entry,
|
|
each line of the @samp{*Calc Edit*} buffer is interpreted as a
|
|
separate formula. Otherwise, the entire buffer is interpreted as
|
|
one formula, with line breaks ignored. (You can use @kbd{C-o} or
|
|
@kbd{C-q C-j} to insert a newline in the buffer without pressing @key{RET}.)
|
|
|
|
The @kbd{`} key also works during numeric or algebraic entry. The
|
|
text entered so far is moved to the @code{*Calc Edit*} buffer for
|
|
more extensive editing than is convenient in the minibuffer.
|
|
|
|
@node Trail Commands, Keep Arguments, Editing Stack Entries, Stack and Trail
|
|
@section Trail Commands
|
|
|
|
@noindent
|
|
@cindex Trail buffer
|
|
The commands for manipulating the Calc Trail buffer are two-key sequences
|
|
beginning with the @kbd{t} prefix.
|
|
|
|
@kindex t d
|
|
@pindex calc-trail-display
|
|
The @kbd{t d} (@code{calc-trail-display}) command turns display of the
|
|
trail on and off. Normally the trail display is toggled on if it was off,
|
|
off if it was on. With a numeric prefix of zero, this command always
|
|
turns the trail off; with a prefix of one, it always turns the trail on.
|
|
The other trail-manipulation commands described here automatically turn
|
|
the trail on. Note that when the trail is off values are still recorded
|
|
there; they are simply not displayed. To set Emacs to turn the trail
|
|
off by default, type @kbd{t d} and then save the mode settings with
|
|
@kbd{m m} (@code{calc-save-modes}).
|
|
|
|
@kindex t i
|
|
@pindex calc-trail-in
|
|
@kindex t o
|
|
@pindex calc-trail-out
|
|
The @kbd{t i} (@code{calc-trail-in}) and @kbd{t o}
|
|
(@code{calc-trail-out}) commands switch the cursor into and out of the
|
|
Calc Trail window. In practice they are rarely used, since the commands
|
|
shown below are a more convenient way to move around in the
|
|
trail, and they work ``by remote control'' when the cursor is still
|
|
in the Calculator window.
|
|
|
|
@cindex Trail pointer
|
|
There is a @dfn{trail pointer} which selects some entry of the trail at
|
|
any given time. The trail pointer looks like a @samp{>} symbol right
|
|
before the selected number. The following commands operate on the
|
|
trail pointer in various ways.
|
|
|
|
@kindex t y
|
|
@pindex calc-trail-yank
|
|
@cindex Retrieving previous results
|
|
The @kbd{t y} (@code{calc-trail-yank}) command reads the selected value in
|
|
the trail and pushes it onto the Calculator stack. It allows you to
|
|
re-use any previously computed value without retyping. With a numeric
|
|
prefix argument @var{n}, it yanks the value @var{n} lines above the current
|
|
trail pointer.
|
|
|
|
@kindex t <
|
|
@pindex calc-trail-scroll-left
|
|
@kindex t >
|
|
@pindex calc-trail-scroll-right
|
|
The @kbd{t <} (@code{calc-trail-scroll-left}) and @kbd{t >}
|
|
(@code{calc-trail-scroll-right}) commands horizontally scroll the trail
|
|
window left or right by one half of its width.
|
|
|
|
@kindex t n
|
|
@pindex calc-trail-next
|
|
@kindex t p
|
|
@pindex calc-trail-previous
|
|
@kindex t f
|
|
@pindex calc-trail-forward
|
|
@kindex t b
|
|
@pindex calc-trail-backward
|
|
The @kbd{t n} (@code{calc-trail-next}) and @kbd{t p}
|
|
(@code{calc-trail-previous)} commands move the trail pointer down or up
|
|
one line. The @kbd{t f} (@code{calc-trail-forward}) and @kbd{t b}
|
|
(@code{calc-trail-backward}) commands move the trail pointer down or up
|
|
one screenful at a time. All of these commands accept numeric prefix
|
|
arguments to move several lines or screenfuls at a time.
|
|
|
|
@kindex t [
|
|
@pindex calc-trail-first
|
|
@kindex t ]
|
|
@pindex calc-trail-last
|
|
@kindex t h
|
|
@pindex calc-trail-here
|
|
The @kbd{t [} (@code{calc-trail-first}) and @kbd{t ]}
|
|
(@code{calc-trail-last}) commands move the trail pointer to the first or
|
|
last line of the trail. The @kbd{t h} (@code{calc-trail-here}) command
|
|
moves the trail pointer to the cursor position; unlike the other trail
|
|
commands, @kbd{t h} works only when Calc Trail is the selected window.
|
|
|
|
@kindex t s
|
|
@pindex calc-trail-isearch-forward
|
|
@kindex t r
|
|
@pindex calc-trail-isearch-backward
|
|
@ifinfo
|
|
The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
|
|
(@code{calc-trail-isearch-backward}) commands perform an incremental
|
|
search forward or backward through the trail. You can press @key{RET}
|
|
to terminate the search; the trail pointer moves to the current line.
|
|
If you cancel the search with @kbd{C-g}, the trail pointer stays where
|
|
it was when the search began.
|
|
@end ifinfo
|
|
@tex
|
|
The @kbd{t s} (@code{calc-trail-isearch-forward}) and @kbd{t r}
|
|
(@code{calc-trail-isearch-backward}) com\-mands perform an incremental
|
|
search forward or backward through the trail. You can press @key{RET}
|
|
to terminate the search; the trail pointer moves to the current line.
|
|
If you cancel the search with @kbd{C-g}, the trail pointer stays where
|
|
it was when the search began.
|
|
@end tex
|
|
|
|
@kindex t m
|
|
@pindex calc-trail-marker
|
|
The @kbd{t m} (@code{calc-trail-marker}) command allows you to enter a
|
|
line of text of your own choosing into the trail. The text is inserted
|
|
after the line containing the trail pointer; this usually means it is
|
|
added to the end of the trail. Trail markers are useful mainly as the
|
|
targets for later incremental searches in the trail.
|
|
|
|
@kindex t k
|
|
@pindex calc-trail-kill
|
|
The @kbd{t k} (@code{calc-trail-kill}) command removes the selected line
|
|
from the trail. The line is saved in the Emacs kill ring suitable for
|
|
yanking into another buffer, but it is not easy to yank the text back
|
|
into the trail buffer. With a numeric prefix argument, this command
|
|
kills the @var{n} lines below or above the selected one.
|
|
|
|
The @kbd{t .} (@code{calc-full-trail-vectors}) command is described
|
|
elsewhere; @pxref{Vector and Matrix Formats}.
|
|
|
|
@node Keep Arguments, , Trail Commands, Stack and Trail
|
|
@section Keep Arguments
|
|
|
|
@noindent
|
|
@kindex K
|
|
@pindex calc-keep-args
|
|
The @kbd{K} (@code{calc-keep-args}) command acts like a prefix for
|
|
the following command. It prevents that command from removing its
|
|
arguments from the stack. For example, after @kbd{2 @key{RET} 3 +},
|
|
the stack contains the sole number 5, but after @kbd{2 @key{RET} 3 K +},
|
|
the stack contains the arguments and the result: @samp{2 3 5}.
|
|
|
|
With the exception of keyboard macros, this works for all commands that
|
|
take arguments off the stack. (To avoid potentially unpleasant behavior,
|
|
a @kbd{K} prefix before a keyboard macro will be ignored. A @kbd{K}
|
|
prefix called @emph{within} the keyboard macro will still take effect.)
|
|
As another example, @kbd{K a s} simplifies a formula, pushing the
|
|
simplified version of the formula onto the stack after the original
|
|
formula (rather than replacing the original formula). Note that you
|
|
could get the same effect by typing @kbd{@key{RET} a s}, copying the
|
|
formula and then simplifying the copy. One difference is that for a very
|
|
large formula the time taken to format the intermediate copy in
|
|
@kbd{@key{RET} a s} could be noticeable; @kbd{K a s} would avoid this
|
|
extra work.
|
|
|
|
Even stack manipulation commands are affected. @key{TAB} works by
|
|
popping two values and pushing them back in the opposite order,
|
|
so @kbd{2 @key{RET} 3 K @key{TAB}} produces @samp{2 3 3 2}.
|
|
|
|
A few Calc commands provide other ways of doing the same thing.
|
|
For example, @kbd{' sin($)} replaces the number on the stack with
|
|
its sine using algebraic entry; to push the sine and keep the
|
|
original argument you could use either @kbd{' sin($1)} or
|
|
@kbd{K ' sin($)}. @xref{Algebraic Entry}. Also, the @kbd{s s}
|
|
command is effectively the same as @kbd{K s t}. @xref{Storing Variables}.
|
|
|
|
If you execute a command and then decide you really wanted to keep
|
|
the argument, you can press @kbd{M-@key{RET}} (@code{calc-last-args}).
|
|
This command pushes the last arguments that were popped by any command
|
|
onto the stack. Note that the order of things on the stack will be
|
|
different than with @kbd{K}: @kbd{2 @key{RET} 3 + M-@key{RET}} leaves
|
|
@samp{5 2 3} on the stack instead of @samp{2 3 5}. @xref{Undo}.
|
|
|
|
@node Mode Settings, Arithmetic, Stack and Trail, Top
|
|
@chapter Mode Settings
|
|
|
|
@noindent
|
|
This chapter describes commands that set modes in the Calculator.
|
|
They do not affect the contents of the stack, although they may change
|
|
the @emph{appearance} or @emph{interpretation} of the stack's contents.
|
|
|
|
@menu
|
|
* General Mode Commands::
|
|
* Precision::
|
|
* Inverse and Hyperbolic::
|
|
* Calculation Modes::
|
|
* Simplification Modes::
|
|
* Declarations::
|
|
* Display Modes::
|
|
* Language Modes::
|
|
* Modes Variable::
|
|
* Calc Mode Line::
|
|
@end menu
|
|
|
|
@node General Mode Commands, Precision, Mode Settings, Mode Settings
|
|
@section General Mode Commands
|
|
|
|
@noindent
|
|
@kindex m m
|
|
@pindex calc-save-modes
|
|
@cindex Continuous memory
|
|
@cindex Saving mode settings
|
|
@cindex Permanent mode settings
|
|
@cindex Calc init file, mode settings
|
|
You can save all of the current mode settings in your Calc init file
|
|
(the file given by the variable @code{calc-settings-file}, typically
|
|
@file{~/.calc.el}) with the @kbd{m m} (@code{calc-save-modes}) command.
|
|
This will cause Emacs to reestablish these modes each time it starts up.
|
|
The modes saved in the file include everything controlled by the @kbd{m}
|
|
and @kbd{d} prefix keys, the current precision and binary word size,
|
|
whether or not the trail is displayed, the current height of the Calc
|
|
window, and more. The current interface (used when you type @kbd{C-x * *})
|
|
is also saved. If there were already saved mode settings in the
|
|
file, they are replaced. Otherwise, the new mode information is
|
|
appended to the end of the file.
|
|
|
|
@kindex m R
|
|
@pindex calc-mode-record-mode
|
|
The @kbd{m R} (@code{calc-mode-record-mode}) command tells Calc to
|
|
record all the mode settings (as if by pressing @kbd{m m}) every
|
|
time a mode setting changes. If the modes are saved this way, then this
|
|
``automatic mode recording'' mode is also saved.
|
|
Type @kbd{m R} again to disable this method of recording the mode
|
|
settings. To turn it off permanently, the @kbd{m m} command will also be
|
|
necessary. (If Embedded mode is enabled, other options for recording
|
|
the modes are available; @pxref{Mode Settings in Embedded Mode}.)
|
|
|
|
@kindex m F
|
|
@pindex calc-settings-file-name
|
|
The @kbd{m F} (@code{calc-settings-file-name}) command allows you to
|
|
choose a different file than the current value of @code{calc-settings-file}
|
|
for @kbd{m m}, @kbd{Z P}, and similar commands to save permanent information.
|
|
You are prompted for a file name. All Calc modes are then reset to
|
|
their default values, then settings from the file you named are loaded
|
|
if this file exists, and this file becomes the one that Calc will
|
|
use in the future for commands like @kbd{m m}. The default settings
|
|
file name is @file{~/.calc.el}. You can see the current file name by
|
|
giving a blank response to the @kbd{m F} prompt. See also the
|
|
discussion of the @code{calc-settings-file} variable; @pxref{Customizing Calc}.
|
|
|
|
If the file name you give is your user init file (typically
|
|
@file{~/.emacs}), @kbd{m F} will not automatically load the new file. This
|
|
is because your user init file may contain other things you don't want
|
|
to reread. You can give
|
|
a numeric prefix argument of 1 to @kbd{m F} to force it to read the
|
|
file no matter what. Conversely, an argument of @mathit{-1} tells
|
|
@kbd{m F} @emph{not} to read the new file. An argument of 2 or @mathit{-2}
|
|
tells @kbd{m F} not to reset the modes to their defaults beforehand,
|
|
which is useful if you intend your new file to have a variant of the
|
|
modes present in the file you were using before.
|
|
|
|
@kindex m x
|
|
@pindex calc-always-load-extensions
|
|
The @kbd{m x} (@code{calc-always-load-extensions}) command enables a mode
|
|
in which the first use of Calc loads the entire program, including all
|
|
extensions modules. Otherwise, the extensions modules will not be loaded
|
|
until the various advanced Calc features are used. Since this mode only
|
|
has effect when Calc is first loaded, @kbd{m x} is usually followed by
|
|
@kbd{m m} to make the mode-setting permanent. To load all of Calc just
|
|
once, rather than always in the future, you can press @kbd{C-x * L}.
|
|
|
|
@kindex m S
|
|
@pindex calc-shift-prefix
|
|
The @kbd{m S} (@code{calc-shift-prefix}) command enables a mode in which
|
|
all of Calc's letter prefix keys may be typed shifted as well as unshifted.
|
|
If you are typing, say, @kbd{a S} (@code{calc-solve-for}) quite often
|
|
you might find it easier to turn this mode on so that you can type
|
|
@kbd{A S} instead. When this mode is enabled, the commands that used to
|
|
be on those single shifted letters (e.g., @kbd{A} (@code{calc-abs})) can
|
|
now be invoked by pressing the shifted letter twice: @kbd{A A}. Note
|
|
that the @kbd{v} prefix key always works both shifted and unshifted, and
|
|
the @kbd{z} and @kbd{Z} prefix keys are always distinct. Also, the @kbd{h}
|
|
prefix is not affected by this mode. Press @kbd{m S} again to disable
|
|
shifted-prefix mode.
|
|
|
|
@node Precision, Inverse and Hyperbolic, General Mode Commands, Mode Settings
|
|
@section Precision
|
|
|
|
@noindent
|
|
@kindex p
|
|
@pindex calc-precision
|
|
@cindex Precision of calculations
|
|
The @kbd{p} (@code{calc-precision}) command controls the precision to
|
|
which floating-point calculations are carried. The precision must be
|
|
at least 3 digits and may be arbitrarily high, within the limits of
|
|
memory and time. This affects only floats: Integer and rational
|
|
calculations are always carried out with as many digits as necessary.
|
|
|
|
The @kbd{p} key prompts for the current precision. If you wish you
|
|
can instead give the precision as a numeric prefix argument.
|
|
|
|
Many internal calculations are carried to one or two digits higher
|
|
precision than normal. Results are rounded down afterward to the
|
|
current precision. Unless a special display mode has been selected,
|
|
floats are always displayed with their full stored precision, i.e.,
|
|
what you see is what you get. Reducing the current precision does not
|
|
round values already on the stack, but those values will be rounded
|
|
down before being used in any calculation. The @kbd{c 0} through
|
|
@kbd{c 9} commands (@pxref{Conversions}) can be used to round an
|
|
existing value to a new precision.
|
|
|
|
@cindex Accuracy of calculations
|
|
It is important to distinguish the concepts of @dfn{precision} and
|
|
@dfn{accuracy}. In the normal usage of these words, the number
|
|
123.4567 has a precision of 7 digits but an accuracy of 4 digits.
|
|
The precision is the total number of digits not counting leading
|
|
or trailing zeros (regardless of the position of the decimal point).
|
|
The accuracy is simply the number of digits after the decimal point
|
|
(again not counting trailing zeros). In Calc you control the precision,
|
|
not the accuracy of computations. If you were to set the accuracy
|
|
instead, then calculations like @samp{exp(100)} would generate many
|
|
more digits than you would typically need, while @samp{exp(-100)} would
|
|
probably round to zero! In Calc, both these computations give you
|
|
exactly 12 (or the requested number of) significant digits.
|
|
|
|
The only Calc features that deal with accuracy instead of precision
|
|
are fixed-point display mode for floats (@kbd{d f}; @pxref{Float Formats}),
|
|
and the rounding functions like @code{floor} and @code{round}
|
|
(@pxref{Integer Truncation}). Also, @kbd{c 0} through @kbd{c 9}
|
|
deal with both precision and accuracy depending on the magnitudes
|
|
of the numbers involved.
|
|
|
|
If you need to work with a particular fixed accuracy (say, dollars and
|
|
cents with two digits after the decimal point), one solution is to work
|
|
with integers and an ``implied'' decimal point. For example, $8.99
|
|
divided by 6 would be entered @kbd{899 @key{RET} 6 /}, yielding 149.833
|
|
(actually $1.49833 with our implied decimal point); pressing @kbd{R}
|
|
would round this to 150 cents, i.e., $1.50.
|
|
|
|
@xref{Floats}, for still more on floating-point precision and related
|
|
issues.
|
|
|
|
@node Inverse and Hyperbolic, Calculation Modes, Precision, Mode Settings
|
|
@section Inverse and Hyperbolic Flags
|
|
|
|
@noindent
|
|
@kindex I
|
|
@pindex calc-inverse
|
|
There is no single-key equivalent to the @code{calc-arcsin} function.
|
|
Instead, you must first press @kbd{I} (@code{calc-inverse}) to set
|
|
the @dfn{Inverse Flag}, then press @kbd{S} (@code{calc-sin}).
|
|
The @kbd{I} key actually toggles the Inverse Flag. When this flag
|
|
is set, the word @samp{Inv} appears in the mode line.
|
|
|
|
@kindex H
|
|
@pindex calc-hyperbolic
|
|
Likewise, the @kbd{H} key (@code{calc-hyperbolic}) sets or clears the
|
|
Hyperbolic Flag, which transforms @code{calc-sin} into @code{calc-sinh}.
|
|
If both of these flags are set at once, the effect will be
|
|
@code{calc-arcsinh}. (The Hyperbolic flag is also used by some
|
|
non-trigonometric commands; for example @kbd{H L} computes a base-10,
|
|
instead of base-@mathit{e}, logarithm.)
|
|
|
|
Command names like @code{calc-arcsin} are provided for completeness, and
|
|
may be executed with @kbd{x} or @kbd{M-x}. Their effect is simply to
|
|
toggle the Inverse and/or Hyperbolic flags and then execute the
|
|
corresponding base command (@code{calc-sin} in this case).
|
|
|
|
The Inverse and Hyperbolic flags apply only to the next Calculator
|
|
command, after which they are automatically cleared. (They are also
|
|
cleared if the next keystroke is not a Calc command.) Digits you
|
|
type after @kbd{I} or @kbd{H} (or @kbd{K}) are treated as prefix
|
|
arguments for the next command, not as numeric entries. The same
|
|
is true of @kbd{C-u}, but not of the minus sign (@kbd{K -} means to
|
|
subtract and keep arguments).
|
|
|
|
The third Calc prefix flag, @kbd{K} (keep-arguments), is discussed
|
|
elsewhere. @xref{Keep Arguments}.
|
|
|
|
@node Calculation Modes, Simplification Modes, Inverse and Hyperbolic, Mode Settings
|
|
@section Calculation Modes
|
|
|
|
@noindent
|
|
The commands in this section are two-key sequences beginning with
|
|
the @kbd{m} prefix. (That's the letter @kbd{m}, not the @key{META} key.)
|
|
The @samp{m a} (@code{calc-algebraic-mode}) command is described elsewhere
|
|
(@pxref{Algebraic Entry}).
|
|
|
|
@menu
|
|
* Angular Modes::
|
|
* Polar Mode::
|
|
* Fraction Mode::
|
|
* Infinite Mode::
|
|
* Symbolic Mode::
|
|
* Matrix Mode::
|
|
* Automatic Recomputation::
|
|
* Working Message::
|
|
@end menu
|
|
|
|
@node Angular Modes, Polar Mode, Calculation Modes, Calculation Modes
|
|
@subsection Angular Modes
|
|
|
|
@noindent
|
|
@cindex Angular mode
|
|
The Calculator supports three notations for angles: radians, degrees,
|
|
and degrees-minutes-seconds. When a number is presented to a function
|
|
like @code{sin} that requires an angle, the current angular mode is
|
|
used to interpret the number as either radians or degrees. If an HMS
|
|
form is presented to @code{sin}, it is always interpreted as
|
|
degrees-minutes-seconds.
|
|
|
|
Functions that compute angles produce a number in radians, a number in
|
|
degrees, or an HMS form depending on the current angular mode. If the
|
|
result is a complex number and the current mode is HMS, the number is
|
|
instead expressed in degrees. (Complex-number calculations would
|
|
normally be done in Radians mode, though. Complex numbers are converted
|
|
to degrees by calculating the complex result in radians and then
|
|
multiplying by 180 over @cpi{}.)
|
|
|
|
@kindex m r
|
|
@pindex calc-radians-mode
|
|
@kindex m d
|
|
@pindex calc-degrees-mode
|
|
@kindex m h
|
|
@pindex calc-hms-mode
|
|
The @kbd{m r} (@code{calc-radians-mode}), @kbd{m d} (@code{calc-degrees-mode}),
|
|
and @kbd{m h} (@code{calc-hms-mode}) commands control the angular mode.
|
|
The current angular mode is displayed on the Emacs mode line.
|
|
The default angular mode is Degrees.
|
|
|
|
@node Polar Mode, Fraction Mode, Angular Modes, Calculation Modes
|
|
@subsection Polar Mode
|
|
|
|
@noindent
|
|
@cindex Polar mode
|
|
The Calculator normally ``prefers'' rectangular complex numbers in the
|
|
sense that rectangular form is used when the proper form can not be
|
|
decided from the input. This might happen by multiplying a rectangular
|
|
number by a polar one, by taking the square root of a negative real
|
|
number, or by entering @kbd{( 2 @key{SPC} 3 )}.
|
|
|
|
@kindex m p
|
|
@pindex calc-polar-mode
|
|
The @kbd{m p} (@code{calc-polar-mode}) command toggles complex-number
|
|
preference between rectangular and polar forms. In Polar mode, all
|
|
of the above example situations would produce polar complex numbers.
|
|
|
|
@node Fraction Mode, Infinite Mode, Polar Mode, Calculation Modes
|
|
@subsection Fraction Mode
|
|
|
|
@noindent
|
|
@cindex Fraction mode
|
|
@cindex Division of integers
|
|
Division of two integers normally yields a floating-point number if the
|
|
result cannot be expressed as an integer. In some cases you would
|
|
rather get an exact fractional answer. One way to accomplish this is
|
|
to use the @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command, which
|
|
divides the two integers on the top of the stack to produce a fraction:
|
|
@kbd{6 @key{RET} 4 :} produces @expr{3:2} even though
|
|
@kbd{6 @key{RET} 4 /} produces @expr{1.5}.
|
|
|
|
@kindex m f
|
|
@pindex calc-frac-mode
|
|
To set the Calculator to produce fractional results for normal integer
|
|
divisions, use the @kbd{m f} (@code{calc-frac-mode}) command.
|
|
For example, @expr{8/4} produces @expr{2} in either mode,
|
|
but @expr{6/4} produces @expr{3:2} in Fraction mode, @expr{1.5} in
|
|
Float mode.
|
|
|
|
At any time you can use @kbd{c f} (@code{calc-float}) to convert a
|
|
fraction to a float, or @kbd{c F} (@code{calc-fraction}) to convert a
|
|
float to a fraction. @xref{Conversions}.
|
|
|
|
@node Infinite Mode, Symbolic Mode, Fraction Mode, Calculation Modes
|
|
@subsection Infinite Mode
|
|
|
|
@noindent
|
|
@cindex Infinite mode
|
|
The Calculator normally treats results like @expr{1 / 0} as errors;
|
|
formulas like this are left in unsimplified form. But Calc can be
|
|
put into a mode where such calculations instead produce ``infinite''
|
|
results.
|
|
|
|
@kindex m i
|
|
@pindex calc-infinite-mode
|
|
The @kbd{m i} (@code{calc-infinite-mode}) command turns this mode
|
|
on and off. When the mode is off, infinities do not arise except
|
|
in calculations that already had infinities as inputs. (One exception
|
|
is that infinite open intervals like @samp{[0 .. inf)} can be
|
|
generated; however, intervals closed at infinity (@samp{[0 .. inf]})
|
|
will not be generated when Infinite mode is off.)
|
|
|
|
With Infinite mode turned on, @samp{1 / 0} will generate @code{uinf},
|
|
an undirected infinity. @xref{Infinities}, for a discussion of the
|
|
difference between @code{inf} and @code{uinf}. Also, @expr{0 / 0}
|
|
evaluates to @code{nan}, the ``indeterminate'' symbol. Various other
|
|
functions can also return infinities in this mode; for example,
|
|
@samp{ln(0) = -inf}, and @samp{gamma(-7) = uinf}. Once again,
|
|
note that @samp{exp(inf) = inf} regardless of Infinite mode because
|
|
this calculation has infinity as an input.
|
|
|
|
@cindex Positive Infinite mode
|
|
The @kbd{m i} command with a numeric prefix argument of zero,
|
|
i.e., @kbd{C-u 0 m i}, turns on a Positive Infinite mode in
|
|
which zero is treated as positive instead of being directionless.
|
|
Thus, @samp{1 / 0 = inf} and @samp{-1 / 0 = -inf} in this mode.
|
|
Note that zero never actually has a sign in Calc; there are no
|
|
separate representations for @mathit{+0} and @mathit{-0}. Positive
|
|
Infinite mode merely changes the interpretation given to the
|
|
single symbol, @samp{0}. One consequence of this is that, while
|
|
you might expect @samp{1 / -0 = -inf}, actually @samp{1 / -0}
|
|
is equivalent to @samp{1 / 0}, which is equal to positive @code{inf}.
|
|
|
|
@node Symbolic Mode, Matrix Mode, Infinite Mode, Calculation Modes
|
|
@subsection Symbolic Mode
|
|
|
|
@noindent
|
|
@cindex Symbolic mode
|
|
@cindex Inexact results
|
|
Calculations are normally performed numerically wherever possible.
|
|
For example, the @code{calc-sqrt} command, or @code{sqrt} function in an
|
|
algebraic expression, produces a numeric answer if the argument is a
|
|
number or a symbolic expression if the argument is an expression:
|
|
@kbd{2 Q} pushes 1.4142 but @kbd{@key{'} x+1 @key{RET} Q} pushes @samp{sqrt(x+1)}.
|
|
|
|
@kindex m s
|
|
@pindex calc-symbolic-mode
|
|
In @dfn{Symbolic mode}, controlled by the @kbd{m s} (@code{calc-symbolic-mode})
|
|
command, functions which would produce inexact, irrational results are
|
|
left in symbolic form. Thus @kbd{16 Q} pushes 4, but @kbd{2 Q} pushes
|
|
@samp{sqrt(2)}.
|
|
|
|
@kindex N
|
|
@pindex calc-eval-num
|
|
The shift-@kbd{N} (@code{calc-eval-num}) command evaluates numerically
|
|
the expression at the top of the stack, by temporarily disabling
|
|
@code{calc-symbolic-mode} and executing @kbd{=} (@code{calc-evaluate}).
|
|
Given a numeric prefix argument, it also
|
|
sets the floating-point precision to the specified value for the duration
|
|
of the command.
|
|
|
|
To evaluate a formula numerically without expanding the variables it
|
|
contains, you can use the key sequence @kbd{m s a v m s} (this uses
|
|
@code{calc-alg-evaluate}, which resimplifies but doesn't evaluate
|
|
variables.)
|
|
|
|
@node Matrix Mode, Automatic Recomputation, Symbolic Mode, Calculation Modes
|
|
@subsection Matrix and Scalar Modes
|
|
|
|
@noindent
|
|
@cindex Matrix mode
|
|
@cindex Scalar mode
|
|
Calc sometimes makes assumptions during algebraic manipulation that
|
|
are awkward or incorrect when vectors and matrices are involved.
|
|
Calc has two modes, @dfn{Matrix mode} and @dfn{Scalar mode}, which
|
|
modify its behavior around vectors in useful ways.
|
|
|
|
@kindex m v
|
|
@pindex calc-matrix-mode
|
|
Press @kbd{m v} (@code{calc-matrix-mode}) once to enter Matrix mode.
|
|
In this mode, all objects are assumed to be matrices unless provably
|
|
otherwise. One major effect is that Calc will no longer consider
|
|
multiplication to be commutative. (Recall that in matrix arithmetic,
|
|
@samp{A*B} is not the same as @samp{B*A}.) This assumption affects
|
|
rewrite rules and algebraic simplification. Another effect of this
|
|
mode is that calculations that would normally produce constants like
|
|
0 and 1 (e.g., @expr{a - a} and @expr{a / a}, respectively) will now
|
|
produce function calls that represent ``generic'' zero or identity
|
|
matrices: @samp{idn(0)}, @samp{idn(1)}. The @code{idn} function
|
|
@samp{idn(@var{a},@var{n})} returns @var{a} times an @var{n}x@var{n}
|
|
identity matrix; if @var{n} is omitted, it doesn't know what
|
|
dimension to use and so the @code{idn} call remains in symbolic
|
|
form. However, if this generic identity matrix is later combined
|
|
with a matrix whose size is known, it will be converted into
|
|
a true identity matrix of the appropriate size. On the other hand,
|
|
if it is combined with a scalar (as in @samp{idn(1) + 2}), Calc
|
|
will assume it really was a scalar after all and produce, e.g., 3.
|
|
|
|
Press @kbd{m v} a second time to get Scalar mode. Here, objects are
|
|
assumed @emph{not} to be vectors or matrices unless provably so.
|
|
For example, normally adding a variable to a vector, as in
|
|
@samp{[x, y, z] + a}, will leave the sum in symbolic form because
|
|
as far as Calc knows, @samp{a} could represent either a number or
|
|
another 3-vector. In Scalar mode, @samp{a} is assumed to be a
|
|
non-vector, and the addition is evaluated to @samp{[x+a, y+a, z+a]}.
|
|
|
|
Press @kbd{m v} a third time to return to the normal mode of operation.
|
|
|
|
If you press @kbd{m v} with a numeric prefix argument @var{n}, you
|
|
get a special ``dimensioned'' Matrix mode in which matrices of
|
|
unknown size are assumed to be @var{n}x@var{n} square matrices.
|
|
Then, the function call @samp{idn(1)} will expand into an actual
|
|
matrix rather than representing a ``generic'' matrix. Simply typing
|
|
@kbd{C-u m v} will get you a square Matrix mode, in which matrices of
|
|
unknown size are assumed to be square matrices of unspecified size.
|
|
|
|
@cindex Declaring scalar variables
|
|
Of course these modes are approximations to the true state of
|
|
affairs, which is probably that some quantities will be matrices
|
|
and others will be scalars. One solution is to ``declare''
|
|
certain variables or functions to be scalar-valued.
|
|
@xref{Declarations}, to see how to make declarations in Calc.
|
|
|
|
There is nothing stopping you from declaring a variable to be
|
|
scalar and then storing a matrix in it; however, if you do, the
|
|
results you get from Calc may not be valid. Suppose you let Calc
|
|
get the result @samp{[x+a, y+a, z+a]} shown above, and then stored
|
|
@samp{[1, 2, 3]} in @samp{a}. The result would not be the same as
|
|
for @samp{[x, y, z] + [1, 2, 3]}, but that's because you have broken
|
|
your earlier promise to Calc that @samp{a} would be scalar.
|
|
|
|
Another way to mix scalars and matrices is to use selections
|
|
(@pxref{Selecting Subformulas}). Use Matrix mode when operating on
|
|
your formula normally; then, to apply Scalar mode to a certain part
|
|
of the formula without affecting the rest just select that part,
|
|
change into Scalar mode and press @kbd{=} to resimplify the part
|
|
under this mode, then change back to Matrix mode before deselecting.
|
|
|
|
@node Automatic Recomputation, Working Message, Matrix Mode, Calculation Modes
|
|
@subsection Automatic Recomputation
|
|
|
|
@noindent
|
|
The @dfn{evaluates-to} operator, @samp{=>}, has the special
|
|
property that any @samp{=>} formulas on the stack are recomputed
|
|
whenever variable values or mode settings that might affect them
|
|
are changed. @xref{Evaluates-To Operator}.
|
|
|
|
@kindex m C
|
|
@pindex calc-auto-recompute
|
|
The @kbd{m C} (@code{calc-auto-recompute}) command turns this
|
|
automatic recomputation on and off. If you turn it off, Calc will
|
|
not update @samp{=>} operators on the stack (nor those in the
|
|
attached Embedded mode buffer, if there is one). They will not
|
|
be updated unless you explicitly do so by pressing @kbd{=} or until
|
|
you press @kbd{m C} to turn recomputation back on. (While automatic
|
|
recomputation is off, you can think of @kbd{m C m C} as a command
|
|
to update all @samp{=>} operators while leaving recomputation off.)
|
|
|
|
To update @samp{=>} operators in an Embedded buffer while
|
|
automatic recomputation is off, use @w{@kbd{C-x * u}}.
|
|
@xref{Embedded Mode}.
|
|
|
|
@node Working Message, , Automatic Recomputation, Calculation Modes
|
|
@subsection Working Messages
|
|
|
|
@noindent
|
|
@cindex Performance
|
|
@cindex Working messages
|
|
Since the Calculator is written entirely in Emacs Lisp, which is not
|
|
designed for heavy numerical work, many operations are quite slow.
|
|
The Calculator normally displays the message @samp{Working...} in the
|
|
echo area during any command that may be slow. In addition, iterative
|
|
operations such as square roots and trigonometric functions display the
|
|
intermediate result at each step. Both of these types of messages can
|
|
be disabled if you find them distracting.
|
|
|
|
@kindex m w
|
|
@pindex calc-working
|
|
Type @kbd{m w} (@code{calc-working}) with a numeric prefix of 0 to
|
|
disable all ``working'' messages. Use a numeric prefix of 1 to enable
|
|
only the plain @samp{Working...} message. Use a numeric prefix of 2 to
|
|
see intermediate results as well. With no numeric prefix this displays
|
|
the current mode.
|
|
|
|
While it may seem that the ``working'' messages will slow Calc down
|
|
considerably, experiments have shown that their impact is actually
|
|
quite small. But if your terminal is slow you may find that it helps
|
|
to turn the messages off.
|
|
|
|
@node Simplification Modes, Declarations, Calculation Modes, Mode Settings
|
|
@section Simplification Modes
|
|
|
|
@noindent
|
|
The current @dfn{simplification mode} controls how numbers and formulas
|
|
are ``normalized'' when being taken from or pushed onto the stack.
|
|
Some normalizations are unavoidable, such as rounding floating-point
|
|
results to the current precision, and reducing fractions to simplest
|
|
form. Others, such as simplifying a formula like @expr{a+a} (or @expr{2+3}),
|
|
are done by default but can be turned off when necessary.
|
|
|
|
When you press a key like @kbd{+} when @expr{2} and @expr{3} are on the
|
|
stack, Calc pops these numbers, normalizes them, creates the formula
|
|
@expr{2+3}, normalizes it, and pushes the result. Of course the standard
|
|
rules for normalizing @expr{2+3} will produce the result @expr{5}.
|
|
|
|
Simplification mode commands consist of the lower-case @kbd{m} prefix key
|
|
followed by a shifted letter.
|
|
|
|
@kindex m O
|
|
@pindex calc-no-simplify-mode
|
|
The @kbd{m O} (@code{calc-no-simplify-mode}) command turns off all optional
|
|
simplifications. These would leave a formula like @expr{2+3} alone. In
|
|
fact, nothing except simple numbers are ever affected by normalization
|
|
in this mode.
|
|
|
|
@kindex m N
|
|
@pindex calc-num-simplify-mode
|
|
The @kbd{m N} (@code{calc-num-simplify-mode}) command turns off simplification
|
|
of any formulas except those for which all arguments are constants. For
|
|
example, @expr{1+2} is simplified to @expr{3}, and @expr{a+(2-2)} is
|
|
simplified to @expr{a+0} but no further, since one argument of the sum
|
|
is not a constant. Unfortunately, @expr{(a+2)-2} is @emph{not} simplified
|
|
because the top-level @samp{-} operator's arguments are not both
|
|
constant numbers (one of them is the formula @expr{a+2}).
|
|
A constant is a number or other numeric object (such as a constant
|
|
error form or modulo form), or a vector all of whose
|
|
elements are constant.
|
|
|
|
@kindex m D
|
|
@pindex calc-default-simplify-mode
|
|
The @kbd{m D} (@code{calc-default-simplify-mode}) command restores the
|
|
default simplifications for all formulas. This includes many easy and
|
|
fast algebraic simplifications such as @expr{a+0} to @expr{a}, and
|
|
@expr{a + 2 a} to @expr{3 a}, as well as evaluating functions like
|
|
@expr{@tfn{deriv}(x^2, x)} to @expr{2 x}.
|
|
|
|
@kindex m B
|
|
@pindex calc-bin-simplify-mode
|
|
The @kbd{m B} (@code{calc-bin-simplify-mode}) mode applies the default
|
|
simplifications to a result and then, if the result is an integer,
|
|
uses the @kbd{b c} (@code{calc-clip}) command to clip the integer according
|
|
to the current binary word size. @xref{Binary Functions}. Real numbers
|
|
are rounded to the nearest integer and then clipped; other kinds of
|
|
results (after the default simplifications) are left alone.
|
|
|
|
@kindex m A
|
|
@pindex calc-alg-simplify-mode
|
|
The @kbd{m A} (@code{calc-alg-simplify-mode}) mode does algebraic
|
|
simplification; it applies all the default simplifications, and also
|
|
the more powerful (and slower) simplifications made by @kbd{a s}
|
|
(@code{calc-simplify}). @xref{Algebraic Simplifications}.
|
|
|
|
@kindex m E
|
|
@pindex calc-ext-simplify-mode
|
|
The @kbd{m E} (@code{calc-ext-simplify-mode}) mode does ``extended''
|
|
algebraic simplification, as by the @kbd{a e} (@code{calc-simplify-extended})
|
|
command. @xref{Unsafe Simplifications}.
|
|
|
|
@kindex m U
|
|
@pindex calc-units-simplify-mode
|
|
The @kbd{m U} (@code{calc-units-simplify-mode}) mode does units
|
|
simplification; it applies the command @kbd{u s}
|
|
(@code{calc-simplify-units}), which in turn
|
|
is a superset of @kbd{a s}. In this mode, variable names which
|
|
are identifiable as unit names (like @samp{mm} for ``millimeters'')
|
|
are simplified with their unit definitions in mind.
|
|
|
|
A common technique is to set the simplification mode down to the lowest
|
|
amount of simplification you will allow to be applied automatically, then
|
|
use manual commands like @kbd{a s} and @kbd{c c} (@code{calc-clean}) to
|
|
perform higher types of simplifications on demand. @xref{Algebraic
|
|
Definitions}, for another sample use of No-Simplification mode.
|
|
|
|
@node Declarations, Display Modes, Simplification Modes, Mode Settings
|
|
@section Declarations
|
|
|
|
@noindent
|
|
A @dfn{declaration} is a statement you make that promises you will
|
|
use a certain variable or function in a restricted way. This may
|
|
give Calc the freedom to do things that it couldn't do if it had to
|
|
take the fully general situation into account.
|
|
|
|
@menu
|
|
* Declaration Basics::
|
|
* Kinds of Declarations::
|
|
* Functions for Declarations::
|
|
@end menu
|
|
|
|
@node Declaration Basics, Kinds of Declarations, Declarations, Declarations
|
|
@subsection Declaration Basics
|
|
|
|
@noindent
|
|
@kindex s d
|
|
@pindex calc-declare-variable
|
|
The @kbd{s d} (@code{calc-declare-variable}) command is the easiest
|
|
way to make a declaration for a variable. This command prompts for
|
|
the variable name, then prompts for the declaration. The default
|
|
at the declaration prompt is the previous declaration, if any.
|
|
You can edit this declaration, or press @kbd{C-k} to erase it and
|
|
type a new declaration. (Or, erase it and press @key{RET} to clear
|
|
the declaration, effectively ``undeclaring'' the variable.)
|
|
|
|
A declaration is in general a vector of @dfn{type symbols} and
|
|
@dfn{range} values. If there is only one type symbol or range value,
|
|
you can write it directly rather than enclosing it in a vector.
|
|
For example, @kbd{s d foo @key{RET} real @key{RET}} declares @code{foo} to
|
|
be a real number, and @kbd{s d bar @key{RET} [int, const, [1..6]] @key{RET}}
|
|
declares @code{bar} to be a constant integer between 1 and 6.
|
|
(Actually, you can omit the outermost brackets and Calc will
|
|
provide them for you: @kbd{s d bar @key{RET} int, const, [1..6] @key{RET}}.)
|
|
|
|
@cindex @code{Decls} variable
|
|
@vindex Decls
|
|
Declarations in Calc are kept in a special variable called @code{Decls}.
|
|
This variable encodes the set of all outstanding declarations in
|
|
the form of a matrix. Each row has two elements: A variable or
|
|
vector of variables declared by that row, and the declaration
|
|
specifier as described above. You can use the @kbd{s D} command to
|
|
edit this variable if you wish to see all the declarations at once.
|
|
@xref{Operations on Variables}, for a description of this command
|
|
and the @kbd{s p} command that allows you to save your declarations
|
|
permanently if you wish.
|
|
|
|
Items being declared can also be function calls. The arguments in
|
|
the call are ignored; the effect is to say that this function returns
|
|
values of the declared type for any valid arguments. The @kbd{s d}
|
|
command declares only variables, so if you wish to make a function
|
|
declaration you will have to edit the @code{Decls} matrix yourself.
|
|
|
|
For example, the declaration matrix
|
|
|
|
@smallexample
|
|
@group
|
|
[ [ foo, real ]
|
|
[ [j, k, n], int ]
|
|
[ f(1,2,3), [0 .. inf) ] ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
declares that @code{foo} represents a real number, @code{j}, @code{k}
|
|
and @code{n} represent integers, and the function @code{f} always
|
|
returns a real number in the interval shown.
|
|
|
|
@vindex All
|
|
If there is a declaration for the variable @code{All}, then that
|
|
declaration applies to all variables that are not otherwise declared.
|
|
It does not apply to function names. For example, using the row
|
|
@samp{[All, real]} says that all your variables are real unless they
|
|
are explicitly declared without @code{real} in some other row.
|
|
The @kbd{s d} command declares @code{All} if you give a blank
|
|
response to the variable-name prompt.
|
|
|
|
@node Kinds of Declarations, Functions for Declarations, Declaration Basics, Declarations
|
|
@subsection Kinds of Declarations
|
|
|
|
@noindent
|
|
The type-specifier part of a declaration (that is, the second prompt
|
|
in the @kbd{s d} command) can be a type symbol, an interval, or a
|
|
vector consisting of zero or more type symbols followed by zero or
|
|
more intervals or numbers that represent the set of possible values
|
|
for the variable.
|
|
|
|
@smallexample
|
|
@group
|
|
[ [ a, [1, 2, 3, 4, 5] ]
|
|
[ b, [1 .. 5] ]
|
|
[ c, [int, 1 .. 5] ] ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
Here @code{a} is declared to contain one of the five integers shown;
|
|
@code{b} is any number in the interval from 1 to 5 (any real number
|
|
since we haven't specified), and @code{c} is any integer in that
|
|
interval. Thus the declarations for @code{a} and @code{c} are
|
|
nearly equivalent (see below).
|
|
|
|
The type-specifier can be the empty vector @samp{[]} to say that
|
|
nothing is known about a given variable's value. This is the same
|
|
as not declaring the variable at all except that it overrides any
|
|
@code{All} declaration which would otherwise apply.
|
|
|
|
The initial value of @code{Decls} is the empty vector @samp{[]}.
|
|
If @code{Decls} has no stored value or if the value stored in it
|
|
is not valid, it is ignored and there are no declarations as far
|
|
as Calc is concerned. (The @kbd{s d} command will replace such a
|
|
malformed value with a fresh empty matrix, @samp{[]}, before recording
|
|
the new declaration.) Unrecognized type symbols are ignored.
|
|
|
|
The following type symbols describe what sorts of numbers will be
|
|
stored in a variable:
|
|
|
|
@table @code
|
|
@item int
|
|
Integers.
|
|
@item numint
|
|
Numerical integers. (Integers or integer-valued floats.)
|
|
@item frac
|
|
Fractions. (Rational numbers which are not integers.)
|
|
@item rat
|
|
Rational numbers. (Either integers or fractions.)
|
|
@item float
|
|
Floating-point numbers.
|
|
@item real
|
|
Real numbers. (Integers, fractions, or floats. Actually,
|
|
intervals and error forms with real components also count as
|
|
reals here.)
|
|
@item pos
|
|
Positive real numbers. (Strictly greater than zero.)
|
|
@item nonneg
|
|
Nonnegative real numbers. (Greater than or equal to zero.)
|
|
@item number
|
|
Numbers. (Real or complex.)
|
|
@end table
|
|
|
|
Calc uses this information to determine when certain simplifications
|
|
of formulas are safe. For example, @samp{(x^y)^z} cannot be
|
|
simplified to @samp{x^(y z)} in general; for example,
|
|
@samp{((-3)^2)^1:2} is 3, but @samp{(-3)^(2*1:2) = (-3)^1} is @mathit{-3}.
|
|
However, this simplification @emph{is} safe if @code{z} is known
|
|
to be an integer, or if @code{x} is known to be a nonnegative
|
|
real number. If you have given declarations that allow Calc to
|
|
deduce either of these facts, Calc will perform this simplification
|
|
of the formula.
|
|
|
|
Calc can apply a certain amount of logic when using declarations.
|
|
For example, @samp{(x^y)^(2n+1)} will be simplified if @code{n}
|
|
has been declared @code{int}; Calc knows that an integer times an
|
|
integer, plus an integer, must always be an integer. (In fact,
|
|
Calc would simplify @samp{(-x)^(2n+1)} to @samp{-(x^(2n+1))} since
|
|
it is able to determine that @samp{2n+1} must be an odd integer.)
|
|
|
|
Similarly, @samp{(abs(x)^y)^z} will be simplified to @samp{abs(x)^(y z)}
|
|
because Calc knows that the @code{abs} function always returns a
|
|
nonnegative real. If you had a @code{myabs} function that also had
|
|
this property, you could get Calc to recognize it by adding the row
|
|
@samp{[myabs(), nonneg]} to the @code{Decls} matrix.
|
|
|
|
One instance of this simplification is @samp{sqrt(x^2)} (since the
|
|
@code{sqrt} function is effectively a one-half power). Normally
|
|
Calc leaves this formula alone. After the command
|
|
@kbd{s d x @key{RET} real @key{RET}}, however, it can simplify the formula to
|
|
@samp{abs(x)}. And after @kbd{s d x @key{RET} nonneg @key{RET}}, Calc can
|
|
simplify this formula all the way to @samp{x}.
|
|
|
|
If there are any intervals or real numbers in the type specifier,
|
|
they comprise the set of possible values that the variable or
|
|
function being declared can have. In particular, the type symbol
|
|
@code{real} is effectively the same as the range @samp{[-inf .. inf]}
|
|
(note that infinity is included in the range of possible values);
|
|
@code{pos} is the same as @samp{(0 .. inf]}, and @code{nonneg} is
|
|
the same as @samp{[0 .. inf]}. Saying @samp{[real, [-5 .. 5]]} is
|
|
redundant because the fact that the variable is real can be
|
|
deduced just from the interval, but @samp{[int, [-5 .. 5]]} and
|
|
@samp{[rat, [-5 .. 5]]} are useful combinations.
|
|
|
|
Note that the vector of intervals or numbers is in the same format
|
|
used by Calc's set-manipulation commands. @xref{Set Operations}.
|
|
|
|
The type specifier @samp{[1, 2, 3]} is equivalent to
|
|
@samp{[numint, 1, 2, 3]}, @emph{not} to @samp{[int, 1, 2, 3]}.
|
|
In other words, the range of possible values means only that
|
|
the variable's value must be numerically equal to a number in
|
|
that range, but not that it must be equal in type as well.
|
|
Calc's set operations act the same way; @samp{in(2, [1., 2., 3.])}
|
|
and @samp{in(1.5, [1:2, 3:2, 5:2])} both report ``true.''
|
|
|
|
If you use a conflicting combination of type specifiers, the
|
|
results are unpredictable. An example is @samp{[pos, [0 .. 5]]},
|
|
where the interval does not lie in the range described by the
|
|
type symbol.
|
|
|
|
``Real'' declarations mostly affect simplifications involving powers
|
|
like the one described above. Another case where they are used
|
|
is in the @kbd{a P} command which returns a list of all roots of a
|
|
polynomial; if the variable has been declared real, only the real
|
|
roots (if any) will be included in the list.
|
|
|
|
``Integer'' declarations are used for simplifications which are valid
|
|
only when certain values are integers (such as @samp{(x^y)^z}
|
|
shown above).
|
|
|
|
Another command that makes use of declarations is @kbd{a s}, when
|
|
simplifying equations and inequalities. It will cancel @code{x}
|
|
from both sides of @samp{a x = b x} only if it is sure @code{x}
|
|
is non-zero, say, because it has a @code{pos} declaration.
|
|
To declare specifically that @code{x} is real and non-zero,
|
|
use @samp{[[-inf .. 0), (0 .. inf]]}. (There is no way in the
|
|
current notation to say that @code{x} is nonzero but not necessarily
|
|
real.) The @kbd{a e} command does ``unsafe'' simplifications,
|
|
including cancelling @samp{x} from the equation when @samp{x} is
|
|
not known to be nonzero.
|
|
|
|
Another set of type symbols distinguish between scalars and vectors.
|
|
|
|
@table @code
|
|
@item scalar
|
|
The value is not a vector.
|
|
@item vector
|
|
The value is a vector.
|
|
@item matrix
|
|
The value is a matrix (a rectangular vector of vectors).
|
|
@item sqmatrix
|
|
The value is a square matrix.
|
|
@end table
|
|
|
|
These type symbols can be combined with the other type symbols
|
|
described above; @samp{[int, matrix]} describes an object which
|
|
is a matrix of integers.
|
|
|
|
Scalar/vector declarations are used to determine whether certain
|
|
algebraic operations are safe. For example, @samp{[a, b, c] + x}
|
|
is normally not simplified to @samp{[a + x, b + x, c + x]}, but
|
|
it will be if @code{x} has been declared @code{scalar}. On the
|
|
other hand, multiplication is usually assumed to be commutative,
|
|
but the terms in @samp{x y} will never be exchanged if both @code{x}
|
|
and @code{y} are known to be vectors or matrices. (Calc currently
|
|
never distinguishes between @code{vector} and @code{matrix}
|
|
declarations.)
|
|
|
|
@xref{Matrix Mode}, for a discussion of Matrix mode and
|
|
Scalar mode, which are similar to declaring @samp{[All, matrix]}
|
|
or @samp{[All, scalar]} but much more convenient.
|
|
|
|
One more type symbol that is recognized is used with the @kbd{H a d}
|
|
command for taking total derivatives of a formula. @xref{Calculus}.
|
|
|
|
@table @code
|
|
@item const
|
|
The value is a constant with respect to other variables.
|
|
@end table
|
|
|
|
Calc does not check the declarations for a variable when you store
|
|
a value in it. However, storing @mathit{-3.5} in a variable that has
|
|
been declared @code{pos}, @code{int}, or @code{matrix} may have
|
|
unexpected effects; Calc may evaluate @samp{sqrt(x^2)} to @expr{3.5}
|
|
if it substitutes the value first, or to @expr{-3.5} if @code{x}
|
|
was declared @code{pos} and the formula @samp{sqrt(x^2)} is
|
|
simplified to @samp{x} before the value is substituted. Before
|
|
using a variable for a new purpose, it is best to use @kbd{s d}
|
|
or @kbd{s D} to check to make sure you don't still have an old
|
|
declaration for the variable that will conflict with its new meaning.
|
|
|
|
@node Functions for Declarations, , Kinds of Declarations, Declarations
|
|
@subsection Functions for Declarations
|
|
|
|
@noindent
|
|
Calc has a set of functions for accessing the current declarations
|
|
in a convenient manner. These functions return 1 if the argument
|
|
can be shown to have the specified property, or 0 if the argument
|
|
can be shown @emph{not} to have that property; otherwise they are
|
|
left unevaluated. These functions are suitable for use with rewrite
|
|
rules (@pxref{Conditional Rewrite Rules}) or programming constructs
|
|
(@pxref{Conditionals in Macros}). They can be entered only using
|
|
algebraic notation. @xref{Logical Operations}, for functions
|
|
that perform other tests not related to declarations.
|
|
|
|
For example, @samp{dint(17)} returns 1 because 17 is an integer, as
|
|
do @samp{dint(n)} and @samp{dint(2 n - 3)} if @code{n} has been declared
|
|
@code{int}, but @samp{dint(2.5)} and @samp{dint(n + 0.5)} return 0.
|
|
Calc consults knowledge of its own built-in functions as well as your
|
|
own declarations: @samp{dint(floor(x))} returns 1.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dint
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dnumint
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dnatnum
|
|
The @code{dint} function checks if its argument is an integer.
|
|
The @code{dnatnum} function checks if its argument is a natural
|
|
number, i.e., a nonnegative integer. The @code{dnumint} function
|
|
checks if its argument is numerically an integer, i.e., either an
|
|
integer or an integer-valued float. Note that these and the other
|
|
data type functions also accept vectors or matrices composed of
|
|
suitable elements, and that real infinities @samp{inf} and @samp{-inf}
|
|
are considered to be integers for the purposes of these functions.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex drat
|
|
The @code{drat} function checks if its argument is rational, i.e.,
|
|
an integer or fraction. Infinities count as rational, but intervals
|
|
and error forms do not.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dreal
|
|
The @code{dreal} function checks if its argument is real. This
|
|
includes integers, fractions, floats, real error forms, and intervals.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dimag
|
|
The @code{dimag} function checks if its argument is imaginary,
|
|
i.e., is mathematically equal to a real number times @expr{i}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dpos
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dneg
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dnonneg
|
|
The @code{dpos} function checks for positive (but nonzero) reals.
|
|
The @code{dneg} function checks for negative reals. The @code{dnonneg}
|
|
function checks for nonnegative reals, i.e., reals greater than or
|
|
equal to zero. Note that the @kbd{a s} command can simplify an
|
|
expression like @expr{x > 0} to 1 or 0 using @code{dpos}, and that
|
|
@kbd{a s} is effectively applied to all conditions in rewrite rules,
|
|
so the actual functions @code{dpos}, @code{dneg}, and @code{dnonneg}
|
|
are rarely necessary.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dnonzero
|
|
The @code{dnonzero} function checks that its argument is nonzero.
|
|
This includes all nonzero real or complex numbers, all intervals that
|
|
do not include zero, all nonzero modulo forms, vectors all of whose
|
|
elements are nonzero, and variables or formulas whose values can be
|
|
deduced to be nonzero. It does not include error forms, since they
|
|
represent values which could be anything including zero. (This is
|
|
also the set of objects considered ``true'' in conditional contexts.)
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex deven
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dodd
|
|
The @code{deven} function returns 1 if its argument is known to be
|
|
an even integer (or integer-valued float); it returns 0 if its argument
|
|
is known not to be even (because it is known to be odd or a non-integer).
|
|
The @kbd{a s} command uses this to simplify a test of the form
|
|
@samp{x % 2 = 0}. There is also an analogous @code{dodd} function.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex drange
|
|
The @code{drange} function returns a set (an interval or a vector
|
|
of intervals and/or numbers; @pxref{Set Operations}) that describes
|
|
the set of possible values of its argument. If the argument is
|
|
a variable or a function with a declaration, the range is copied
|
|
from the declaration. Otherwise, the possible signs of the
|
|
expression are determined using a method similar to @code{dpos},
|
|
etc., and a suitable set like @samp{[0 .. inf]} is returned. If
|
|
the expression is not provably real, the @code{drange} function
|
|
remains unevaluated.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dscalar
|
|
The @code{dscalar} function returns 1 if its argument is provably
|
|
scalar, or 0 if its argument is provably non-scalar. It is left
|
|
unevaluated if this cannot be determined. (If Matrix mode or Scalar
|
|
mode is in effect, this function returns 1 or 0, respectively,
|
|
if it has no other information.) When Calc interprets a condition
|
|
(say, in a rewrite rule) it considers an unevaluated formula to be
|
|
``false.'' Thus, @samp{dscalar(a)} is ``true'' only if @code{a} is
|
|
provably scalar, and @samp{!dscalar(a)} is ``true'' only if @code{a}
|
|
is provably non-scalar; both are ``false'' if there is insufficient
|
|
information to tell.
|
|
|
|
@node Display Modes, Language Modes, Declarations, Mode Settings
|
|
@section Display Modes
|
|
|
|
@noindent
|
|
The commands in this section are two-key sequences beginning with the
|
|
@kbd{d} prefix. The @kbd{d l} (@code{calc-line-numbering}) and @kbd{d b}
|
|
(@code{calc-line-breaking}) commands are described elsewhere;
|
|
@pxref{Stack Basics} and @pxref{Normal Language Modes}, respectively.
|
|
Display formats for vectors and matrices are also covered elsewhere;
|
|
@pxref{Vector and Matrix Formats}.
|
|
|
|
One thing all display modes have in common is their treatment of the
|
|
@kbd{H} prefix. This prefix causes any mode command that would normally
|
|
refresh the stack to leave the stack display alone. The word ``Dirty''
|
|
will appear in the mode line when Calc thinks the stack display may not
|
|
reflect the latest mode settings.
|
|
|
|
@kindex d @key{RET}
|
|
@pindex calc-refresh-top
|
|
The @kbd{d @key{RET}} (@code{calc-refresh-top}) command reformats the
|
|
top stack entry according to all the current modes. Positive prefix
|
|
arguments reformat the top @var{n} entries; negative prefix arguments
|
|
reformat the specified entry, and a prefix of zero is equivalent to
|
|
@kbd{d @key{SPC}} (@code{calc-refresh}), which reformats the entire stack.
|
|
For example, @kbd{H d s M-2 d @key{RET}} changes to scientific notation
|
|
but reformats only the top two stack entries in the new mode.
|
|
|
|
The @kbd{I} prefix has another effect on the display modes. The mode
|
|
is set only temporarily; the top stack entry is reformatted according
|
|
to that mode, then the original mode setting is restored. In other
|
|
words, @kbd{I d s} is equivalent to @kbd{H d s d @key{RET} H d (@var{old mode})}.
|
|
|
|
@menu
|
|
* Radix Modes::
|
|
* Grouping Digits::
|
|
* Float Formats::
|
|
* Complex Formats::
|
|
* Fraction Formats::
|
|
* HMS Formats::
|
|
* Date Formats::
|
|
* Truncating the Stack::
|
|
* Justification::
|
|
* Labels::
|
|
@end menu
|
|
|
|
@node Radix Modes, Grouping Digits, Display Modes, Display Modes
|
|
@subsection Radix Modes
|
|
|
|
@noindent
|
|
@cindex Radix display
|
|
@cindex Non-decimal numbers
|
|
@cindex Decimal and non-decimal numbers
|
|
Calc normally displays numbers in decimal (@dfn{base-10} or @dfn{radix-10})
|
|
notation. Calc can actually display in any radix from two (binary) to 36.
|
|
When the radix is above 10, the letters @code{A} to @code{Z} are used as
|
|
digits. When entering such a number, letter keys are interpreted as
|
|
potential digits rather than terminating numeric entry mode.
|
|
|
|
@kindex d 2
|
|
@kindex d 8
|
|
@kindex d 6
|
|
@kindex d 0
|
|
@cindex Hexadecimal integers
|
|
@cindex Octal integers
|
|
The key sequences @kbd{d 2}, @kbd{d 8}, @kbd{d 6}, and @kbd{d 0} select
|
|
binary, octal, hexadecimal, and decimal as the current display radix,
|
|
respectively. Numbers can always be entered in any radix, though the
|
|
current radix is used as a default if you press @kbd{#} without any initial
|
|
digits. A number entered without a @kbd{#} is @emph{always} interpreted
|
|
as decimal.
|
|
|
|
@kindex d r
|
|
@pindex calc-radix
|
|
To set the radix generally, use @kbd{d r} (@code{calc-radix}) and enter
|
|
an integer from 2 to 36. You can specify the radix as a numeric prefix
|
|
argument; otherwise you will be prompted for it.
|
|
|
|
@kindex d z
|
|
@pindex calc-leading-zeros
|
|
@cindex Leading zeros
|
|
Integers normally are displayed with however many digits are necessary to
|
|
represent the integer and no more. The @kbd{d z} (@code{calc-leading-zeros})
|
|
command causes integers to be padded out with leading zeros according to the
|
|
current binary word size. (@xref{Binary Functions}, for a discussion of
|
|
word size.) If the absolute value of the word size is @expr{w}, all integers
|
|
are displayed with at least enough digits to represent
|
|
@texline @math{2^w-1}
|
|
@infoline @expr{(2^w)-1}
|
|
in the current radix. (Larger integers will still be displayed in their
|
|
entirety.)
|
|
|
|
@node Grouping Digits, Float Formats, Radix Modes, Display Modes
|
|
@subsection Grouping Digits
|
|
|
|
@noindent
|
|
@kindex d g
|
|
@pindex calc-group-digits
|
|
@cindex Grouping digits
|
|
@cindex Digit grouping
|
|
Long numbers can be hard to read if they have too many digits. For
|
|
example, the factorial of 30 is 33 digits long! Press @kbd{d g}
|
|
(@code{calc-group-digits}) to enable @dfn{Grouping} mode, in which digits
|
|
are displayed in clumps of 3 or 4 (depending on the current radix)
|
|
separated by commas.
|
|
|
|
The @kbd{d g} command toggles grouping on and off.
|
|
With a numeric prefix of 0, this command displays the current state of
|
|
the grouping flag; with an argument of minus one it disables grouping;
|
|
with a positive argument @expr{N} it enables grouping on every @expr{N}
|
|
digits. For floating-point numbers, grouping normally occurs only
|
|
before the decimal point. A negative prefix argument @expr{-N} enables
|
|
grouping every @expr{N} digits both before and after the decimal point.
|
|
|
|
@kindex d ,
|
|
@pindex calc-group-char
|
|
The @kbd{d ,} (@code{calc-group-char}) command allows you to choose any
|
|
character as the grouping separator. The default is the comma character.
|
|
If you find it difficult to read vectors of large integers grouped with
|
|
commas, you may wish to use spaces or some other character instead.
|
|
This command takes the next character you type, whatever it is, and
|
|
uses it as the digit separator. As a special case, @kbd{d , \} selects
|
|
@samp{\,} (@TeX{}'s thin-space symbol) as the digit separator.
|
|
|
|
Please note that grouped numbers will not generally be parsed correctly
|
|
if re-read in textual form, say by the use of @kbd{C-x * y} and @kbd{C-x * g}.
|
|
(@xref{Kill and Yank}, for details on these commands.) One exception is
|
|
the @samp{\,} separator, which doesn't interfere with parsing because it
|
|
is ignored by @TeX{} language mode.
|
|
|
|
@node Float Formats, Complex Formats, Grouping Digits, Display Modes
|
|
@subsection Float Formats
|
|
|
|
@noindent
|
|
Floating-point quantities are normally displayed in standard decimal
|
|
form, with scientific notation used if the exponent is especially high
|
|
or low. All significant digits are normally displayed. The commands
|
|
in this section allow you to choose among several alternative display
|
|
formats for floats.
|
|
|
|
@kindex d n
|
|
@pindex calc-normal-notation
|
|
The @kbd{d n} (@code{calc-normal-notation}) command selects the normal
|
|
display format. All significant figures in a number are displayed.
|
|
With a positive numeric prefix, numbers are rounded if necessary to
|
|
that number of significant digits. With a negative numerix prefix,
|
|
the specified number of significant digits less than the current
|
|
precision is used. (Thus @kbd{C-u -2 d n} displays 10 digits if the
|
|
current precision is 12.)
|
|
|
|
@kindex d f
|
|
@pindex calc-fix-notation
|
|
The @kbd{d f} (@code{calc-fix-notation}) command selects fixed-point
|
|
notation. The numeric argument is the number of digits after the
|
|
decimal point, zero or more. This format will relax into scientific
|
|
notation if a nonzero number would otherwise have been rounded all the
|
|
way to zero. Specifying a negative number of digits is the same as
|
|
for a positive number, except that small nonzero numbers will be rounded
|
|
to zero rather than switching to scientific notation.
|
|
|
|
@kindex d s
|
|
@pindex calc-sci-notation
|
|
@cindex Scientific notation, display of
|
|
The @kbd{d s} (@code{calc-sci-notation}) command selects scientific
|
|
notation. A positive argument sets the number of significant figures
|
|
displayed, of which one will be before and the rest after the decimal
|
|
point. A negative argument works the same as for @kbd{d n} format.
|
|
The default is to display all significant digits.
|
|
|
|
@kindex d e
|
|
@pindex calc-eng-notation
|
|
@cindex Engineering notation, display of
|
|
The @kbd{d e} (@code{calc-eng-notation}) command selects engineering
|
|
notation. This is similar to scientific notation except that the
|
|
exponent is rounded down to a multiple of three, with from one to three
|
|
digits before the decimal point. An optional numeric prefix sets the
|
|
number of significant digits to display, as for @kbd{d s}.
|
|
|
|
It is important to distinguish between the current @emph{precision} and
|
|
the current @emph{display format}. After the commands @kbd{C-u 10 p}
|
|
and @kbd{C-u 6 d n} the Calculator computes all results to ten
|
|
significant figures but displays only six. (In fact, intermediate
|
|
calculations are often carried to one or two more significant figures,
|
|
but values placed on the stack will be rounded down to ten figures.)
|
|
Numbers are never actually rounded to the display precision for storage,
|
|
except by commands like @kbd{C-k} and @kbd{C-x * y} which operate on the
|
|
actual displayed text in the Calculator buffer.
|
|
|
|
@kindex d .
|
|
@pindex calc-point-char
|
|
The @kbd{d .} (@code{calc-point-char}) command selects the character used
|
|
as a decimal point. Normally this is a period; users in some countries
|
|
may wish to change this to a comma. Note that this is only a display
|
|
style; on entry, periods must always be used to denote floating-point
|
|
numbers, and commas to separate elements in a list.
|
|
|
|
@node Complex Formats, Fraction Formats, Float Formats, Display Modes
|
|
@subsection Complex Formats
|
|
|
|
@noindent
|
|
@kindex d c
|
|
@pindex calc-complex-notation
|
|
There are three supported notations for complex numbers in rectangular
|
|
form. The default is as a pair of real numbers enclosed in parentheses
|
|
and separated by a comma: @samp{(a,b)}. The @kbd{d c}
|
|
(@code{calc-complex-notation}) command selects this style.
|
|
|
|
@kindex d i
|
|
@pindex calc-i-notation
|
|
@kindex d j
|
|
@pindex calc-j-notation
|
|
The other notations are @kbd{d i} (@code{calc-i-notation}), in which
|
|
numbers are displayed in @samp{a+bi} form, and @kbd{d j}
|
|
(@code{calc-j-notation}) which displays the form @samp{a+bj} preferred
|
|
in some disciplines.
|
|
|
|
@cindex @code{i} variable
|
|
@vindex i
|
|
Complex numbers are normally entered in @samp{(a,b)} format.
|
|
If you enter @samp{2+3i} as an algebraic formula, it will be stored as
|
|
the formula @samp{2 + 3 * i}. However, if you use @kbd{=} to evaluate
|
|
this formula and you have not changed the variable @samp{i}, the @samp{i}
|
|
will be interpreted as @samp{(0,1)} and the formula will be simplified
|
|
to @samp{(2,3)}. Other commands (like @code{calc-sin}) will @emph{not}
|
|
interpret the formula @samp{2 + 3 * i} as a complex number.
|
|
@xref{Variables}, under ``special constants.''
|
|
|
|
@node Fraction Formats, HMS Formats, Complex Formats, Display Modes
|
|
@subsection Fraction Formats
|
|
|
|
@noindent
|
|
@kindex d o
|
|
@pindex calc-over-notation
|
|
Display of fractional numbers is controlled by the @kbd{d o}
|
|
(@code{calc-over-notation}) command. By default, a number like
|
|
eight thirds is displayed in the form @samp{8:3}. The @kbd{d o} command
|
|
prompts for a one- or two-character format. If you give one character,
|
|
that character is used as the fraction separator. Common separators are
|
|
@samp{:} and @samp{/}. (During input of numbers, the @kbd{:} key must be
|
|
used regardless of the display format; in particular, the @kbd{/} is used
|
|
for RPN-style division, @emph{not} for entering fractions.)
|
|
|
|
If you give two characters, fractions use ``integer-plus-fractional-part''
|
|
notation. For example, the format @samp{+/} would display eight thirds
|
|
as @samp{2+2/3}. If two colons are present in a number being entered,
|
|
the number is interpreted in this form (so that the entries @kbd{2:2:3}
|
|
and @kbd{8:3} are equivalent).
|
|
|
|
It is also possible to follow the one- or two-character format with
|
|
a number. For example: @samp{:10} or @samp{+/3}. In this case,
|
|
Calc adjusts all fractions that are displayed to have the specified
|
|
denominator, if possible. Otherwise it adjusts the denominator to
|
|
be a multiple of the specified value. For example, in @samp{:6} mode
|
|
the fraction @expr{1:6} will be unaffected, but @expr{2:3} will be
|
|
displayed as @expr{4:6}, @expr{1:2} will be displayed as @expr{3:6},
|
|
and @expr{1:8} will be displayed as @expr{3:24}. Integers are also
|
|
affected by this mode: 3 is displayed as @expr{18:6}. Note that the
|
|
format @samp{:1} writes fractions the same as @samp{:}, but it writes
|
|
integers as @expr{n:1}.
|
|
|
|
The fraction format does not affect the way fractions or integers are
|
|
stored, only the way they appear on the screen. The fraction format
|
|
never affects floats.
|
|
|
|
@node HMS Formats, Date Formats, Fraction Formats, Display Modes
|
|
@subsection HMS Formats
|
|
|
|
@noindent
|
|
@kindex d h
|
|
@pindex calc-hms-notation
|
|
The @kbd{d h} (@code{calc-hms-notation}) command controls the display of
|
|
HMS (hours-minutes-seconds) forms. It prompts for a string which
|
|
consists basically of an ``hours'' marker, optional punctuation, a
|
|
``minutes'' marker, more optional punctuation, and a ``seconds'' marker.
|
|
Punctuation is zero or more spaces, commas, or semicolons. The hours
|
|
marker is one or more non-punctuation characters. The minutes and
|
|
seconds markers must be single non-punctuation characters.
|
|
|
|
The default HMS format is @samp{@@ ' "}, producing HMS values of the form
|
|
@samp{23@@ 30' 15.75"}. The format @samp{deg, ms} would display this same
|
|
value as @samp{23deg, 30m15.75s}. During numeric entry, the @kbd{h} or @kbd{o}
|
|
keys are recognized as synonyms for @kbd{@@} regardless of display format.
|
|
The @kbd{m} and @kbd{s} keys are recognized as synonyms for @kbd{'} and
|
|
@kbd{"}, respectively, but only if an @kbd{@@} (or @kbd{h} or @kbd{o}) has
|
|
already been typed; otherwise, they have their usual meanings
|
|
(@kbd{m-} prefix and @kbd{s-} prefix). Thus, @kbd{5 "}, @kbd{0 @@ 5 "}, and
|
|
@kbd{0 h 5 s} are some of the ways to enter the quantity ``five seconds.''
|
|
The @kbd{'} key is recognized as ``minutes'' only if @kbd{@@} (or @kbd{h} or
|
|
@kbd{o}) has already been pressed; otherwise it means to switch to algebraic
|
|
entry.
|
|
|
|
@node Date Formats, Truncating the Stack, HMS Formats, Display Modes
|
|
@subsection Date Formats
|
|
|
|
@noindent
|
|
@kindex d d
|
|
@pindex calc-date-notation
|
|
The @kbd{d d} (@code{calc-date-notation}) command controls the display
|
|
of date forms (@pxref{Date Forms}). It prompts for a string which
|
|
contains letters that represent the various parts of a date and time.
|
|
To show which parts should be omitted when the form represents a pure
|
|
date with no time, parts of the string can be enclosed in @samp{< >}
|
|
marks. If you don't include @samp{< >} markers in the format, Calc
|
|
guesses at which parts, if any, should be omitted when formatting
|
|
pure dates.
|
|
|
|
The default format is: @samp{<H:mm:SSpp >Www Mmm D, YYYY}.
|
|
An example string in this format is @samp{3:32pm Wed Jan 9, 1991}.
|
|
If you enter a blank format string, this default format is
|
|
reestablished.
|
|
|
|
Calc uses @samp{< >} notation for nameless functions as well as for
|
|
dates. @xref{Specifying Operators}. To avoid confusion with nameless
|
|
functions, your date formats should avoid using the @samp{#} character.
|
|
|
|
@menu
|
|
* Date Formatting Codes::
|
|
* Free-Form Dates::
|
|
* Standard Date Formats::
|
|
@end menu
|
|
|
|
@node Date Formatting Codes, Free-Form Dates, Date Formats, Date Formats
|
|
@subsubsection Date Formatting Codes
|
|
|
|
@noindent
|
|
When displaying a date, the current date format is used. All
|
|
characters except for letters and @samp{<} and @samp{>} are
|
|
copied literally when dates are formatted. The portion between
|
|
@samp{< >} markers is omitted for pure dates, or included for
|
|
date/time forms. Letters are interpreted according to the table
|
|
below.
|
|
|
|
When dates are read in during algebraic entry, Calc first tries to
|
|
match the input string to the current format either with or without
|
|
the time part. The punctuation characters (including spaces) must
|
|
match exactly; letter fields must correspond to suitable text in
|
|
the input. If this doesn't work, Calc checks if the input is a
|
|
simple number; if so, the number is interpreted as a number of days
|
|
since Jan 1, 1 AD. Otherwise, Calc tries a much more relaxed and
|
|
flexible algorithm which is described in the next section.
|
|
|
|
Weekday names are ignored during reading.
|
|
|
|
Two-digit year numbers are interpreted as lying in the range
|
|
from 1941 to 2039. Years outside that range are always
|
|
entered and displayed in full. Year numbers with a leading
|
|
@samp{+} sign are always interpreted exactly, allowing the
|
|
entry and display of the years 1 through 99 AD.
|
|
|
|
Here is a complete list of the formatting codes for dates:
|
|
|
|
@table @asis
|
|
@item Y
|
|
Year: ``91'' for 1991, ``7'' for 2007, ``+23'' for 23 AD.
|
|
@item YY
|
|
Year: ``91'' for 1991, ``07'' for 2007, ``+23'' for 23 AD.
|
|
@item BY
|
|
Year: ``91'' for 1991, `` 7'' for 2007, ``+23'' for 23 AD.
|
|
@item YYY
|
|
Year: ``1991'' for 1991, ``23'' for 23 AD.
|
|
@item YYYY
|
|
Year: ``1991'' for 1991, ``+23'' for 23 AD.
|
|
@item aa
|
|
Year: ``ad'' or blank.
|
|
@item AA
|
|
Year: ``AD'' or blank.
|
|
@item aaa
|
|
Year: ``ad '' or blank. (Note trailing space.)
|
|
@item AAA
|
|
Year: ``AD '' or blank.
|
|
@item aaaa
|
|
Year: ``a.d.'' or blank.
|
|
@item AAAA
|
|
Year: ``A.D.'' or blank.
|
|
@item bb
|
|
Year: ``bc'' or blank.
|
|
@item BB
|
|
Year: ``BC'' or blank.
|
|
@item bbb
|
|
Year: `` bc'' or blank. (Note leading space.)
|
|
@item BBB
|
|
Year: `` BC'' or blank.
|
|
@item bbbb
|
|
Year: ``b.c.'' or blank.
|
|
@item BBBB
|
|
Year: ``B.C.'' or blank.
|
|
@item M
|
|
Month: ``8'' for August.
|
|
@item MM
|
|
Month: ``08'' for August.
|
|
@item BM
|
|
Month: `` 8'' for August.
|
|
@item MMM
|
|
Month: ``AUG'' for August.
|
|
@item Mmm
|
|
Month: ``Aug'' for August.
|
|
@item mmm
|
|
Month: ``aug'' for August.
|
|
@item MMMM
|
|
Month: ``AUGUST'' for August.
|
|
@item Mmmm
|
|
Month: ``August'' for August.
|
|
@item D
|
|
Day: ``7'' for 7th day of month.
|
|
@item DD
|
|
Day: ``07'' for 7th day of month.
|
|
@item BD
|
|
Day: `` 7'' for 7th day of month.
|
|
@item W
|
|
Weekday: ``0'' for Sunday, ``6'' for Saturday.
|
|
@item WWW
|
|
Weekday: ``SUN'' for Sunday.
|
|
@item Www
|
|
Weekday: ``Sun'' for Sunday.
|
|
@item www
|
|
Weekday: ``sun'' for Sunday.
|
|
@item WWWW
|
|
Weekday: ``SUNDAY'' for Sunday.
|
|
@item Wwww
|
|
Weekday: ``Sunday'' for Sunday.
|
|
@item d
|
|
Day of year: ``34'' for Feb. 3.
|
|
@item ddd
|
|
Day of year: ``034'' for Feb. 3.
|
|
@item bdd
|
|
Day of year: `` 34'' for Feb. 3.
|
|
@item h
|
|
Hour: ``5'' for 5 AM; ``17'' for 5 PM.
|
|
@item hh
|
|
Hour: ``05'' for 5 AM; ``17'' for 5 PM.
|
|
@item bh
|
|
Hour: `` 5'' for 5 AM; ``17'' for 5 PM.
|
|
@item H
|
|
Hour: ``5'' for 5 AM and 5 PM.
|
|
@item HH
|
|
Hour: ``05'' for 5 AM and 5 PM.
|
|
@item BH
|
|
Hour: `` 5'' for 5 AM and 5 PM.
|
|
@item p
|
|
AM/PM: ``a'' or ``p''.
|
|
@item P
|
|
AM/PM: ``A'' or ``P''.
|
|
@item pp
|
|
AM/PM: ``am'' or ``pm''.
|
|
@item PP
|
|
AM/PM: ``AM'' or ``PM''.
|
|
@item pppp
|
|
AM/PM: ``a.m.'' or ``p.m.''.
|
|
@item PPPP
|
|
AM/PM: ``A.M.'' or ``P.M.''.
|
|
@item m
|
|
Minutes: ``7'' for 7.
|
|
@item mm
|
|
Minutes: ``07'' for 7.
|
|
@item bm
|
|
Minutes: `` 7'' for 7.
|
|
@item s
|
|
Seconds: ``7'' for 7; ``7.23'' for 7.23.
|
|
@item ss
|
|
Seconds: ``07'' for 7; ``07.23'' for 7.23.
|
|
@item bs
|
|
Seconds: `` 7'' for 7; `` 7.23'' for 7.23.
|
|
@item SS
|
|
Optional seconds: ``07'' for 7; blank for 0.
|
|
@item BS
|
|
Optional seconds: `` 7'' for 7; blank for 0.
|
|
@item N
|
|
Numeric date/time: ``726842.25'' for 6:00am Wed Jan 9, 1991.
|
|
@item n
|
|
Numeric date: ``726842'' for any time on Wed Jan 9, 1991.
|
|
@item J
|
|
Julian date/time: ``2448265.75'' for 6:00am Wed Jan 9, 1991.
|
|
@item j
|
|
Julian date: ``2448266'' for any time on Wed Jan 9, 1991.
|
|
@item U
|
|
Unix time: ``663400800'' for 6:00am Wed Jan 9, 1991.
|
|
@item X
|
|
Brackets suppression. An ``X'' at the front of the format
|
|
causes the surrounding @w{@samp{< >}} delimiters to be omitted
|
|
when formatting dates. Note that the brackets are still
|
|
required for algebraic entry.
|
|
@end table
|
|
|
|
If ``SS'' or ``BS'' (optional seconds) is preceded by a colon, the
|
|
colon is also omitted if the seconds part is zero.
|
|
|
|
If ``bb,'' ``bbb'' or ``bbbb'' or their upper-case equivalents
|
|
appear in the format, then negative year numbers are displayed
|
|
without a minus sign. Note that ``aa'' and ``bb'' are mutually
|
|
exclusive. Some typical usages would be @samp{YYYY AABB};
|
|
@samp{AAAYYYYBBB}; @samp{YYYYBBB}.
|
|
|
|
The formats ``YY,'' ``YYYY,'' ``MM,'' ``DD,'' ``ddd,'' ``hh,'' ``HH,''
|
|
``mm,'' ``ss,'' and ``SS'' actually match any number of digits during
|
|
reading unless several of these codes are strung together with no
|
|
punctuation in between, in which case the input must have exactly as
|
|
many digits as there are letters in the format.
|
|
|
|
The ``j,'' ``J,'' and ``U'' formats do not make any time zone
|
|
adjustment. They effectively use @samp{julian(x,0)} and
|
|
@samp{unixtime(x,0)} to make the conversion; @pxref{Date Arithmetic}.
|
|
|
|
@node Free-Form Dates, Standard Date Formats, Date Formatting Codes, Date Formats
|
|
@subsubsection Free-Form Dates
|
|
|
|
@noindent
|
|
When reading a date form during algebraic entry, Calc falls back
|
|
on the algorithm described here if the input does not exactly
|
|
match the current date format. This algorithm generally
|
|
``does the right thing'' and you don't have to worry about it,
|
|
but it is described here in full detail for the curious.
|
|
|
|
Calc does not distinguish between upper- and lower-case letters
|
|
while interpreting dates.
|
|
|
|
First, the time portion, if present, is located somewhere in the
|
|
text and then removed. The remaining text is then interpreted as
|
|
the date.
|
|
|
|
A time is of the form @samp{hh:mm:ss}, possibly with the seconds
|
|
part omitted and possibly with an AM/PM indicator added to indicate
|
|
12-hour time. If the AM/PM is present, the minutes may also be
|
|
omitted. The AM/PM part may be any of the words @samp{am},
|
|
@samp{pm}, @samp{noon}, or @samp{midnight}; each of these may be
|
|
abbreviated to one letter, and the alternate forms @samp{a.m.},
|
|
@samp{p.m.}, and @samp{mid} are also understood. Obviously
|
|
@samp{noon} and @samp{midnight} are allowed only on 12:00:00.
|
|
The words @samp{noon}, @samp{mid}, and @samp{midnight} are also
|
|
recognized with no number attached.
|
|
|
|
If there is no AM/PM indicator, the time is interpreted in 24-hour
|
|
format.
|
|
|
|
To read the date portion, all words and numbers are isolated
|
|
from the string; other characters are ignored. All words must
|
|
be either month names or day-of-week names (the latter of which
|
|
are ignored). Names can be written in full or as three-letter
|
|
abbreviations.
|
|
|
|
Large numbers, or numbers with @samp{+} or @samp{-} signs,
|
|
are interpreted as years. If one of the other numbers is
|
|
greater than 12, then that must be the day and the remaining
|
|
number in the input is therefore the month. Otherwise, Calc
|
|
assumes the month, day and year are in the same order that they
|
|
appear in the current date format. If the year is omitted, the
|
|
current year is taken from the system clock.
|
|
|
|
If there are too many or too few numbers, or any unrecognizable
|
|
words, then the input is rejected.
|
|
|
|
If there are any large numbers (of five digits or more) other than
|
|
the year, they are ignored on the assumption that they are something
|
|
like Julian dates that were included along with the traditional
|
|
date components when the date was formatted.
|
|
|
|
One of the words @samp{ad}, @samp{a.d.}, @samp{bc}, or @samp{b.c.}
|
|
may optionally be used; the latter two are equivalent to a
|
|
minus sign on the year value.
|
|
|
|
If you always enter a four-digit year, and use a name instead
|
|
of a number for the month, there is no danger of ambiguity.
|
|
|
|
@node Standard Date Formats, , Free-Form Dates, Date Formats
|
|
@subsubsection Standard Date Formats
|
|
|
|
@noindent
|
|
There are actually ten standard date formats, numbered 0 through 9.
|
|
Entering a blank line at the @kbd{d d} command's prompt gives
|
|
you format number 1, Calc's usual format. You can enter any digit
|
|
to select the other formats.
|
|
|
|
To create your own standard date formats, give a numeric prefix
|
|
argument from 0 to 9 to the @w{@kbd{d d}} command. The format you
|
|
enter will be recorded as the new standard format of that
|
|
number, as well as becoming the new current date format.
|
|
You can save your formats permanently with the @w{@kbd{m m}}
|
|
command (@pxref{Mode Settings}).
|
|
|
|
@table @asis
|
|
@item 0
|
|
@samp{N} (Numerical format)
|
|
@item 1
|
|
@samp{<H:mm:SSpp >Www Mmm D, YYYY} (American format)
|
|
@item 2
|
|
@samp{D Mmm YYYY<, h:mm:SS>} (European format)
|
|
@item 3
|
|
@samp{Www Mmm BD< hh:mm:ss> YYYY} (Unix written date format)
|
|
@item 4
|
|
@samp{M/D/Y< H:mm:SSpp>} (American slashed format)
|
|
@item 5
|
|
@samp{D.M.Y< h:mm:SS>} (European dotted format)
|
|
@item 6
|
|
@samp{M-D-Y< H:mm:SSpp>} (American dashed format)
|
|
@item 7
|
|
@samp{D-M-Y< h:mm:SS>} (European dashed format)
|
|
@item 8
|
|
@samp{j<, h:mm:ss>} (Julian day plus time)
|
|
@item 9
|
|
@samp{YYddd< hh:mm:ss>} (Year-day format)
|
|
@end table
|
|
|
|
@node Truncating the Stack, Justification, Date Formats, Display Modes
|
|
@subsection Truncating the Stack
|
|
|
|
@noindent
|
|
@kindex d t
|
|
@pindex calc-truncate-stack
|
|
@cindex Truncating the stack
|
|
@cindex Narrowing the stack
|
|
The @kbd{d t} (@code{calc-truncate-stack}) command moves the @samp{.}@:
|
|
line that marks the top-of-stack up or down in the Calculator buffer.
|
|
The number right above that line is considered to the be at the top of
|
|
the stack. Any numbers below that line are ``hidden'' from all stack
|
|
operations (although still visible to the user). This is similar to the
|
|
Emacs ``narrowing'' feature, except that the values below the @samp{.}
|
|
are @emph{visible}, just temporarily frozen. This feature allows you to
|
|
keep several independent calculations running at once in different parts
|
|
of the stack, or to apply a certain command to an element buried deep in
|
|
the stack.
|
|
|
|
Pressing @kbd{d t} by itself moves the @samp{.} to the line the cursor
|
|
is on. Thus, this line and all those below it become hidden. To un-hide
|
|
these lines, move down to the end of the buffer and press @w{@kbd{d t}}.
|
|
With a positive numeric prefix argument @expr{n}, @kbd{d t} hides the
|
|
bottom @expr{n} values in the buffer. With a negative argument, it hides
|
|
all but the top @expr{n} values. With an argument of zero, it hides zero
|
|
values, i.e., moves the @samp{.} all the way down to the bottom.
|
|
|
|
@kindex d [
|
|
@pindex calc-truncate-up
|
|
@kindex d ]
|
|
@pindex calc-truncate-down
|
|
The @kbd{d [} (@code{calc-truncate-up}) and @kbd{d ]}
|
|
(@code{calc-truncate-down}) commands move the @samp{.} up or down one
|
|
line at a time (or several lines with a prefix argument).
|
|
|
|
@node Justification, Labels, Truncating the Stack, Display Modes
|
|
@subsection Justification
|
|
|
|
@noindent
|
|
@kindex d <
|
|
@pindex calc-left-justify
|
|
@kindex d =
|
|
@pindex calc-center-justify
|
|
@kindex d >
|
|
@pindex calc-right-justify
|
|
Values on the stack are normally left-justified in the window. You can
|
|
control this arrangement by typing @kbd{d <} (@code{calc-left-justify}),
|
|
@kbd{d >} (@code{calc-right-justify}), or @kbd{d =}
|
|
(@code{calc-center-justify}). For example, in Right-Justification mode,
|
|
stack entries are displayed flush-right against the right edge of the
|
|
window.
|
|
|
|
If you change the width of the Calculator window you may have to type
|
|
@kbd{d @key{SPC}} (@code{calc-refresh}) to re-align right-justified or centered
|
|
text.
|
|
|
|
Right-justification is especially useful together with fixed-point
|
|
notation (see @code{d f}; @code{calc-fix-notation}). With these modes
|
|
together, the decimal points on numbers will always line up.
|
|
|
|
With a numeric prefix argument, the justification commands give you
|
|
a little extra control over the display. The argument specifies the
|
|
horizontal ``origin'' of a display line. It is also possible to
|
|
specify a maximum line width using the @kbd{d b} command (@pxref{Normal
|
|
Language Modes}). For reference, the precise rules for formatting and
|
|
breaking lines are given below. Notice that the interaction between
|
|
origin and line width is slightly different in each justification
|
|
mode.
|
|
|
|
In Left-Justified mode, the line is indented by a number of spaces
|
|
given by the origin (default zero). If the result is longer than the
|
|
maximum line width, if given, or too wide to fit in the Calc window
|
|
otherwise, then it is broken into lines which will fit; each broken
|
|
line is indented to the origin.
|
|
|
|
In Right-Justified mode, lines are shifted right so that the rightmost
|
|
character is just before the origin, or just before the current
|
|
window width if no origin was specified. If the line is too long
|
|
for this, then it is broken; the current line width is used, if
|
|
specified, or else the origin is used as a width if that is
|
|
specified, or else the line is broken to fit in the window.
|
|
|
|
In Centering mode, the origin is the column number of the center of
|
|
each stack entry. If a line width is specified, lines will not be
|
|
allowed to go past that width; Calc will either indent less or
|
|
break the lines if necessary. If no origin is specified, half the
|
|
line width or Calc window width is used.
|
|
|
|
Note that, in each case, if line numbering is enabled the display
|
|
is indented an additional four spaces to make room for the line
|
|
number. The width of the line number is taken into account when
|
|
positioning according to the current Calc window width, but not
|
|
when positioning by explicit origins and widths. In the latter
|
|
case, the display is formatted as specified, and then uniformly
|
|
shifted over four spaces to fit the line numbers.
|
|
|
|
@node Labels, , Justification, Display Modes
|
|
@subsection Labels
|
|
|
|
@noindent
|
|
@kindex d @{
|
|
@pindex calc-left-label
|
|
The @kbd{d @{} (@code{calc-left-label}) command prompts for a string,
|
|
then displays that string to the left of every stack entry. If the
|
|
entries are left-justified (@pxref{Justification}), then they will
|
|
appear immediately after the label (unless you specified an origin
|
|
greater than the length of the label). If the entries are centered
|
|
or right-justified, the label appears on the far left and does not
|
|
affect the horizontal position of the stack entry.
|
|
|
|
Give a blank string (with @kbd{d @{ @key{RET}}) to turn the label off.
|
|
|
|
@kindex d @}
|
|
@pindex calc-right-label
|
|
The @kbd{d @}} (@code{calc-right-label}) command similarly adds a
|
|
label on the righthand side. It does not affect positioning of
|
|
the stack entries unless they are right-justified. Also, if both
|
|
a line width and an origin are given in Right-Justified mode, the
|
|
stack entry is justified to the origin and the righthand label is
|
|
justified to the line width.
|
|
|
|
One application of labels would be to add equation numbers to
|
|
formulas you are manipulating in Calc and then copying into a
|
|
document (possibly using Embedded mode). The equations would
|
|
typically be centered, and the equation numbers would be on the
|
|
left or right as you prefer.
|
|
|
|
@node Language Modes, Modes Variable, Display Modes, Mode Settings
|
|
@section Language Modes
|
|
|
|
@noindent
|
|
The commands in this section change Calc to use a different notation for
|
|
entry and display of formulas, corresponding to the conventions of some
|
|
other common language such as Pascal or La@TeX{}. Objects displayed on the
|
|
stack or yanked from the Calculator to an editing buffer will be formatted
|
|
in the current language; objects entered in algebraic entry or yanked from
|
|
another buffer will be interpreted according to the current language.
|
|
|
|
The current language has no effect on things written to or read from the
|
|
trail buffer, nor does it affect numeric entry. Only algebraic entry is
|
|
affected. You can make even algebraic entry ignore the current language
|
|
and use the standard notation by giving a numeric prefix, e.g., @kbd{C-u '}.
|
|
|
|
For example, suppose the formula @samp{2*a[1] + atan(a[2])} occurs in a C
|
|
program; elsewhere in the program you need the derivatives of this formula
|
|
with respect to @samp{a[1]} and @samp{a[2]}. First, type @kbd{d C}
|
|
to switch to C notation. Now use @code{C-u C-x * g} to grab the formula
|
|
into the Calculator, @kbd{a d a[1] @key{RET}} to differentiate with respect
|
|
to the first variable, and @kbd{C-x * y} to yank the formula for the derivative
|
|
back into your C program. Press @kbd{U} to undo the differentiation and
|
|
repeat with @kbd{a d a[2] @key{RET}} for the other derivative.
|
|
|
|
Without being switched into C mode first, Calc would have misinterpreted
|
|
the brackets in @samp{a[1]} and @samp{a[2]}, would not have known that
|
|
@code{atan} was equivalent to Calc's built-in @code{arctan} function,
|
|
and would have written the formula back with notations (like implicit
|
|
multiplication) which would not have been valid for a C program.
|
|
|
|
As another example, suppose you are maintaining a C program and a La@TeX{}
|
|
document, each of which needs a copy of the same formula. You can grab the
|
|
formula from the program in C mode, switch to La@TeX{} mode, and yank the
|
|
formula into the document in La@TeX{} math-mode format.
|
|
|
|
Language modes are selected by typing the letter @kbd{d} followed by a
|
|
shifted letter key.
|
|
|
|
@menu
|
|
* Normal Language Modes::
|
|
* C FORTRAN Pascal::
|
|
* TeX and LaTeX Language Modes::
|
|
* Eqn Language Mode::
|
|
* Mathematica Language Mode::
|
|
* Maple Language Mode::
|
|
* Compositions::
|
|
* Syntax Tables::
|
|
@end menu
|
|
|
|
@node Normal Language Modes, C FORTRAN Pascal, Language Modes, Language Modes
|
|
@subsection Normal Language Modes
|
|
|
|
@noindent
|
|
@kindex d N
|
|
@pindex calc-normal-language
|
|
The @kbd{d N} (@code{calc-normal-language}) command selects the usual
|
|
notation for Calc formulas, as described in the rest of this manual.
|
|
Matrices are displayed in a multi-line tabular format, but all other
|
|
objects are written in linear form, as they would be typed from the
|
|
keyboard.
|
|
|
|
@kindex d O
|
|
@pindex calc-flat-language
|
|
@cindex Matrix display
|
|
The @kbd{d O} (@code{calc-flat-language}) command selects a language
|
|
identical with the normal one, except that matrices are written in
|
|
one-line form along with everything else. In some applications this
|
|
form may be more suitable for yanking data into other buffers.
|
|
|
|
@kindex d b
|
|
@pindex calc-line-breaking
|
|
@cindex Line breaking
|
|
@cindex Breaking up long lines
|
|
Even in one-line mode, long formulas or vectors will still be split
|
|
across multiple lines if they exceed the width of the Calculator window.
|
|
The @kbd{d b} (@code{calc-line-breaking}) command turns this line-breaking
|
|
feature on and off. (It works independently of the current language.)
|
|
If you give a numeric prefix argument of five or greater to the @kbd{d b}
|
|
command, that argument will specify the line width used when breaking
|
|
long lines.
|
|
|
|
@kindex d B
|
|
@pindex calc-big-language
|
|
The @kbd{d B} (@code{calc-big-language}) command selects a language
|
|
which uses textual approximations to various mathematical notations,
|
|
such as powers, quotients, and square roots:
|
|
|
|
@example
|
|
____________
|
|
| a + 1 2
|
|
| ----- + c
|
|
\| b
|
|
@end example
|
|
|
|
@noindent
|
|
in place of @samp{sqrt((a+1)/b + c^2)}.
|
|
|
|
Subscripts like @samp{a_i} are displayed as actual subscripts in Big
|
|
mode. Double subscripts, @samp{a_i_j} (@samp{subscr(subscr(a, i), j)})
|
|
are displayed as @samp{a} with subscripts separated by commas:
|
|
@samp{i, j}. They must still be entered in the usual underscore
|
|
notation.
|
|
|
|
One slight ambiguity of Big notation is that
|
|
|
|
@example
|
|
3
|
|
- -
|
|
4
|
|
@end example
|
|
|
|
@noindent
|
|
can represent either the negative rational number @expr{-3:4}, or the
|
|
actual expression @samp{-(3/4)}; but the latter formula would normally
|
|
never be displayed because it would immediately be evaluated to
|
|
@expr{-3:4} or @expr{-0.75}, so this ambiguity is not a problem in
|
|
typical use.
|
|
|
|
Non-decimal numbers are displayed with subscripts. Thus there is no
|
|
way to tell the difference between @samp{16#C2} and @samp{C2_16},
|
|
though generally you will know which interpretation is correct.
|
|
Logarithms @samp{log(x,b)} and @samp{log10(x)} also use subscripts
|
|
in Big mode.
|
|
|
|
In Big mode, stack entries often take up several lines. To aid
|
|
readability, stack entries are separated by a blank line in this mode.
|
|
You may find it useful to expand the Calc window's height using
|
|
@kbd{C-x ^} (@code{enlarge-window}) or to make the Calc window the only
|
|
one on the screen with @kbd{C-x 1} (@code{delete-other-windows}).
|
|
|
|
Long lines are currently not rearranged to fit the window width in
|
|
Big mode, so you may need to use the @kbd{<} and @kbd{>} keys
|
|
to scroll across a wide formula. For really big formulas, you may
|
|
even need to use @kbd{@{} and @kbd{@}} to scroll up and down.
|
|
|
|
@kindex d U
|
|
@pindex calc-unformatted-language
|
|
The @kbd{d U} (@code{calc-unformatted-language}) command altogether disables
|
|
the use of operator notation in formulas. In this mode, the formula
|
|
shown above would be displayed:
|
|
|
|
@example
|
|
sqrt(add(div(add(a, 1), b), pow(c, 2)))
|
|
@end example
|
|
|
|
These four modes differ only in display format, not in the format
|
|
expected for algebraic entry. The standard Calc operators work in
|
|
all four modes, and unformatted notation works in any language mode
|
|
(except that Mathematica mode expects square brackets instead of
|
|
parentheses).
|
|
|
|
@node C FORTRAN Pascal, TeX and LaTeX Language Modes, Normal Language Modes, Language Modes
|
|
@subsection C, FORTRAN, and Pascal Modes
|
|
|
|
@noindent
|
|
@kindex d C
|
|
@pindex calc-c-language
|
|
@cindex C language
|
|
The @kbd{d C} (@code{calc-c-language}) command selects the conventions
|
|
of the C language for display and entry of formulas. This differs from
|
|
the normal language mode in a variety of (mostly minor) ways. In
|
|
particular, C language operators and operator precedences are used in
|
|
place of Calc's usual ones. For example, @samp{a^b} means @samp{xor(a,b)}
|
|
in C mode; a value raised to a power is written as a function call,
|
|
@samp{pow(a,b)}.
|
|
|
|
In C mode, vectors and matrices use curly braces instead of brackets.
|
|
Octal and hexadecimal values are written with leading @samp{0} or @samp{0x}
|
|
rather than using the @samp{#} symbol. Array subscripting is
|
|
translated into @code{subscr} calls, so that @samp{a[i]} in C
|
|
mode is the same as @samp{a_i} in Normal mode. Assignments
|
|
turn into the @code{assign} function, which Calc normally displays
|
|
using the @samp{:=} symbol.
|
|
|
|
The variables @code{pi} and @code{e} would be displayed @samp{pi}
|
|
and @samp{e} in Normal mode, but in C mode they are displayed as
|
|
@samp{M_PI} and @samp{M_E}, corresponding to the names of constants
|
|
typically provided in the @file{<math.h>} header. Functions whose
|
|
names are different in C are translated automatically for entry and
|
|
display purposes. For example, entering @samp{asin(x)} will push the
|
|
formula @samp{arcsin(x)} onto the stack; this formula will be displayed
|
|
as @samp{asin(x)} as long as C mode is in effect.
|
|
|
|
@kindex d P
|
|
@pindex calc-pascal-language
|
|
@cindex Pascal language
|
|
The @kbd{d P} (@code{calc-pascal-language}) command selects Pascal
|
|
conventions. Like C mode, Pascal mode interprets array brackets and uses
|
|
a different table of operators. Hexadecimal numbers are entered and
|
|
displayed with a preceding dollar sign. (Thus the regular meaning of
|
|
@kbd{$2} during algebraic entry does not work in Pascal mode, though
|
|
@kbd{$} (and @kbd{$$}, etc.) not followed by digits works the same as
|
|
always.) No special provisions are made for other non-decimal numbers,
|
|
vectors, and so on, since there is no universally accepted standard way
|
|
of handling these in Pascal.
|
|
|
|
@kindex d F
|
|
@pindex calc-fortran-language
|
|
@cindex FORTRAN language
|
|
The @kbd{d F} (@code{calc-fortran-language}) command selects FORTRAN
|
|
conventions. Various function names are transformed into FORTRAN
|
|
equivalents. Vectors are written as @samp{/1, 2, 3/}, and may be
|
|
entered this way or using square brackets. Since FORTRAN uses round
|
|
parentheses for both function calls and array subscripts, Calc displays
|
|
both in the same way; @samp{a(i)} is interpreted as a function call
|
|
upon reading, and subscripts must be entered as @samp{subscr(a, i)}.
|
|
Also, if the variable @code{a} has been declared to have type
|
|
@code{vector} or @code{matrix} then @samp{a(i)} will be parsed as a
|
|
subscript. (@xref{Declarations}.) Usually it doesn't matter, though;
|
|
if you enter the subscript expression @samp{a(i)} and Calc interprets
|
|
it as a function call, you'll never know the difference unless you
|
|
switch to another language mode or replace @code{a} with an actual
|
|
vector (or unless @code{a} happens to be the name of a built-in
|
|
function!).
|
|
|
|
Underscores are allowed in variable and function names in all of these
|
|
language modes. The underscore here is equivalent to the @samp{#} in
|
|
Normal mode, or to hyphens in the underlying Emacs Lisp variable names.
|
|
|
|
FORTRAN and Pascal modes normally do not adjust the case of letters in
|
|
formulas. Most built-in Calc names use lower-case letters. If you use a
|
|
positive numeric prefix argument with @kbd{d P} or @kbd{d F}, these
|
|
modes will use upper-case letters exclusively for display, and will
|
|
convert to lower-case on input. With a negative prefix, these modes
|
|
convert to lower-case for display and input.
|
|
|
|
@node TeX and LaTeX Language Modes, Eqn Language Mode, C FORTRAN Pascal, Language Modes
|
|
@subsection @TeX{} and La@TeX{} Language Modes
|
|
|
|
@noindent
|
|
@kindex d T
|
|
@pindex calc-tex-language
|
|
@cindex TeX language
|
|
@kindex d L
|
|
@pindex calc-latex-language
|
|
@cindex LaTeX language
|
|
The @kbd{d T} (@code{calc-tex-language}) command selects the conventions
|
|
of ``math mode'' in Donald Knuth's @TeX{} typesetting language,
|
|
and the @kbd{d L} (@code{calc-latex-language}) command selects the
|
|
conventions of ``math mode'' in La@TeX{}, a typesetting language that
|
|
uses @TeX{} as its formatting engine. Calc's La@TeX{} language mode can
|
|
read any formula that the @TeX{} language mode can, although La@TeX{}
|
|
mode may display it differently.
|
|
|
|
Formulas are entered and displayed in the appropriate notation;
|
|
@texline @math{\sin(a/b)}
|
|
@infoline @expr{sin(a/b)}
|
|
will appear as @samp{\sin\left( a \over b \right)} in @TeX{} mode and
|
|
@samp{\sin\left(\frac@{a@}@{b@}\right)} in La@TeX{} mode.
|
|
Math formulas are often enclosed by @samp{$ $} signs in @TeX{} and
|
|
La@TeX{}; these should be omitted when interfacing with Calc. To Calc,
|
|
the @samp{$} sign has the same meaning it always does in algebraic
|
|
formulas (a reference to an existing entry on the stack).
|
|
|
|
Complex numbers are displayed as in @samp{3 + 4i}. Fractions and
|
|
quotients are written using @code{\over} in @TeX{} mode (as in
|
|
@code{@{a \over b@}}) and @code{\frac} in La@TeX{} mode (as in
|
|
@code{\frac@{a@}@{b@}}); binomial coefficients are written with
|
|
@code{\choose} in @TeX{} mode (as in @code{@{a \choose b@}}) and
|
|
@code{\binom} in La@TeX{} mode (as in @code{\binom@{a@}@{b@}}).
|
|
Interval forms are written with @code{\ldots}, and error forms are
|
|
written with @code{\pm}. Absolute values are written as in
|
|
@samp{|x + 1|}, and the floor and ceiling functions are written with
|
|
@code{\lfloor}, @code{\rfloor}, etc. The words @code{\left} and
|
|
@code{\right} are ignored when reading formulas in @TeX{} and La@TeX{}
|
|
modes. Both @code{inf} and @code{uinf} are written as @code{\infty};
|
|
when read, @code{\infty} always translates to @code{inf}.
|
|
|
|
Function calls are written the usual way, with the function name followed
|
|
by the arguments in parentheses. However, functions for which @TeX{}
|
|
and La@TeX{} have special names (like @code{\sin}) will use curly braces
|
|
instead of parentheses for very simple arguments. During input, curly
|
|
braces and parentheses work equally well for grouping, but when the
|
|
document is formatted the curly braces will be invisible. Thus the
|
|
printed result is
|
|
@texline @math{\sin{2 x}}
|
|
@infoline @expr{sin 2x}
|
|
but
|
|
@texline @math{\sin(2 + x)}.
|
|
@infoline @expr{sin(2 + x)}.
|
|
|
|
Function and variable names not treated specially by @TeX{} and La@TeX{}
|
|
are simply written out as-is, which will cause them to come out in
|
|
italic letters in the printed document. If you invoke @kbd{d T} or
|
|
@kbd{d L} with a positive numeric prefix argument, names of more than
|
|
one character will instead be enclosed in a protective commands that
|
|
will prevent them from being typeset in the math italics; they will be
|
|
written @samp{\hbox@{@var{name}@}} in @TeX{} mode and
|
|
@samp{\text@{@var{name}@}} in La@TeX{} mode. The
|
|
@samp{\hbox@{ @}} and @samp{\text@{ @}} notations are ignored during
|
|
reading. If you use a negative prefix argument, such function names are
|
|
written @samp{\@var{name}}, and function names that begin with @code{\} during
|
|
reading have the @code{\} removed. (Note that in this mode, long
|
|
variable names are still written with @code{\hbox} or @code{\text}.
|
|
However, you can always make an actual variable name like @code{\bar} in
|
|
any @TeX{} mode.)
|
|
|
|
During reading, text of the form @samp{\matrix@{ ...@: @}} is replaced
|
|
by @samp{[ ...@: ]}. The same also applies to @code{\pmatrix} and
|
|
@code{\bmatrix}. In La@TeX{} mode this also applies to
|
|
@samp{\begin@{matrix@} ... \end@{matrix@}},
|
|
@samp{\begin@{bmatrix@} ... \end@{bmatrix@}},
|
|
@samp{\begin@{pmatrix@} ... \end@{pmatrix@}}, as well as
|
|
@samp{\begin@{smallmatrix@} ... \end@{smallmatrix@}}.
|
|
The symbol @samp{&} is interpreted as a comma,
|
|
and the symbols @samp{\cr} and @samp{\\} are interpreted as semicolons.
|
|
During output, matrices are displayed in @samp{\matrix@{ a & b \\ c & d@}}
|
|
format in @TeX{} mode and in
|
|
@samp{\begin@{pmatrix@} a & b \\ c & d \end@{pmatrix@}} format in
|
|
La@TeX{} mode; you may need to edit this afterwards to change to your
|
|
preferred matrix form. If you invoke @kbd{d T} or @kbd{d L} with an
|
|
argument of 2 or -2, then matrices will be displayed in two-dimensional
|
|
form, such as
|
|
|
|
@example
|
|
\begin@{pmatrix@}
|
|
a & b \\
|
|
c & d
|
|
\end@{pmatrix@}
|
|
@end example
|
|
|
|
@noindent
|
|
This may be convenient for isolated matrices, but could lead to
|
|
expressions being displayed like
|
|
|
|
@example
|
|
\begin@{pmatrix@} \times x
|
|
a & b \\
|
|
c & d
|
|
\end@{pmatrix@}
|
|
@end example
|
|
|
|
@noindent
|
|
While this wouldn't bother Calc, it is incorrect La@TeX{}.
|
|
(Similarly for @TeX{}.)
|
|
|
|
Accents like @code{\tilde} and @code{\bar} translate into function
|
|
calls internally (@samp{tilde(x)}, @samp{bar(x)}). The @code{\underline}
|
|
sequence is treated as an accent. The @code{\vec} accent corresponds
|
|
to the function name @code{Vec}, because @code{vec} is the name of
|
|
a built-in Calc function. The following table shows the accents
|
|
in Calc, @TeX{}, La@TeX{} and @dfn{eqn} (described in the next section):
|
|
|
|
@iftex
|
|
@begingroup
|
|
@let@calcindexershow=@calcindexernoshow @c Suppress marginal notes
|
|
@let@calcindexersh=@calcindexernoshow
|
|
@end iftex
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex acute
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Acute
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex bar
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Bar
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex breve
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Breve
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex check
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Check
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dddot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex ddddot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Dot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dotdot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex DotDot
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dyad
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex grave
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Grave
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex hat
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Hat
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Prime
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex tilde
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Tilde
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex under
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Vec
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex VEC
|
|
@iftex
|
|
@endgroup
|
|
@end iftex
|
|
@example
|
|
Calc TeX LaTeX eqn
|
|
---- --- ----- ---
|
|
acute \acute \acute
|
|
Acute \Acute
|
|
bar \bar \bar bar
|
|
Bar \Bar
|
|
breve \breve \breve
|
|
Breve \Breve
|
|
check \check \check
|
|
Check \Check
|
|
dddot \dddot
|
|
ddddot \ddddot
|
|
dot \dot \dot dot
|
|
Dot \Dot
|
|
dotdot \ddot \ddot dotdot
|
|
DotDot \Ddot
|
|
dyad dyad
|
|
grave \grave \grave
|
|
Grave \Grave
|
|
hat \hat \hat hat
|
|
Hat \Hat
|
|
Prime prime
|
|
tilde \tilde \tilde tilde
|
|
Tilde \Tilde
|
|
under \underline \underline under
|
|
Vec \vec \vec vec
|
|
VEC \Vec
|
|
@end example
|
|
|
|
The @samp{=>} (evaluates-to) operator appears as a @code{\to} symbol:
|
|
@samp{@{@var{a} \to @var{b}@}}. @TeX{} defines @code{\to} as an
|
|
alias for @code{\rightarrow}. However, if the @samp{=>} is the
|
|
top-level expression being formatted, a slightly different notation
|
|
is used: @samp{\evalto @var{a} \to @var{b}}. The @code{\evalto}
|
|
word is ignored by Calc's input routines, and is undefined in @TeX{}.
|
|
You will typically want to include one of the following definitions
|
|
at the top of a @TeX{} file that uses @code{\evalto}:
|
|
|
|
@example
|
|
\def\evalto@{@}
|
|
\def\evalto#1\to@{@}
|
|
@end example
|
|
|
|
The first definition formats evaluates-to operators in the usual
|
|
way. The second causes only the @var{b} part to appear in the
|
|
printed document; the @var{a} part and the arrow are hidden.
|
|
Another definition you may wish to use is @samp{\let\to=\Rightarrow}
|
|
which causes @code{\to} to appear more like Calc's @samp{=>} symbol.
|
|
@xref{Evaluates-To Operator}, for a discussion of @code{evalto}.
|
|
|
|
The complete set of @TeX{} control sequences that are ignored during
|
|
reading is:
|
|
|
|
@example
|
|
\hbox \mbox \text \left \right
|
|
\, \> \: \; \! \quad \qquad \hfil \hfill
|
|
\displaystyle \textstyle \dsize \tsize
|
|
\scriptstyle \scriptscriptstyle \ssize \ssize
|
|
\rm \bf \it \sl \roman \bold \italic \slanted
|
|
\cal \mit \Cal \Bbb \frak \goth
|
|
\evalto
|
|
@end example
|
|
|
|
Note that, because these symbols are ignored, reading a @TeX{} or
|
|
La@TeX{} formula into Calc and writing it back out may lose spacing and
|
|
font information.
|
|
|
|
Also, the ``discretionary multiplication sign'' @samp{\*} is read
|
|
the same as @samp{*}.
|
|
|
|
@ifinfo
|
|
The @TeX{} version of this manual includes some printed examples at the
|
|
end of this section.
|
|
@end ifinfo
|
|
@iftex
|
|
Here are some examples of how various Calc formulas are formatted in @TeX{}:
|
|
|
|
@example
|
|
@group
|
|
sin(a^2 / b_i)
|
|
\sin\left( {a^2 \over b_i} \right)
|
|
@end group
|
|
@end example
|
|
@tex
|
|
$$ \sin\left( a^2 \over b_i \right) $$
|
|
@end tex
|
|
@sp 1
|
|
|
|
@example
|
|
@group
|
|
[(3, 4), 3:4, 3 +/- 4, [3 .. inf)]
|
|
[3 + 4i, @{3 \over 4@}, 3 \pm 4, [3 \ldots \infty)]
|
|
@end group
|
|
@end example
|
|
@tex
|
|
\turnoffactive
|
|
$$ [3 + 4i, {3 \over 4}, 3 \pm 4, [ 3 \ldots \infty)] $$
|
|
@end tex
|
|
@sp 1
|
|
|
|
@example
|
|
@group
|
|
[abs(a), abs(a / b), floor(a), ceil(a / b)]
|
|
[|a|, \left| a \over b \right|,
|
|
\lfloor a \rfloor, \left\lceil a \over b \right\rceil]
|
|
@end group
|
|
@end example
|
|
@tex
|
|
$$ [|a|, \left| a \over b \right|,
|
|
\lfloor a \rfloor, \left\lceil a \over b \right\rceil] $$
|
|
@end tex
|
|
@sp 1
|
|
|
|
@example
|
|
@group
|
|
[sin(a), sin(2 a), sin(2 + a), sin(a / b)]
|
|
[\sin@{a@}, \sin@{2 a@}, \sin(2 + a),
|
|
\sin\left( @{a \over b@} \right)]
|
|
@end group
|
|
@end example
|
|
@tex
|
|
\turnoffactive
|
|
$$ [\sin{a}, \sin{2 a}, \sin(2 + a), \sin\left( {a \over b} \right)] $$
|
|
@end tex
|
|
@sp 2
|
|
|
|
First with plain @kbd{d T}, then with @kbd{C-u d T}, then finally with
|
|
@kbd{C-u - d T} (using the example definition
|
|
@samp{\def\foo#1@{\tilde F(#1)@}}:
|
|
|
|
@example
|
|
@group
|
|
[f(a), foo(bar), sin(pi)]
|
|
[f(a), foo(bar), \sin{\pi}]
|
|
[f(a), \hbox@{foo@}(\hbox@{bar@}), \sin@{\pi@}]
|
|
[f(a), \foo@{\hbox@{bar@}@}, \sin@{\pi@}]
|
|
@end group
|
|
@end example
|
|
@tex
|
|
$$ [f(a), foo(bar), \sin{\pi}] $$
|
|
$$ [f(a), \hbox{foo}(\hbox{bar}), \sin{\pi}] $$
|
|
$$ [f(a), \tilde F(\hbox{bar}), \sin{\pi}] $$
|
|
@end tex
|
|
@sp 2
|
|
|
|
First with @samp{\def\evalto@{@}}, then with @samp{\def\evalto#1\to@{@}}:
|
|
|
|
@example
|
|
@group
|
|
2 + 3 => 5
|
|
\evalto 2 + 3 \to 5
|
|
@end group
|
|
@end example
|
|
@tex
|
|
\turnoffactive
|
|
$$ 2 + 3 \to 5 $$
|
|
$$ 5 $$
|
|
@end tex
|
|
@sp 2
|
|
|
|
First with standard @code{\to}, then with @samp{\let\to\Rightarrow}:
|
|
|
|
@example
|
|
@group
|
|
[2 + 3 => 5, a / 2 => (b + c) / 2]
|
|
[@{2 + 3 \to 5@}, @{@{a \over 2@} \to @{b + c \over 2@}@}]
|
|
@end group
|
|
@end example
|
|
@tex
|
|
\turnoffactive
|
|
$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$
|
|
{\let\to\Rightarrow
|
|
$$ [{2 + 3 \to 5}, {{a \over 2} \to {b + c \over 2}}] $$}
|
|
@end tex
|
|
@sp 2
|
|
|
|
Matrices normally, then changing @code{\matrix} to @code{\pmatrix}:
|
|
|
|
@example
|
|
@group
|
|
[ [ a / b, 0 ], [ 0, 2^(x + 1) ] ]
|
|
\matrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
|
|
\pmatrix@{ @{a \over b@} & 0 \\ 0 & 2^@{(x + 1)@} @}
|
|
@end group
|
|
@end example
|
|
@tex
|
|
\turnoffactive
|
|
$$ \matrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
|
|
$$ \pmatrix{ {a \over b} & 0 \cr 0 & 2^{(x + 1)} } $$
|
|
@end tex
|
|
@sp 2
|
|
@end iftex
|
|
|
|
@node Eqn Language Mode, Mathematica Language Mode, TeX and LaTeX Language Modes, Language Modes
|
|
@subsection Eqn Language Mode
|
|
|
|
@noindent
|
|
@kindex d E
|
|
@pindex calc-eqn-language
|
|
@dfn{Eqn} is another popular formatter for math formulas. It is
|
|
designed for use with the TROFF text formatter, and comes standard
|
|
with many versions of Unix. The @kbd{d E} (@code{calc-eqn-language})
|
|
command selects @dfn{eqn} notation.
|
|
|
|
The @dfn{eqn} language's main idiosyncrasy is that whitespace plays
|
|
a significant part in the parsing of the language. For example,
|
|
@samp{sqrt x+1 + y} treats @samp{x+1} as the argument of the
|
|
@code{sqrt} operator. @dfn{Eqn} also understands more conventional
|
|
grouping using curly braces: @samp{sqrt@{x+1@} + y}. Braces are
|
|
required only when the argument contains spaces.
|
|
|
|
In Calc's @dfn{eqn} mode, however, curly braces are required to
|
|
delimit arguments of operators like @code{sqrt}. The first of the
|
|
above examples would treat only the @samp{x} as the argument of
|
|
@code{sqrt}, and in fact @samp{sin x+1} would be interpreted as
|
|
@samp{sin * x + 1}, because @code{sin} is not a special operator
|
|
in the @dfn{eqn} language. If you always surround the argument
|
|
with curly braces, Calc will never misunderstand.
|
|
|
|
Calc also understands parentheses as grouping characters. Another
|
|
peculiarity of @dfn{eqn}'s syntax makes it advisable to separate
|
|
words with spaces from any surrounding characters that aren't curly
|
|
braces, so Calc writes @samp{sin ( x + y )} in @dfn{eqn} mode.
|
|
(The spaces around @code{sin} are important to make @dfn{eqn}
|
|
recognize that @code{sin} should be typeset in a roman font, and
|
|
the spaces around @code{x} and @code{y} are a good idea just in
|
|
case the @dfn{eqn} document has defined special meanings for these
|
|
names, too.)
|
|
|
|
Powers and subscripts are written with the @code{sub} and @code{sup}
|
|
operators, respectively. Note that the caret symbol @samp{^} is
|
|
treated the same as a space in @dfn{eqn} mode, as is the @samp{~}
|
|
symbol (these are used to introduce spaces of various widths into
|
|
the typeset output of @dfn{eqn}).
|
|
|
|
As in La@TeX{} mode, Calc's formatter omits parentheses around the
|
|
arguments of functions like @code{ln} and @code{sin} if they are
|
|
``simple-looking''; in this case Calc surrounds the argument with
|
|
braces, separated by a @samp{~} from the function name: @samp{sin~@{x@}}.
|
|
|
|
Font change codes (like @samp{roman @var{x}}) and positioning codes
|
|
(like @samp{~} and @samp{down @var{n} @var{x}}) are ignored by the
|
|
@dfn{eqn} reader. Also ignored are the words @code{left}, @code{right},
|
|
@code{mark}, and @code{lineup}. Quotation marks in @dfn{eqn} mode input
|
|
are treated the same as curly braces: @samp{sqrt "1+x"} is equivalent to
|
|
@samp{sqrt @{1+x@}}; this is only an approximation to the true meaning
|
|
of quotes in @dfn{eqn}, but it is good enough for most uses.
|
|
|
|
Accent codes (@samp{@var{x} dot}) are handled by treating them as
|
|
function calls (@samp{dot(@var{x})}) internally.
|
|
@xref{TeX and LaTeX Language Modes}, for a table of these accent
|
|
functions. The @code{prime} accent is treated specially if it occurs on
|
|
a variable or function name: @samp{f prime prime @w{( x prime )}} is
|
|
stored internally as @samp{f'@w{'}(x')}. For example, taking the
|
|
derivative of @samp{f(2 x)} with @kbd{a d x} will produce @samp{2 f'(2
|
|
x)}, which @dfn{eqn} mode will display as @samp{2 f prime ( 2 x )}.
|
|
|
|
Assignments are written with the @samp{<-} (left-arrow) symbol,
|
|
and @code{evalto} operators are written with @samp{->} or
|
|
@samp{evalto ... ->} (@pxref{TeX and LaTeX Language Modes}, for a discussion
|
|
of this). The regular Calc symbols @samp{:=} and @samp{=>} are also
|
|
recognized for these operators during reading.
|
|
|
|
Vectors in @dfn{eqn} mode use regular Calc square brackets, but
|
|
matrices are formatted as @samp{matrix @{ ccol @{ a above b @} ... @}}.
|
|
The words @code{lcol} and @code{rcol} are recognized as synonyms
|
|
for @code{ccol} during input, and are generated instead of @code{ccol}
|
|
if the matrix justification mode so specifies.
|
|
|
|
@node Mathematica Language Mode, Maple Language Mode, Eqn Language Mode, Language Modes
|
|
@subsection Mathematica Language Mode
|
|
|
|
@noindent
|
|
@kindex d M
|
|
@pindex calc-mathematica-language
|
|
@cindex Mathematica language
|
|
The @kbd{d M} (@code{calc-mathematica-language}) command selects the
|
|
conventions of Mathematica. Notable differences in Mathematica mode
|
|
are that the names of built-in functions are capitalized, and function
|
|
calls use square brackets instead of parentheses. Thus the Calc
|
|
formula @samp{sin(2 x)} is entered and displayed @w{@samp{Sin[2 x]}} in
|
|
Mathematica mode.
|
|
|
|
Vectors and matrices use curly braces in Mathematica. Complex numbers
|
|
are written @samp{3 + 4 I}. The standard special constants in Calc are
|
|
written @code{Pi}, @code{E}, @code{I}, @code{GoldenRatio}, @code{EulerGamma},
|
|
@code{Infinity}, @code{ComplexInfinity}, and @code{Indeterminate} in
|
|
Mathematica mode.
|
|
Non-decimal numbers are written, e.g., @samp{16^^7fff}. Floating-point
|
|
numbers in scientific notation are written @samp{1.23*10.^3}.
|
|
Subscripts use double square brackets: @samp{a[[i]]}.
|
|
|
|
@node Maple Language Mode, Compositions, Mathematica Language Mode, Language Modes
|
|
@subsection Maple Language Mode
|
|
|
|
@noindent
|
|
@kindex d W
|
|
@pindex calc-maple-language
|
|
@cindex Maple language
|
|
The @kbd{d W} (@code{calc-maple-language}) command selects the
|
|
conventions of Maple.
|
|
|
|
Maple's language is much like C. Underscores are allowed in symbol
|
|
names; square brackets are used for subscripts; explicit @samp{*}s for
|
|
multiplications are required. Use either @samp{^} or @samp{**} to
|
|
denote powers.
|
|
|
|
Maple uses square brackets for lists and curly braces for sets. Calc
|
|
interprets both notations as vectors, and displays vectors with square
|
|
brackets. This means Maple sets will be converted to lists when they
|
|
pass through Calc. As a special case, matrices are written as calls
|
|
to the function @code{matrix}, given a list of lists as the argument,
|
|
and can be read in this form or with all-capitals @code{MATRIX}.
|
|
|
|
The Maple interval notation @samp{2 .. 3} has no surrounding brackets;
|
|
Calc reads @samp{2 .. 3} as the closed interval @samp{[2 .. 3]}, and
|
|
writes any kind of interval as @samp{2 .. 3}. This means you cannot
|
|
see the difference between an open and a closed interval while in
|
|
Maple display mode.
|
|
|
|
Maple writes complex numbers as @samp{3 + 4*I}. Its special constants
|
|
are @code{Pi}, @code{E}, @code{I}, and @code{infinity} (all three of
|
|
@code{inf}, @code{uinf}, and @code{nan} display as @code{infinity}).
|
|
Floating-point numbers are written @samp{1.23*10.^3}.
|
|
|
|
Among things not currently handled by Calc's Maple mode are the
|
|
various quote symbols, procedures and functional operators, and
|
|
inert (@samp{&}) operators.
|
|
|
|
@node Compositions, Syntax Tables, Maple Language Mode, Language Modes
|
|
@subsection Compositions
|
|
|
|
@noindent
|
|
@cindex Compositions
|
|
There are several @dfn{composition functions} which allow you to get
|
|
displays in a variety of formats similar to those in Big language
|
|
mode. Most of these functions do not evaluate to anything; they are
|
|
placeholders which are left in symbolic form by Calc's evaluator but
|
|
are recognized by Calc's display formatting routines.
|
|
|
|
Two of these, @code{string} and @code{bstring}, are described elsewhere.
|
|
@xref{Strings}. For example, @samp{string("ABC")} is displayed as
|
|
@samp{ABC}. When viewed on the stack it will be indistinguishable from
|
|
the variable @code{ABC}, but internally it will be stored as
|
|
@samp{string([65, 66, 67])} and can still be manipulated this way; for
|
|
example, the selection and vector commands @kbd{j 1 v v j u} would
|
|
select the vector portion of this object and reverse the elements, then
|
|
deselect to reveal a string whose characters had been reversed.
|
|
|
|
The composition functions do the same thing in all language modes
|
|
(although their components will of course be formatted in the current
|
|
language mode). The one exception is Unformatted mode (@kbd{d U}),
|
|
which does not give the composition functions any special treatment.
|
|
The functions are discussed here because of their relationship to
|
|
the language modes.
|
|
|
|
@menu
|
|
* Composition Basics::
|
|
* Horizontal Compositions::
|
|
* Vertical Compositions::
|
|
* Other Compositions::
|
|
* Information about Compositions::
|
|
* User-Defined Compositions::
|
|
@end menu
|
|
|
|
@node Composition Basics, Horizontal Compositions, Compositions, Compositions
|
|
@subsubsection Composition Basics
|
|
|
|
@noindent
|
|
Compositions are generally formed by stacking formulas together
|
|
horizontally or vertically in various ways. Those formulas are
|
|
themselves compositions. @TeX{} users will find this analogous
|
|
to @TeX{}'s ``boxes.'' Each multi-line composition has a
|
|
@dfn{baseline}; horizontal compositions use the baselines to
|
|
decide how formulas should be positioned relative to one another.
|
|
For example, in the Big mode formula
|
|
|
|
@example
|
|
@group
|
|
2
|
|
a + b
|
|
17 + ------
|
|
c
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
the second term of the sum is four lines tall and has line three as
|
|
its baseline. Thus when the term is combined with 17, line three
|
|
is placed on the same level as the baseline of 17.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Another important composition concept is @dfn{precedence}. This is
|
|
an integer that represents the binding strength of various operators.
|
|
For example, @samp{*} has higher precedence (195) than @samp{+} (180),
|
|
which means that @samp{(a * b) + c} will be formatted without the
|
|
parentheses, but @samp{a * (b + c)} will keep the parentheses.
|
|
|
|
The operator table used by normal and Big language modes has the
|
|
following precedences:
|
|
|
|
@example
|
|
_ 1200 @r{(subscripts)}
|
|
% 1100 @r{(as in n}%@r{)}
|
|
- 1000 @r{(as in }-@r{n)}
|
|
! 1000 @r{(as in }!@r{n)}
|
|
mod 400
|
|
+/- 300
|
|
!! 210 @r{(as in n}!!@r{)}
|
|
! 210 @r{(as in n}!@r{)}
|
|
^ 200
|
|
* 195 @r{(or implicit multiplication)}
|
|
/ % \ 190
|
|
+ - 180 @r{(as in a}+@r{b)}
|
|
| 170
|
|
< = 160 @r{(and other relations)}
|
|
&& 110
|
|
|| 100
|
|
? : 90
|
|
!!! 85
|
|
&&& 80
|
|
||| 75
|
|
:= 50
|
|
:: 45
|
|
=> 40
|
|
@end example
|
|
|
|
The general rule is that if an operator with precedence @expr{n}
|
|
occurs as an argument to an operator with precedence @expr{m}, then
|
|
the argument is enclosed in parentheses if @expr{n < m}. Top-level
|
|
expressions and expressions which are function arguments, vector
|
|
components, etc., are formatted with precedence zero (so that they
|
|
normally never get additional parentheses).
|
|
|
|
For binary left-associative operators like @samp{+}, the righthand
|
|
argument is actually formatted with one-higher precedence than shown
|
|
in the table. This makes sure @samp{(a + b) + c} omits the parentheses,
|
|
but the unnatural form @samp{a + (b + c)} keeps its parentheses.
|
|
Right-associative operators like @samp{^} format the lefthand argument
|
|
with one-higher precedence.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cprec
|
|
The @code{cprec} function formats an expression with an arbitrary
|
|
precedence. For example, @samp{cprec(abc, 185)} will combine into
|
|
sums and products as follows: @samp{7 + abc}, @samp{7 (abc)} (because
|
|
this @code{cprec} form has higher precedence than addition, but lower
|
|
precedence than multiplication).
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
A final composition issue is @dfn{line breaking}. Calc uses two
|
|
different strategies for ``flat'' and ``non-flat'' compositions.
|
|
A non-flat composition is anything that appears on multiple lines
|
|
(not counting line breaking). Examples would be matrices and Big
|
|
mode powers and quotients. Non-flat compositions are displayed
|
|
exactly as specified. If they come out wider than the current
|
|
window, you must use horizontal scrolling (@kbd{<} and @kbd{>}) to
|
|
view them.
|
|
|
|
Flat compositions, on the other hand, will be broken across several
|
|
lines if they are too wide to fit the window. Certain points in a
|
|
composition are noted internally as @dfn{break points}. Calc's
|
|
general strategy is to fill each line as much as possible, then to
|
|
move down to the next line starting at the first break point that
|
|
didn't fit. However, the line breaker understands the hierarchical
|
|
structure of formulas. It will not break an ``inner'' formula if
|
|
it can use an earlier break point from an ``outer'' formula instead.
|
|
For example, a vector of sums might be formatted as:
|
|
|
|
@example
|
|
@group
|
|
[ a + b + c, d + e + f,
|
|
g + h + i, j + k + l, m ]
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
If the @samp{m} can fit, then so, it seems, could the @samp{g}.
|
|
But Calc prefers to break at the comma since the comma is part
|
|
of a ``more outer'' formula. Calc would break at a plus sign
|
|
only if it had to, say, if the very first sum in the vector had
|
|
itself been too large to fit.
|
|
|
|
Of the composition functions described below, only @code{choriz}
|
|
generates break points. The @code{bstring} function (@pxref{Strings})
|
|
also generates breakable items: A break point is added after every
|
|
space (or group of spaces) except for spaces at the very beginning or
|
|
end of the string.
|
|
|
|
Composition functions themselves count as levels in the formula
|
|
hierarchy, so a @code{choriz} that is a component of a larger
|
|
@code{choriz} will be less likely to be broken. As a special case,
|
|
if a @code{bstring} occurs as a component of a @code{choriz} or
|
|
@code{choriz}-like object (such as a vector or a list of arguments
|
|
in a function call), then the break points in that @code{bstring}
|
|
will be on the same level as the break points of the surrounding
|
|
object.
|
|
|
|
@node Horizontal Compositions, Vertical Compositions, Composition Basics, Compositions
|
|
@subsubsection Horizontal Compositions
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex choriz
|
|
The @code{choriz} function takes a vector of objects and composes
|
|
them horizontally. For example, @samp{choriz([17, a b/c, d])} formats
|
|
as @w{@samp{17a b / cd}} in Normal language mode, or as
|
|
|
|
@example
|
|
@group
|
|
a b
|
|
17---d
|
|
c
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
in Big language mode. This is actually one case of the general
|
|
function @samp{choriz(@var{vec}, @var{sep}, @var{prec})}, where
|
|
either or both of @var{sep} and @var{prec} may be omitted.
|
|
@var{Prec} gives the @dfn{precedence} to use when formatting
|
|
each of the components of @var{vec}. The default precedence is
|
|
the precedence from the surrounding environment.
|
|
|
|
@var{Sep} is a string (i.e., a vector of character codes as might
|
|
be entered with @code{" "} notation) which should separate components
|
|
of the composition. Also, if @var{sep} is given, the line breaker
|
|
will allow lines to be broken after each occurrence of @var{sep}.
|
|
If @var{sep} is omitted, the composition will not be breakable
|
|
(unless any of its component compositions are breakable).
|
|
|
|
For example, @samp{2 choriz([a, b c, d = e], " + ", 180)} is
|
|
formatted as @samp{2 a + b c + (d = e)}. To get the @code{choriz}
|
|
to have precedence 180 ``outwards'' as well as ``inwards,''
|
|
enclose it in a @code{cprec} form: @samp{2 cprec(choriz(...), 180)}
|
|
formats as @samp{2 (a + b c + (d = e))}.
|
|
|
|
The baseline of a horizontal composition is the same as the
|
|
baselines of the component compositions, which are all aligned.
|
|
|
|
@node Vertical Compositions, Other Compositions, Horizontal Compositions, Compositions
|
|
@subsubsection Vertical Compositions
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cvert
|
|
The @code{cvert} function makes a vertical composition. Each
|
|
component of the vector is centered in a column. The baseline of
|
|
the result is by default the top line of the resulting composition.
|
|
For example, @samp{f(cvert([a, bb, ccc]), cvert([a^2 + 1, b^2]))}
|
|
formats in Big mode as
|
|
|
|
@example
|
|
@group
|
|
f( a , 2 )
|
|
bb a + 1
|
|
ccc 2
|
|
b
|
|
@end group
|
|
@end example
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cbase
|
|
There are several special composition functions that work only as
|
|
components of a vertical composition. The @code{cbase} function
|
|
controls the baseline of the vertical composition; the baseline
|
|
will be the same as the baseline of whatever component is enclosed
|
|
in @code{cbase}. Thus @samp{f(cvert([a, cbase(bb), ccc]),
|
|
cvert([a^2 + 1, cbase(b^2)]))} displays as
|
|
|
|
@example
|
|
@group
|
|
2
|
|
a + 1
|
|
a 2
|
|
f(bb , b )
|
|
ccc
|
|
@end group
|
|
@end example
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex ctbase
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cbbase
|
|
There are also @code{ctbase} and @code{cbbase} functions which
|
|
make the baseline of the vertical composition equal to the top
|
|
or bottom line (rather than the baseline) of that component.
|
|
Thus @samp{cvert([cbase(a / b)]) + cvert([ctbase(a / b)]) +
|
|
cvert([cbbase(a / b)])} gives
|
|
|
|
@example
|
|
@group
|
|
a
|
|
a -
|
|
- + a + b
|
|
b -
|
|
b
|
|
@end group
|
|
@end example
|
|
|
|
There should be only one @code{cbase}, @code{ctbase}, or @code{cbbase}
|
|
function in a given vertical composition. These functions can also
|
|
be written with no arguments: @samp{ctbase()} is a zero-height object
|
|
which means the baseline is the top line of the following item, and
|
|
@samp{cbbase()} means the baseline is the bottom line of the preceding
|
|
item.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex crule
|
|
The @code{crule} function builds a ``rule,'' or horizontal line,
|
|
across a vertical composition. By itself @samp{crule()} uses @samp{-}
|
|
characters to build the rule. You can specify any other character,
|
|
e.g., @samp{crule("=")}. The argument must be a character code or
|
|
vector of exactly one character code. It is repeated to match the
|
|
width of the widest item in the stack. For example, a quotient
|
|
with a thick line is @samp{cvert([a + 1, cbase(crule("=")), b^2])}:
|
|
|
|
@example
|
|
@group
|
|
a + 1
|
|
=====
|
|
2
|
|
b
|
|
@end group
|
|
@end example
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex clvert
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex crvert
|
|
Finally, the functions @code{clvert} and @code{crvert} act exactly
|
|
like @code{cvert} except that the items are left- or right-justified
|
|
in the stack. Thus @samp{clvert([a, bb, ccc]) + crvert([a, bb, ccc])}
|
|
gives:
|
|
|
|
@example
|
|
@group
|
|
a + a
|
|
bb bb
|
|
ccc ccc
|
|
@end group
|
|
@end example
|
|
|
|
Like @code{choriz}, the vertical compositions accept a second argument
|
|
which gives the precedence to use when formatting the components.
|
|
Vertical compositions do not support separator strings.
|
|
|
|
@node Other Compositions, Information about Compositions, Vertical Compositions, Compositions
|
|
@subsubsection Other Compositions
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex csup
|
|
The @code{csup} function builds a superscripted expression. For
|
|
example, @samp{csup(a, b)} looks the same as @samp{a^b} does in Big
|
|
language mode. This is essentially a horizontal composition of
|
|
@samp{a} and @samp{b}, where @samp{b} is shifted up so that its
|
|
bottom line is one above the baseline.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex csub
|
|
Likewise, the @code{csub} function builds a subscripted expression.
|
|
This shifts @samp{b} down so that its top line is one below the
|
|
bottom line of @samp{a} (note that this is not quite analogous to
|
|
@code{csup}). Other arrangements can be obtained by using
|
|
@code{choriz} and @code{cvert} directly.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cflat
|
|
The @code{cflat} function formats its argument in ``flat'' mode,
|
|
as obtained by @samp{d O}, if the current language mode is normal
|
|
or Big. It has no effect in other language modes. For example,
|
|
@samp{a^(b/c)} is formatted by Big mode like @samp{csup(a, cflat(b/c))}
|
|
to improve its readability.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cspace
|
|
The @code{cspace} function creates horizontal space. For example,
|
|
@samp{cspace(4)} is effectively the same as @samp{string(" ")}.
|
|
A second string (i.e., vector of characters) argument is repeated
|
|
instead of the space character. For example, @samp{cspace(4, "ab")}
|
|
looks like @samp{abababab}. If the second argument is not a string,
|
|
it is formatted in the normal way and then several copies of that
|
|
are composed together: @samp{cspace(4, a^2)} yields
|
|
|
|
@example
|
|
@group
|
|
2 2 2 2
|
|
a a a a
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
If the number argument is zero, this is a zero-width object.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cvspace
|
|
The @code{cvspace} function creates vertical space, or a vertical
|
|
stack of copies of a certain string or formatted object. The
|
|
baseline is the center line of the resulting stack. A numerical
|
|
argument of zero will produce an object which contributes zero
|
|
height if used in a vertical composition.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex ctspace
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cbspace
|
|
There are also @code{ctspace} and @code{cbspace} functions which
|
|
create vertical space with the baseline the same as the baseline
|
|
of the top or bottom copy, respectively, of the second argument.
|
|
Thus @samp{cvspace(2, a/b) + ctspace(2, a/b) + cbspace(2, a/b)}
|
|
displays as:
|
|
|
|
@example
|
|
@group
|
|
a
|
|
-
|
|
a b
|
|
- a a
|
|
b + - + -
|
|
a b b
|
|
- a
|
|
b -
|
|
b
|
|
@end group
|
|
@end example
|
|
|
|
@node Information about Compositions, User-Defined Compositions, Other Compositions, Compositions
|
|
@subsubsection Information about Compositions
|
|
|
|
@noindent
|
|
The functions in this section are actual functions; they compose their
|
|
arguments according to the current language and other display modes,
|
|
then return a certain measurement of the composition as an integer.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cwidth
|
|
The @code{cwidth} function measures the width, in characters, of a
|
|
composition. For example, @samp{cwidth(a + b)} is 5, and
|
|
@samp{cwidth(a / b)} is 5 in Normal mode, 1 in Big mode, and 11 in
|
|
@TeX{} mode (for @samp{@{a \over b@}}). The argument may involve
|
|
the composition functions described in this section.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cheight
|
|
The @code{cheight} function measures the height of a composition.
|
|
This is the total number of lines in the argument's printed form.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cascent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex cdescent
|
|
The functions @code{cascent} and @code{cdescent} measure the amount
|
|
of the height that is above (and including) the baseline, or below
|
|
the baseline, respectively. Thus @samp{cascent(@var{x}) + cdescent(@var{x})}
|
|
always equals @samp{cheight(@var{x})}. For a one-line formula like
|
|
@samp{a + b}, @code{cascent} returns 1 and @code{cdescent} returns 0.
|
|
For @samp{a / b} in Big mode, @code{cascent} returns 2 and @code{cdescent}
|
|
returns 1. The only formula for which @code{cascent} will return zero
|
|
is @samp{cvspace(0)} or equivalents.
|
|
|
|
@node User-Defined Compositions, , Information about Compositions, Compositions
|
|
@subsubsection User-Defined Compositions
|
|
|
|
@noindent
|
|
@kindex Z C
|
|
@pindex calc-user-define-composition
|
|
The @kbd{Z C} (@code{calc-user-define-composition}) command lets you
|
|
define the display format for any algebraic function. You provide a
|
|
formula containing a certain number of argument variables on the stack.
|
|
Any time Calc formats a call to the specified function in the current
|
|
language mode and with that number of arguments, Calc effectively
|
|
replaces the function call with that formula with the arguments
|
|
replaced.
|
|
|
|
Calc builds the default argument list by sorting all the variable names
|
|
that appear in the formula into alphabetical order. You can edit this
|
|
argument list before pressing @key{RET} if you wish. Any variables in
|
|
the formula that do not appear in the argument list will be displayed
|
|
literally; any arguments that do not appear in the formula will not
|
|
affect the display at all.
|
|
|
|
You can define formats for built-in functions, for functions you have
|
|
defined with @kbd{Z F} (@pxref{Algebraic Definitions}), or for functions
|
|
which have no definitions but are being used as purely syntactic objects.
|
|
You can define different formats for each language mode, and for each
|
|
number of arguments, using a succession of @kbd{Z C} commands. When
|
|
Calc formats a function call, it first searches for a format defined
|
|
for the current language mode (and number of arguments); if there is
|
|
none, it uses the format defined for the Normal language mode. If
|
|
neither format exists, Calc uses its built-in standard format for that
|
|
function (usually just @samp{@var{func}(@var{args})}).
|
|
|
|
If you execute @kbd{Z C} with the number 0 on the stack instead of a
|
|
formula, any defined formats for the function in the current language
|
|
mode will be removed. The function will revert to its standard format.
|
|
|
|
For example, the default format for the binomial coefficient function
|
|
@samp{choose(n, m)} in the Big language mode is
|
|
|
|
@example
|
|
@group
|
|
n
|
|
( )
|
|
m
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
You might prefer the notation,
|
|
|
|
@example
|
|
@group
|
|
C
|
|
n m
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
To define this notation, first make sure you are in Big mode,
|
|
then put the formula
|
|
|
|
@smallexample
|
|
choriz([cvert([cvspace(1), n]), C, cvert([cvspace(1), m])])
|
|
@end smallexample
|
|
|
|
@noindent
|
|
on the stack and type @kbd{Z C}. Answer the first prompt with
|
|
@code{choose}. The second prompt will be the default argument list
|
|
of @samp{(C m n)}. Edit this list to be @samp{(n m)} and press
|
|
@key{RET}. Now, try it out: For example, turn simplification
|
|
off with @kbd{m O} and enter @samp{choose(a,b) + choose(7,3)}
|
|
as an algebraic entry.
|
|
|
|
@example
|
|
@group
|
|
C + C
|
|
a b 7 3
|
|
@end group
|
|
@end example
|
|
|
|
As another example, let's define the usual notation for Stirling
|
|
numbers of the first kind, @samp{stir1(n, m)}. This is just like
|
|
the regular format for binomial coefficients but with square brackets
|
|
instead of parentheses.
|
|
|
|
@smallexample
|
|
choriz([string("["), cvert([n, cbase(cvspace(1)), m]), string("]")])
|
|
@end smallexample
|
|
|
|
Now type @kbd{Z C stir1 @key{RET}}, edit the argument list to
|
|
@samp{(n m)}, and type @key{RET}.
|
|
|
|
The formula provided to @kbd{Z C} usually will involve composition
|
|
functions, but it doesn't have to. Putting the formula @samp{a + b + c}
|
|
onto the stack and typing @kbd{Z C foo @key{RET} @key{RET}} would define
|
|
the function @samp{foo(x,y,z)} to display like @samp{x + y + z}.
|
|
This ``sum'' will act exactly like a real sum for all formatting
|
|
purposes (it will be parenthesized the same, and so on). However
|
|
it will be computationally unrelated to a sum. For example, the
|
|
formula @samp{2 * foo(1, 2, 3)} will display as @samp{2 (1 + 2 + 3)}.
|
|
Operator precedences have caused the ``sum'' to be written in
|
|
parentheses, but the arguments have not actually been summed.
|
|
(Generally a display format like this would be undesirable, since
|
|
it can easily be confused with a real sum.)
|
|
|
|
The special function @code{eval} can be used inside a @kbd{Z C}
|
|
composition formula to cause all or part of the formula to be
|
|
evaluated at display time. For example, if the formula is
|
|
@samp{a + eval(b + c)}, then @samp{foo(1, 2, 3)} will be displayed
|
|
as @samp{1 + 5}. Evaluation will use the default simplifications,
|
|
regardless of the current simplification mode. There are also
|
|
@code{evalsimp} and @code{evalextsimp} which simplify as if by
|
|
@kbd{a s} and @kbd{a e} (respectively). Note that these ``functions''
|
|
operate only in the context of composition formulas (and also in
|
|
rewrite rules, where they serve a similar purpose; @pxref{Rewrite
|
|
Rules}). On the stack, a call to @code{eval} will be left in
|
|
symbolic form.
|
|
|
|
It is not a good idea to use @code{eval} except as a last resort.
|
|
It can cause the display of formulas to be extremely slow. For
|
|
example, while @samp{eval(a + b)} might seem quite fast and simple,
|
|
there are several situations where it could be slow. For example,
|
|
@samp{a} and/or @samp{b} could be polar complex numbers, in which
|
|
case doing the sum requires trigonometry. Or, @samp{a} could be
|
|
the factorial @samp{fact(100)} which is unevaluated because you
|
|
have typed @kbd{m O}; @code{eval} will evaluate it anyway to
|
|
produce a large, unwieldy integer.
|
|
|
|
You can save your display formats permanently using the @kbd{Z P}
|
|
command (@pxref{Creating User Keys}).
|
|
|
|
@node Syntax Tables, , Compositions, Language Modes
|
|
@subsection Syntax Tables
|
|
|
|
@noindent
|
|
@cindex Syntax tables
|
|
@cindex Parsing formulas, customized
|
|
Syntax tables do for input what compositions do for output: They
|
|
allow you to teach custom notations to Calc's formula parser.
|
|
Calc keeps a separate syntax table for each language mode.
|
|
|
|
(Note that the Calc ``syntax tables'' discussed here are completely
|
|
unrelated to the syntax tables described in the Emacs manual.)
|
|
|
|
@kindex Z S
|
|
@pindex calc-edit-user-syntax
|
|
The @kbd{Z S} (@code{calc-edit-user-syntax}) command edits the
|
|
syntax table for the current language mode. If you want your
|
|
syntax to work in any language, define it in the Normal language
|
|
mode. Type @kbd{C-c C-c} to finish editing the syntax table, or
|
|
@kbd{C-x k} to cancel the edit. The @kbd{m m} command saves all
|
|
the syntax tables along with the other mode settings;
|
|
@pxref{General Mode Commands}.
|
|
|
|
@menu
|
|
* Syntax Table Basics::
|
|
* Precedence in Syntax Tables::
|
|
* Advanced Syntax Patterns::
|
|
* Conditional Syntax Rules::
|
|
@end menu
|
|
|
|
@node Syntax Table Basics, Precedence in Syntax Tables, Syntax Tables, Syntax Tables
|
|
@subsubsection Syntax Table Basics
|
|
|
|
@noindent
|
|
@dfn{Parsing} is the process of converting a raw string of characters,
|
|
such as you would type in during algebraic entry, into a Calc formula.
|
|
Calc's parser works in two stages. First, the input is broken down
|
|
into @dfn{tokens}, such as words, numbers, and punctuation symbols
|
|
like @samp{+}, @samp{:=}, and @samp{+/-}. Space between tokens is
|
|
ignored (except when it serves to separate adjacent words). Next,
|
|
the parser matches this string of tokens against various built-in
|
|
syntactic patterns, such as ``an expression followed by @samp{+}
|
|
followed by another expression'' or ``a name followed by @samp{(},
|
|
zero or more expressions separated by commas, and @samp{)}.''
|
|
|
|
A @dfn{syntax table} is a list of user-defined @dfn{syntax rules},
|
|
which allow you to specify new patterns to define your own
|
|
favorite input notations. Calc's parser always checks the syntax
|
|
table for the current language mode, then the table for the Normal
|
|
language mode, before it uses its built-in rules to parse an
|
|
algebraic formula you have entered. Each syntax rule should go on
|
|
its own line; it consists of a @dfn{pattern}, a @samp{:=} symbol,
|
|
and a Calc formula with an optional @dfn{condition}. (Syntax rules
|
|
resemble algebraic rewrite rules, but the notation for patterns is
|
|
completely different.)
|
|
|
|
A syntax pattern is a list of tokens, separated by spaces.
|
|
Except for a few special symbols, tokens in syntax patterns are
|
|
matched literally, from left to right. For example, the rule,
|
|
|
|
@example
|
|
foo ( ) := 2+3
|
|
@end example
|
|
|
|
@noindent
|
|
would cause Calc to parse the formula @samp{4+foo()*5} as if it
|
|
were @samp{4+(2+3)*5}. Notice that the parentheses were written
|
|
as two separate tokens in the rule. As a result, the rule works
|
|
for both @samp{foo()} and @w{@samp{foo ( )}}. If we had written
|
|
the rule as @samp{foo () := 2+3}, then Calc would treat @samp{()}
|
|
as a single, indivisible token, so that @w{@samp{foo( )}} would
|
|
not be recognized by the rule. (It would be parsed as a regular
|
|
zero-argument function call instead.) In fact, this rule would
|
|
also make trouble for the rest of Calc's parser: An unrelated
|
|
formula like @samp{bar()} would now be tokenized into @samp{bar ()}
|
|
instead of @samp{bar ( )}, so that the standard parser for function
|
|
calls would no longer recognize it!
|
|
|
|
While it is possible to make a token with a mixture of letters
|
|
and punctuation symbols, this is not recommended. It is better to
|
|
break it into several tokens, as we did with @samp{foo()} above.
|
|
|
|
The symbol @samp{#} in a syntax pattern matches any Calc expression.
|
|
On the righthand side, the things that matched the @samp{#}s can
|
|
be referred to as @samp{#1}, @samp{#2}, and so on (where @samp{#1}
|
|
matches the leftmost @samp{#} in the pattern). For example, these
|
|
rules match a user-defined function, prefix operator, infix operator,
|
|
and postfix operator, respectively:
|
|
|
|
@example
|
|
foo ( # ) := myfunc(#1)
|
|
foo # := myprefix(#1)
|
|
# foo # := myinfix(#1,#2)
|
|
# foo := mypostfix(#1)
|
|
@end example
|
|
|
|
Thus @samp{foo(3)} will parse as @samp{myfunc(3)}, and @samp{2+3 foo}
|
|
will parse as @samp{mypostfix(2+3)}.
|
|
|
|
It is important to write the first two rules in the order shown,
|
|
because Calc tries rules in order from first to last. If the
|
|
pattern @samp{foo #} came first, it would match anything that could
|
|
match the @samp{foo ( # )} rule, since an expression in parentheses
|
|
is itself a valid expression. Thus the @w{@samp{foo ( # )}} rule would
|
|
never get to match anything. Likewise, the last two rules must be
|
|
written in the order shown or else @samp{3 foo 4} will be parsed as
|
|
@samp{mypostfix(3) * 4}. (Of course, the best way to avoid these
|
|
ambiguities is not to use the same symbol in more than one way at
|
|
the same time! In case you're not convinced, try the following
|
|
exercise: How will the above rules parse the input @samp{foo(3,4)},
|
|
if at all? Work it out for yourself, then try it in Calc and see.)
|
|
|
|
Calc is quite flexible about what sorts of patterns are allowed.
|
|
The only rule is that every pattern must begin with a literal
|
|
token (like @samp{foo} in the first two patterns above), or with
|
|
a @samp{#} followed by a literal token (as in the last two
|
|
patterns). After that, any mixture is allowed, although putting
|
|
two @samp{#}s in a row will not be very useful since two
|
|
expressions with nothing between them will be parsed as one
|
|
expression that uses implicit multiplication.
|
|
|
|
As a more practical example, Maple uses the notation
|
|
@samp{sum(a(i), i=1..10)} for sums, which Calc's Maple mode doesn't
|
|
recognize at present. To handle this syntax, we simply add the
|
|
rule,
|
|
|
|
@example
|
|
sum ( # , # = # .. # ) := sum(#1,#2,#3,#4)
|
|
@end example
|
|
|
|
@noindent
|
|
to the Maple mode syntax table. As another example, C mode can't
|
|
read assignment operators like @samp{++} and @samp{*=}. We can
|
|
define these operators quite easily:
|
|
|
|
@example
|
|
# *= # := muleq(#1,#2)
|
|
# ++ := postinc(#1)
|
|
++ # := preinc(#1)
|
|
@end example
|
|
|
|
@noindent
|
|
To complete the job, we would use corresponding composition functions
|
|
and @kbd{Z C} to cause these functions to display in their respective
|
|
Maple and C notations. (Note that the C example ignores issues of
|
|
operator precedence, which are discussed in the next section.)
|
|
|
|
You can enclose any token in quotes to prevent its usual
|
|
interpretation in syntax patterns:
|
|
|
|
@example
|
|
# ":=" # := becomes(#1,#2)
|
|
@end example
|
|
|
|
Quotes also allow you to include spaces in a token, although once
|
|
again it is generally better to use two tokens than one token with
|
|
an embedded space. To include an actual quotation mark in a quoted
|
|
token, precede it with a backslash. (This also works to include
|
|
backslashes in tokens.)
|
|
|
|
@example
|
|
# "bad token" # "/\"\\" # := silly(#1,#2,#3)
|
|
@end example
|
|
|
|
@noindent
|
|
This will parse @samp{3 bad token 4 /"\ 5} to @samp{silly(3,4,5)}.
|
|
|
|
The token @kbd{#} has a predefined meaning in Calc's formula parser;
|
|
it is not valid to use @samp{"#"} in a syntax rule. However, longer
|
|
tokens that include the @samp{#} character are allowed. Also, while
|
|
@samp{"$"} and @samp{"\""} are allowed as tokens, their presence in
|
|
the syntax table will prevent those characters from working in their
|
|
usual ways (referring to stack entries and quoting strings,
|
|
respectively).
|
|
|
|
Finally, the notation @samp{%%} anywhere in a syntax table causes
|
|
the rest of the line to be ignored as a comment.
|
|
|
|
@node Precedence in Syntax Tables, Advanced Syntax Patterns, Syntax Table Basics, Syntax Tables
|
|
@subsubsection Precedence
|
|
|
|
@noindent
|
|
Different operators are generally assigned different @dfn{precedences}.
|
|
By default, an operator defined by a rule like
|
|
|
|
@example
|
|
# foo # := foo(#1,#2)
|
|
@end example
|
|
|
|
@noindent
|
|
will have an extremely low precedence, so that @samp{2*3+4 foo 5 == 6}
|
|
will be parsed as @samp{(2*3+4) foo (5 == 6)}. To change the
|
|
precedence of an operator, use the notation @samp{#/@var{p}} in
|
|
place of @samp{#}, where @var{p} is an integer precedence level.
|
|
For example, 185 lies between the precedences for @samp{+} and
|
|
@samp{*}, so if we change this rule to
|
|
|
|
@example
|
|
#/185 foo #/186 := foo(#1,#2)
|
|
@end example
|
|
|
|
@noindent
|
|
then @samp{2+3 foo 4*5} will be parsed as @samp{2+(3 foo (4*5))}.
|
|
Also, because we've given the righthand expression slightly higher
|
|
precedence, our new operator will be left-associative:
|
|
@samp{1 foo 2 foo 3} will be parsed as @samp{(1 foo 2) foo 3}.
|
|
By raising the precedence of the lefthand expression instead, we
|
|
can create a right-associative operator.
|
|
|
|
@xref{Composition Basics}, for a table of precedences of the
|
|
standard Calc operators. For the precedences of operators in other
|
|
language modes, look in the Calc source file @file{calc-lang.el}.
|
|
|
|
@node Advanced Syntax Patterns, Conditional Syntax Rules, Precedence in Syntax Tables, Syntax Tables
|
|
@subsubsection Advanced Syntax Patterns
|
|
|
|
@noindent
|
|
To match a function with a variable number of arguments, you could
|
|
write
|
|
|
|
@example
|
|
foo ( # ) := myfunc(#1)
|
|
foo ( # , # ) := myfunc(#1,#2)
|
|
foo ( # , # , # ) := myfunc(#1,#2,#3)
|
|
@end example
|
|
|
|
@noindent
|
|
but this isn't very elegant. To match variable numbers of items,
|
|
Calc uses some notations inspired regular expressions and the
|
|
``extended BNF'' style used by some language designers.
|
|
|
|
@example
|
|
foo ( @{ # @}*, ) := apply(myfunc,#1)
|
|
@end example
|
|
|
|
The token @samp{@{} introduces a repeated or optional portion.
|
|
One of the three tokens @samp{@}*}, @samp{@}+}, or @samp{@}?}
|
|
ends the portion. These will match zero or more, one or more,
|
|
or zero or one copies of the enclosed pattern, respectively.
|
|
In addition, @samp{@}*} and @samp{@}+} can be followed by a
|
|
separator token (with no space in between, as shown above).
|
|
Thus @samp{@{ # @}*,} matches nothing, or one expression, or
|
|
several expressions separated by commas.
|
|
|
|
A complete @samp{@{ ... @}} item matches as a vector of the
|
|
items that matched inside it. For example, the above rule will
|
|
match @samp{foo(1,2,3)} to get @samp{apply(myfunc,[1,2,3])}.
|
|
The Calc @code{apply} function takes a function name and a vector
|
|
of arguments and builds a call to the function with those
|
|
arguments, so the net result is the formula @samp{myfunc(1,2,3)}.
|
|
|
|
If the body of a @samp{@{ ... @}} contains several @samp{#}s
|
|
(or nested @samp{@{ ... @}} constructs), then the items will be
|
|
strung together into the resulting vector. If the body
|
|
does not contain anything but literal tokens, the result will
|
|
always be an empty vector.
|
|
|
|
@example
|
|
foo ( @{ # , # @}+, ) := bar(#1)
|
|
foo ( @{ @{ # @}*, @}*; ) := matrix(#1)
|
|
@end example
|
|
|
|
@noindent
|
|
will parse @samp{foo(1, 2, 3, 4)} as @samp{bar([1, 2, 3, 4])}, and
|
|
@samp{foo(1, 2; 3, 4)} as @samp{matrix([[1, 2], [3, 4]])}. Also, after
|
|
some thought it's easy to see how this pair of rules will parse
|
|
@samp{foo(1, 2, 3)} as @samp{matrix([[1, 2, 3]])}, since the first
|
|
rule will only match an even number of arguments. The rule
|
|
|
|
@example
|
|
foo ( # @{ , # , # @}? ) := bar(#1,#2)
|
|
@end example
|
|
|
|
@noindent
|
|
will parse @samp{foo(2,3,4)} as @samp{bar(2,[3,4])}, and
|
|
@samp{foo(2)} as @samp{bar(2,[])}.
|
|
|
|
The notation @samp{@{ ... @}?.} (note the trailing period) works
|
|
just the same as regular @samp{@{ ... @}?}, except that it does not
|
|
count as an argument; the following two rules are equivalent:
|
|
|
|
@example
|
|
foo ( # , @{ also @}? # ) := bar(#1,#3)
|
|
foo ( # , @{ also @}?. # ) := bar(#1,#2)
|
|
@end example
|
|
|
|
@noindent
|
|
Note that in the first case the optional text counts as @samp{#2},
|
|
which will always be an empty vector, but in the second case no
|
|
empty vector is produced.
|
|
|
|
Another variant is @samp{@{ ... @}?$}, which means the body is
|
|
optional only at the end of the input formula. All built-in syntax
|
|
rules in Calc use this for closing delimiters, so that during
|
|
algebraic entry you can type @kbd{[sqrt(2), sqrt(3 @key{RET}}, omitting
|
|
the closing parenthesis and bracket. Calc does this automatically
|
|
for trailing @samp{)}, @samp{]}, and @samp{>} tokens in syntax
|
|
rules, but you can use @samp{@{ ... @}?$} explicitly to get
|
|
this effect with any token (such as @samp{"@}"} or @samp{end}).
|
|
Like @samp{@{ ... @}?.}, this notation does not count as an
|
|
argument. Conversely, you can use quotes, as in @samp{")"}, to
|
|
prevent a closing-delimiter token from being automatically treated
|
|
as optional.
|
|
|
|
Calc's parser does not have full backtracking, which means some
|
|
patterns will not work as you might expect:
|
|
|
|
@example
|
|
foo ( @{ # , @}? # , # ) := bar(#1,#2,#3)
|
|
@end example
|
|
|
|
@noindent
|
|
Here we are trying to make the first argument optional, so that
|
|
@samp{foo(2,3)} parses as @samp{bar([],2,3)}. Unfortunately, Calc
|
|
first tries to match @samp{2,} against the optional part of the
|
|
pattern, finds a match, and so goes ahead to match the rest of the
|
|
pattern. Later on it will fail to match the second comma, but it
|
|
doesn't know how to go back and try the other alternative at that
|
|
point. One way to get around this would be to use two rules:
|
|
|
|
@example
|
|
foo ( # , # , # ) := bar([#1],#2,#3)
|
|
foo ( # , # ) := bar([],#1,#2)
|
|
@end example
|
|
|
|
More precisely, when Calc wants to match an optional or repeated
|
|
part of a pattern, it scans forward attempting to match that part.
|
|
If it reaches the end of the optional part without failing, it
|
|
``finalizes'' its choice and proceeds. If it fails, though, it
|
|
backs up and tries the other alternative. Thus Calc has ``partial''
|
|
backtracking. A fully backtracking parser would go on to make sure
|
|
the rest of the pattern matched before finalizing the choice.
|
|
|
|
@node Conditional Syntax Rules, , Advanced Syntax Patterns, Syntax Tables
|
|
@subsubsection Conditional Syntax Rules
|
|
|
|
@noindent
|
|
It is possible to attach a @dfn{condition} to a syntax rule. For
|
|
example, the rules
|
|
|
|
@example
|
|
foo ( # ) := ifoo(#1) :: integer(#1)
|
|
foo ( # ) := gfoo(#1)
|
|
@end example
|
|
|
|
@noindent
|
|
will parse @samp{foo(3)} as @samp{ifoo(3)}, but will parse
|
|
@samp{foo(3.5)} and @samp{foo(x)} as calls to @code{gfoo}. Any
|
|
number of conditions may be attached; all must be true for the
|
|
rule to succeed. A condition is ``true'' if it evaluates to a
|
|
nonzero number. @xref{Logical Operations}, for a list of Calc
|
|
functions like @code{integer} that perform logical tests.
|
|
|
|
The exact sequence of events is as follows: When Calc tries a
|
|
rule, it first matches the pattern as usual. It then substitutes
|
|
@samp{#1}, @samp{#2}, etc., in the conditions, if any. Next, the
|
|
conditions are simplified and evaluated in order from left to right,
|
|
as if by the @w{@kbd{a s}} algebra command (@pxref{Simplifying Formulas}).
|
|
Each result is true if it is a nonzero number, or an expression
|
|
that can be proven to be nonzero (@pxref{Declarations}). If the
|
|
results of all conditions are true, the expression (such as
|
|
@samp{ifoo(#1)}) has its @samp{#}s substituted, and that is the
|
|
result of the parse. If the result of any condition is false, Calc
|
|
goes on to try the next rule in the syntax table.
|
|
|
|
Syntax rules also support @code{let} conditions, which operate in
|
|
exactly the same way as they do in algebraic rewrite rules.
|
|
@xref{Other Features of Rewrite Rules}, for details. A @code{let}
|
|
condition is always true, but as a side effect it defines a
|
|
variable which can be used in later conditions, and also in the
|
|
expression after the @samp{:=} sign:
|
|
|
|
@example
|
|
foo ( # ) := hifoo(x) :: let(x := #1 + 0.5) :: dnumint(x)
|
|
@end example
|
|
|
|
@noindent
|
|
The @code{dnumint} function tests if a value is numerically an
|
|
integer, i.e., either a true integer or an integer-valued float.
|
|
This rule will parse @code{foo} with a half-integer argument,
|
|
like @samp{foo(3.5)}, to a call like @samp{hifoo(4.)}.
|
|
|
|
The lefthand side of a syntax rule @code{let} must be a simple
|
|
variable, not the arbitrary pattern that is allowed in rewrite
|
|
rules.
|
|
|
|
The @code{matches} function is also treated specially in syntax
|
|
rule conditions (again, in the same way as in rewrite rules).
|
|
@xref{Matching Commands}. If the matching pattern contains
|
|
meta-variables, then those meta-variables may be used in later
|
|
conditions and in the result expression. The arguments to
|
|
@code{matches} are not evaluated in this situation.
|
|
|
|
@example
|
|
sum ( # , # ) := sum(#1,a,b,c) :: matches(#2, a=[b..c])
|
|
@end example
|
|
|
|
@noindent
|
|
This is another way to implement the Maple mode @code{sum} notation.
|
|
In this approach, we allow @samp{#2} to equal the whole expression
|
|
@samp{i=1..10}. Then, we use @code{matches} to break it apart into
|
|
its components. If the expression turns out not to match the pattern,
|
|
the syntax rule will fail. Note that @kbd{Z S} always uses Calc's
|
|
Normal language mode for editing expressions in syntax rules, so we
|
|
must use regular Calc notation for the interval @samp{[b..c]} that
|
|
will correspond to the Maple mode interval @samp{1..10}.
|
|
|
|
@node Modes Variable, Calc Mode Line, Language Modes, Mode Settings
|
|
@section The @code{Modes} Variable
|
|
|
|
@noindent
|
|
@kindex m g
|
|
@pindex calc-get-modes
|
|
The @kbd{m g} (@code{calc-get-modes}) command pushes onto the stack
|
|
a vector of numbers that describes the various mode settings that
|
|
are in effect. With a numeric prefix argument, it pushes only the
|
|
@var{n}th mode, i.e., the @var{n}th element of this vector. Keyboard
|
|
macros can use the @kbd{m g} command to modify their behavior based
|
|
on the current mode settings.
|
|
|
|
@cindex @code{Modes} variable
|
|
@vindex Modes
|
|
The modes vector is also available in the special variable
|
|
@code{Modes}. In other words, @kbd{m g} is like @kbd{s r Modes @key{RET}}.
|
|
It will not work to store into this variable; in fact, if you do,
|
|
@code{Modes} will cease to track the current modes. (The @kbd{m g}
|
|
command will continue to work, however.)
|
|
|
|
In general, each number in this vector is suitable as a numeric
|
|
prefix argument to the associated mode-setting command. (Recall
|
|
that the @kbd{~} key takes a number from the stack and gives it as
|
|
a numeric prefix to the next command.)
|
|
|
|
The elements of the modes vector are as follows:
|
|
|
|
@enumerate
|
|
@item
|
|
Current precision. Default is 12; associated command is @kbd{p}.
|
|
|
|
@item
|
|
Binary word size. Default is 32; associated command is @kbd{b w}.
|
|
|
|
@item
|
|
Stack size (not counting the value about to be pushed by @kbd{m g}).
|
|
This is zero if @kbd{m g} is executed with an empty stack.
|
|
|
|
@item
|
|
Number radix. Default is 10; command is @kbd{d r}.
|
|
|
|
@item
|
|
Floating-point format. This is the number of digits, plus the
|
|
constant 0 for normal notation, 10000 for scientific notation,
|
|
20000 for engineering notation, or 30000 for fixed-point notation.
|
|
These codes are acceptable as prefix arguments to the @kbd{d n}
|
|
command, but note that this may lose information: For example,
|
|
@kbd{d s} and @kbd{C-u 12 d s} have similar (but not quite
|
|
identical) effects if the current precision is 12, but they both
|
|
produce a code of 10012, which will be treated by @kbd{d n} as
|
|
@kbd{C-u 12 d s}. If the precision then changes, the float format
|
|
will still be frozen at 12 significant figures.
|
|
|
|
@item
|
|
Angular mode. Default is 1 (degrees). Other values are 2 (radians)
|
|
and 3 (HMS). The @kbd{m d} command accepts these prefixes.
|
|
|
|
@item
|
|
Symbolic mode. Value is 0 or 1; default is 0. Command is @kbd{m s}.
|
|
|
|
@item
|
|
Fraction mode. Value is 0 or 1; default is 0. Command is @kbd{m f}.
|
|
|
|
@item
|
|
Polar mode. Value is 0 (rectangular) or 1 (polar); default is 0.
|
|
Command is @kbd{m p}.
|
|
|
|
@item
|
|
Matrix/Scalar mode. Default value is @mathit{-1}. Value is 0 for Scalar
|
|
mode, @mathit{-2} for Matrix mode, @mathit{-3} for square Matrix mode,
|
|
or @var{N} for
|
|
@texline @math{N\times N}
|
|
@infoline @var{N}x@var{N}
|
|
Matrix mode. Command is @kbd{m v}.
|
|
|
|
@item
|
|
Simplification mode. Default is 1. Value is @mathit{-1} for off (@kbd{m O}),
|
|
0 for @kbd{m N}, 2 for @kbd{m B}, 3 for @kbd{m A}, 4 for @kbd{m E},
|
|
or 5 for @w{@kbd{m U}}. The @kbd{m D} command accepts these prefixes.
|
|
|
|
@item
|
|
Infinite mode. Default is @mathit{-1} (off). Value is 1 if the mode is on,
|
|
or 0 if the mode is on with positive zeros. Command is @kbd{m i}.
|
|
@end enumerate
|
|
|
|
For example, the sequence @kbd{M-1 m g @key{RET} 2 + ~ p} increases the
|
|
precision by two, leaving a copy of the old precision on the stack.
|
|
Later, @kbd{~ p} will restore the original precision using that
|
|
stack value. (This sequence might be especially useful inside a
|
|
keyboard macro.)
|
|
|
|
As another example, @kbd{M-3 m g 1 - ~ @key{DEL}} deletes all but the
|
|
oldest (bottommost) stack entry.
|
|
|
|
Yet another example: The HP-48 ``round'' command rounds a number
|
|
to the current displayed precision. You could roughly emulate this
|
|
in Calc with the sequence @kbd{M-5 m g 10000 % ~ c c}. (This
|
|
would not work for fixed-point mode, but it wouldn't be hard to
|
|
do a full emulation with the help of the @kbd{Z [} and @kbd{Z ]}
|
|
programming commands. @xref{Conditionals in Macros}.)
|
|
|
|
@node Calc Mode Line, , Modes Variable, Mode Settings
|
|
@section The Calc Mode Line
|
|
|
|
@noindent
|
|
@cindex Mode line indicators
|
|
This section is a summary of all symbols that can appear on the
|
|
Calc mode line, the highlighted bar that appears under the Calc
|
|
stack window (or under an editing window in Embedded mode).
|
|
|
|
The basic mode line format is:
|
|
|
|
@example
|
|
--%%-Calc: 12 Deg @var{other modes} (Calculator)
|
|
@end example
|
|
|
|
The @samp{%%} is the Emacs symbol for ``read-only''; it shows that
|
|
regular Emacs commands are not allowed to edit the stack buffer
|
|
as if it were text.
|
|
|
|
The word @samp{Calc:} changes to @samp{CalcEmbed:} if Embedded mode
|
|
is enabled. The words after this describe the various Calc modes
|
|
that are in effect.
|
|
|
|
The first mode is always the current precision, an integer.
|
|
The second mode is always the angular mode, either @code{Deg},
|
|
@code{Rad}, or @code{Hms}.
|
|
|
|
Here is a complete list of the remaining symbols that can appear
|
|
on the mode line:
|
|
|
|
@table @code
|
|
@item Alg
|
|
Algebraic mode (@kbd{m a}; @pxref{Algebraic Entry}).
|
|
|
|
@item Alg[(
|
|
Incomplete algebraic mode (@kbd{C-u m a}).
|
|
|
|
@item Alg*
|
|
Total algebraic mode (@kbd{m t}).
|
|
|
|
@item Symb
|
|
Symbolic mode (@kbd{m s}; @pxref{Symbolic Mode}).
|
|
|
|
@item Matrix
|
|
Matrix mode (@kbd{m v}; @pxref{Matrix Mode}).
|
|
|
|
@item Matrix@var{n}
|
|
Dimensioned Matrix mode (@kbd{C-u @var{n} m v}; @pxref{Matrix Mode}).
|
|
|
|
@item SqMatrix
|
|
Square Matrix mode (@kbd{C-u m v}; @pxref{Matrix Mode}).
|
|
|
|
@item Scalar
|
|
Scalar mode (@kbd{m v}; @pxref{Matrix Mode}).
|
|
|
|
@item Polar
|
|
Polar complex mode (@kbd{m p}; @pxref{Polar Mode}).
|
|
|
|
@item Frac
|
|
Fraction mode (@kbd{m f}; @pxref{Fraction Mode}).
|
|
|
|
@item Inf
|
|
Infinite mode (@kbd{m i}; @pxref{Infinite Mode}).
|
|
|
|
@item +Inf
|
|
Positive Infinite mode (@kbd{C-u 0 m i}).
|
|
|
|
@item NoSimp
|
|
Default simplifications off (@kbd{m O}; @pxref{Simplification Modes}).
|
|
|
|
@item NumSimp
|
|
Default simplifications for numeric arguments only (@kbd{m N}).
|
|
|
|
@item BinSimp@var{w}
|
|
Binary-integer simplification mode; word size @var{w} (@kbd{m B}, @kbd{b w}).
|
|
|
|
@item AlgSimp
|
|
Algebraic simplification mode (@kbd{m A}).
|
|
|
|
@item ExtSimp
|
|
Extended algebraic simplification mode (@kbd{m E}).
|
|
|
|
@item UnitSimp
|
|
Units simplification mode (@kbd{m U}).
|
|
|
|
@item Bin
|
|
Current radix is 2 (@kbd{d 2}; @pxref{Radix Modes}).
|
|
|
|
@item Oct
|
|
Current radix is 8 (@kbd{d 8}).
|
|
|
|
@item Hex
|
|
Current radix is 16 (@kbd{d 6}).
|
|
|
|
@item Radix@var{n}
|
|
Current radix is @var{n} (@kbd{d r}).
|
|
|
|
@item Zero
|
|
Leading zeros (@kbd{d z}; @pxref{Radix Modes}).
|
|
|
|
@item Big
|
|
Big language mode (@kbd{d B}; @pxref{Normal Language Modes}).
|
|
|
|
@item Flat
|
|
One-line normal language mode (@kbd{d O}).
|
|
|
|
@item Unform
|
|
Unformatted language mode (@kbd{d U}).
|
|
|
|
@item C
|
|
C language mode (@kbd{d C}; @pxref{C FORTRAN Pascal}).
|
|
|
|
@item Pascal
|
|
Pascal language mode (@kbd{d P}).
|
|
|
|
@item Fortran
|
|
FORTRAN language mode (@kbd{d F}).
|
|
|
|
@item TeX
|
|
@TeX{} language mode (@kbd{d T}; @pxref{TeX and LaTeX Language Modes}).
|
|
|
|
@item LaTeX
|
|
La@TeX{} language mode (@kbd{d L}; @pxref{TeX and LaTeX Language Modes}).
|
|
|
|
@item Eqn
|
|
@dfn{Eqn} language mode (@kbd{d E}; @pxref{Eqn Language Mode}).
|
|
|
|
@item Math
|
|
Mathematica language mode (@kbd{d M}; @pxref{Mathematica Language Mode}).
|
|
|
|
@item Maple
|
|
Maple language mode (@kbd{d W}; @pxref{Maple Language Mode}).
|
|
|
|
@item Norm@var{n}
|
|
Normal float mode with @var{n} digits (@kbd{d n}; @pxref{Float Formats}).
|
|
|
|
@item Fix@var{n}
|
|
Fixed point mode with @var{n} digits after the point (@kbd{d f}).
|
|
|
|
@item Sci
|
|
Scientific notation mode (@kbd{d s}).
|
|
|
|
@item Sci@var{n}
|
|
Scientific notation with @var{n} digits (@kbd{d s}).
|
|
|
|
@item Eng
|
|
Engineering notation mode (@kbd{d e}).
|
|
|
|
@item Eng@var{n}
|
|
Engineering notation with @var{n} digits (@kbd{d e}).
|
|
|
|
@item Left@var{n}
|
|
Left-justified display indented by @var{n} (@kbd{d <}; @pxref{Justification}).
|
|
|
|
@item Right
|
|
Right-justified display (@kbd{d >}).
|
|
|
|
@item Right@var{n}
|
|
Right-justified display with width @var{n} (@kbd{d >}).
|
|
|
|
@item Center
|
|
Centered display (@kbd{d =}).
|
|
|
|
@item Center@var{n}
|
|
Centered display with center column @var{n} (@kbd{d =}).
|
|
|
|
@item Wid@var{n}
|
|
Line breaking with width @var{n} (@kbd{d b}; @pxref{Normal Language Modes}).
|
|
|
|
@item Wide
|
|
No line breaking (@kbd{d b}).
|
|
|
|
@item Break
|
|
Selections show deep structure (@kbd{j b}; @pxref{Making Selections}).
|
|
|
|
@item Save
|
|
Record modes in @file{~/.calc.el} (@kbd{m R}; @pxref{General Mode Commands}).
|
|
|
|
@item Local
|
|
Record modes in Embedded buffer (@kbd{m R}).
|
|
|
|
@item LocEdit
|
|
Record modes as editing-only in Embedded buffer (@kbd{m R}).
|
|
|
|
@item LocPerm
|
|
Record modes as permanent-only in Embedded buffer (@kbd{m R}).
|
|
|
|
@item Global
|
|
Record modes as global in Embedded buffer (@kbd{m R}).
|
|
|
|
@item Manual
|
|
Automatic recomputation turned off (@kbd{m C}; @pxref{Automatic
|
|
Recomputation}).
|
|
|
|
@item Graph
|
|
GNUPLOT process is alive in background (@pxref{Graphics}).
|
|
|
|
@item Sel
|
|
Top-of-stack has a selection (Embedded only; @pxref{Making Selections}).
|
|
|
|
@item Dirty
|
|
The stack display may not be up-to-date (@pxref{Display Modes}).
|
|
|
|
@item Inv
|
|
``Inverse'' prefix was pressed (@kbd{I}; @pxref{Inverse and Hyperbolic}).
|
|
|
|
@item Hyp
|
|
``Hyperbolic'' prefix was pressed (@kbd{H}).
|
|
|
|
@item Keep
|
|
``Keep-arguments'' prefix was pressed (@kbd{K}).
|
|
|
|
@item Narrow
|
|
Stack is truncated (@kbd{d t}; @pxref{Truncating the Stack}).
|
|
@end table
|
|
|
|
In addition, the symbols @code{Active} and @code{~Active} can appear
|
|
as minor modes on an Embedded buffer's mode line. @xref{Embedded Mode}.
|
|
|
|
@node Arithmetic, Scientific Functions, Mode Settings, Top
|
|
@chapter Arithmetic Functions
|
|
|
|
@noindent
|
|
This chapter describes the Calc commands for doing simple calculations
|
|
on numbers, such as addition, absolute value, and square roots. These
|
|
commands work by removing the top one or two values from the stack,
|
|
performing the desired operation, and pushing the result back onto the
|
|
stack. If the operation cannot be performed, the result pushed is a
|
|
formula instead of a number, such as @samp{2/0} (because division by zero
|
|
is invalid) or @samp{sqrt(x)} (because the argument @samp{x} is a formula).
|
|
|
|
Most of the commands described here can be invoked by a single keystroke.
|
|
Some of the more obscure ones are two-letter sequences beginning with
|
|
the @kbd{f} (``functions'') prefix key.
|
|
|
|
@xref{Prefix Arguments}, for a discussion of the effect of numeric
|
|
prefix arguments on commands in this chapter which do not otherwise
|
|
interpret a prefix argument.
|
|
|
|
@menu
|
|
* Basic Arithmetic::
|
|
* Integer Truncation::
|
|
* Complex Number Functions::
|
|
* Conversions::
|
|
* Date Arithmetic::
|
|
* Financial Functions::
|
|
* Binary Functions::
|
|
@end menu
|
|
|
|
@node Basic Arithmetic, Integer Truncation, Arithmetic, Arithmetic
|
|
@section Basic Arithmetic
|
|
|
|
@noindent
|
|
@kindex +
|
|
@pindex calc-plus
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex +
|
|
The @kbd{+} (@code{calc-plus}) command adds two numbers. The numbers may
|
|
be any of the standard Calc data types. The resulting sum is pushed back
|
|
onto the stack.
|
|
|
|
If both arguments of @kbd{+} are vectors or matrices (of matching dimensions),
|
|
the result is a vector or matrix sum. If one argument is a vector and the
|
|
other a scalar (i.e., a non-vector), the scalar is added to each of the
|
|
elements of the vector to form a new vector. If the scalar is not a
|
|
number, the operation is left in symbolic form: Suppose you added @samp{x}
|
|
to the vector @samp{[1,2]}. You may want the result @samp{[1+x,2+x]}, or
|
|
you may plan to substitute a 2-vector for @samp{x} in the future. Since
|
|
the Calculator can't tell which interpretation you want, it makes the
|
|
safest assumption. @xref{Reducing and Mapping}, for a way to add @samp{x}
|
|
to every element of a vector.
|
|
|
|
If either argument of @kbd{+} is a complex number, the result will in general
|
|
be complex. If one argument is in rectangular form and the other polar,
|
|
the current Polar mode determines the form of the result. If Symbolic
|
|
mode is enabled, the sum may be left as a formula if the necessary
|
|
conversions for polar addition are non-trivial.
|
|
|
|
If both arguments of @kbd{+} are HMS forms, the forms are added according to
|
|
the usual conventions of hours-minutes-seconds notation. If one argument
|
|
is an HMS form and the other is a number, that number is converted from
|
|
degrees or radians (depending on the current Angular mode) to HMS format
|
|
and then the two HMS forms are added.
|
|
|
|
If one argument of @kbd{+} is a date form, the other can be either a
|
|
real number, which advances the date by a certain number of days, or
|
|
an HMS form, which advances the date by a certain amount of time.
|
|
Subtracting two date forms yields the number of days between them.
|
|
Adding two date forms is meaningless, but Calc interprets it as the
|
|
subtraction of one date form and the negative of the other. (The
|
|
negative of a date form can be understood by remembering that dates
|
|
are stored as the number of days before or after Jan 1, 1 AD.)
|
|
|
|
If both arguments of @kbd{+} are error forms, the result is an error form
|
|
with an appropriately computed standard deviation. If one argument is an
|
|
error form and the other is a number, the number is taken to have zero error.
|
|
Error forms may have symbolic formulas as their mean and/or error parts;
|
|
adding these will produce a symbolic error form result. However, adding an
|
|
error form to a plain symbolic formula (as in @samp{(a +/- b) + c}) will not
|
|
work, for the same reasons just mentioned for vectors. Instead you must
|
|
write @samp{(a +/- b) + (c +/- 0)}.
|
|
|
|
If both arguments of @kbd{+} are modulo forms with equal values of @expr{M},
|
|
or if one argument is a modulo form and the other a plain number, the
|
|
result is a modulo form which represents the sum, modulo @expr{M}, of
|
|
the two values.
|
|
|
|
If both arguments of @kbd{+} are intervals, the result is an interval
|
|
which describes all possible sums of the possible input values. If
|
|
one argument is a plain number, it is treated as the interval
|
|
@w{@samp{[x ..@: x]}}.
|
|
|
|
If one argument of @kbd{+} is an infinity and the other is not, the
|
|
result is that same infinity. If both arguments are infinite and in
|
|
the same direction, the result is the same infinity, but if they are
|
|
infinite in different directions the result is @code{nan}.
|
|
|
|
@kindex -
|
|
@pindex calc-minus
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex -
|
|
The @kbd{-} (@code{calc-minus}) command subtracts two values. The top
|
|
number on the stack is subtracted from the one behind it, so that the
|
|
computation @kbd{5 @key{RET} 2 -} produces 3, not @mathit{-3}. All options
|
|
available for @kbd{+} are available for @kbd{-} as well.
|
|
|
|
@kindex *
|
|
@pindex calc-times
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex *
|
|
The @kbd{*} (@code{calc-times}) command multiplies two numbers. If one
|
|
argument is a vector and the other a scalar, the scalar is multiplied by
|
|
the elements of the vector to produce a new vector. If both arguments
|
|
are vectors, the interpretation depends on the dimensions of the
|
|
vectors: If both arguments are matrices, a matrix multiplication is
|
|
done. If one argument is a matrix and the other a plain vector, the
|
|
vector is interpreted as a row vector or column vector, whichever is
|
|
dimensionally correct. If both arguments are plain vectors, the result
|
|
is a single scalar number which is the dot product of the two vectors.
|
|
|
|
If one argument of @kbd{*} is an HMS form and the other a number, the
|
|
HMS form is multiplied by that amount. It is an error to multiply two
|
|
HMS forms together, or to attempt any multiplication involving date
|
|
forms. Error forms, modulo forms, and intervals can be multiplied;
|
|
see the comments for addition of those forms. When two error forms
|
|
or intervals are multiplied they are considered to be statistically
|
|
independent; thus, @samp{[-2 ..@: 3] * [-2 ..@: 3]} is @samp{[-6 ..@: 9]},
|
|
whereas @w{@samp{[-2 ..@: 3] ^ 2}} is @samp{[0 ..@: 9]}.
|
|
|
|
@kindex /
|
|
@pindex calc-divide
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex /
|
|
The @kbd{/} (@code{calc-divide}) command divides two numbers. When
|
|
dividing a scalar @expr{B} by a square matrix @expr{A}, the computation
|
|
performed is @expr{B} times the inverse of @expr{A}. This also occurs
|
|
if @expr{B} is itself a vector or matrix, in which case the effect is
|
|
to solve the set of linear equations represented by @expr{B}. If @expr{B}
|
|
is a matrix with the same number of rows as @expr{A}, or a plain vector
|
|
(which is interpreted here as a column vector), then the equation
|
|
@expr{A X = B} is solved for the vector or matrix @expr{X}. Otherwise,
|
|
if @expr{B} is a non-square matrix with the same number of @emph{columns}
|
|
as @expr{A}, the equation @expr{X A = B} is solved. If you wish a vector
|
|
@expr{B} to be interpreted as a row vector to be solved as @expr{X A = B},
|
|
make it into a one-row matrix with @kbd{C-u 1 v p} first. To force a
|
|
left-handed solution with a square matrix @expr{B}, transpose @expr{A} and
|
|
@expr{B} before dividing, then transpose the result.
|
|
|
|
HMS forms can be divided by real numbers or by other HMS forms. Error
|
|
forms can be divided in any combination of ways. Modulo forms where both
|
|
values and the modulo are integers can be divided to get an integer modulo
|
|
form result. Intervals can be divided; dividing by an interval that
|
|
encompasses zero or has zero as a limit will result in an infinite
|
|
interval.
|
|
|
|
@kindex ^
|
|
@pindex calc-power
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ^
|
|
The @kbd{^} (@code{calc-power}) command raises a number to a power. If
|
|
the power is an integer, an exact result is computed using repeated
|
|
multiplications. For non-integer powers, Calc uses Newton's method or
|
|
logarithms and exponentials. Square matrices can be raised to integer
|
|
powers. If either argument is an error (or interval or modulo) form,
|
|
the result is also an error (or interval or modulo) form.
|
|
|
|
@kindex I ^
|
|
@tindex nroot
|
|
If you press the @kbd{I} (inverse) key first, the @kbd{I ^} command
|
|
computes an Nth root: @kbd{125 @key{RET} 3 I ^} computes the number 5.
|
|
(This is entirely equivalent to @kbd{125 @key{RET} 1:3 ^}.)
|
|
|
|
@kindex \
|
|
@pindex calc-idiv
|
|
@tindex idiv
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex \
|
|
The @kbd{\} (@code{calc-idiv}) command divides two numbers on the stack
|
|
to produce an integer result. It is equivalent to dividing with
|
|
@key{/}, then rounding down with @kbd{F} (@code{calc-floor}), only a bit
|
|
more convenient and efficient. Also, since it is an all-integer
|
|
operation when the arguments are integers, it avoids problems that
|
|
@kbd{/ F} would have with floating-point roundoff.
|
|
|
|
@kindex %
|
|
@pindex calc-mod
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex %
|
|
The @kbd{%} (@code{calc-mod}) command performs a ``modulo'' (or ``remainder'')
|
|
operation. Mathematically, @samp{a%b = a - (a\b)*b}, and is defined
|
|
for all real numbers @expr{a} and @expr{b} (except @expr{b=0}). For
|
|
positive @expr{b}, the result will always be between 0 (inclusive) and
|
|
@expr{b} (exclusive). Modulo does not work for HMS forms and error forms.
|
|
If @expr{a} is a modulo form, its modulo is changed to @expr{b}, which
|
|
must be positive real number.
|
|
|
|
@kindex :
|
|
@pindex calc-fdiv
|
|
@tindex fdiv
|
|
The @kbd{:} (@code{calc-fdiv}) [@code{fdiv}] command
|
|
divides the two integers on the top of the stack to produce a fractional
|
|
result. This is a convenient shorthand for enabling Fraction mode (with
|
|
@kbd{m f}) temporarily and using @samp{/}. Note that during numeric entry
|
|
the @kbd{:} key is interpreted as a fraction separator, so to divide 8 by 6
|
|
you would have to type @kbd{8 @key{RET} 6 @key{RET} :}. (Of course, in
|
|
this case, it would be much easier simply to enter the fraction directly
|
|
as @kbd{8:6 @key{RET}}!)
|
|
|
|
@kindex n
|
|
@pindex calc-change-sign
|
|
The @kbd{n} (@code{calc-change-sign}) command negates the number on the top
|
|
of the stack. It works on numbers, vectors and matrices, HMS forms, date
|
|
forms, error forms, intervals, and modulo forms.
|
|
|
|
@kindex A
|
|
@pindex calc-abs
|
|
@tindex abs
|
|
The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the absolute
|
|
value of a number. The result of @code{abs} is always a nonnegative
|
|
real number: With a complex argument, it computes the complex magnitude.
|
|
With a vector or matrix argument, it computes the Frobenius norm, i.e.,
|
|
the square root of the sum of the squares of the absolute values of the
|
|
elements. The absolute value of an error form is defined by replacing
|
|
the mean part with its absolute value and leaving the error part the same.
|
|
The absolute value of a modulo form is undefined. The absolute value of
|
|
an interval is defined in the obvious way.
|
|
|
|
@kindex f A
|
|
@pindex calc-abssqr
|
|
@tindex abssqr
|
|
The @kbd{f A} (@code{calc-abssqr}) [@code{abssqr}] command computes the
|
|
absolute value squared of a number, vector or matrix, or error form.
|
|
|
|
@kindex f s
|
|
@pindex calc-sign
|
|
@tindex sign
|
|
The @kbd{f s} (@code{calc-sign}) [@code{sign}] command returns 1 if its
|
|
argument is positive, @mathit{-1} if its argument is negative, or 0 if its
|
|
argument is zero. In algebraic form, you can also write @samp{sign(a,x)}
|
|
which evaluates to @samp{x * sign(a)}, i.e., either @samp{x}, @samp{-x}, or
|
|
zero depending on the sign of @samp{a}.
|
|
|
|
@kindex &
|
|
@pindex calc-inv
|
|
@tindex inv
|
|
@cindex Reciprocal
|
|
The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
|
|
reciprocal of a number, i.e., @expr{1 / x}. Operating on a square
|
|
matrix, it computes the inverse of that matrix.
|
|
|
|
@kindex Q
|
|
@pindex calc-sqrt
|
|
@tindex sqrt
|
|
The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] command computes the square
|
|
root of a number. For a negative real argument, the result will be a
|
|
complex number whose form is determined by the current Polar mode.
|
|
|
|
@kindex f h
|
|
@pindex calc-hypot
|
|
@tindex hypot
|
|
The @kbd{f h} (@code{calc-hypot}) [@code{hypot}] command computes the square
|
|
root of the sum of the squares of two numbers. That is, @samp{hypot(a,b)}
|
|
is the length of the hypotenuse of a right triangle with sides @expr{a}
|
|
and @expr{b}. If the arguments are complex numbers, their squared
|
|
magnitudes are used.
|
|
|
|
@kindex f Q
|
|
@pindex calc-isqrt
|
|
@tindex isqrt
|
|
The @kbd{f Q} (@code{calc-isqrt}) [@code{isqrt}] command computes the
|
|
integer square root of an integer. This is the true square root of the
|
|
number, rounded down to an integer. For example, @samp{isqrt(10)}
|
|
produces 3. Note that, like @kbd{\} [@code{idiv}], this uses exact
|
|
integer arithmetic throughout to avoid roundoff problems. If the input
|
|
is a floating-point number or other non-integer value, this is exactly
|
|
the same as @samp{floor(sqrt(x))}.
|
|
|
|
@kindex f n
|
|
@kindex f x
|
|
@pindex calc-min
|
|
@tindex min
|
|
@pindex calc-max
|
|
@tindex max
|
|
The @kbd{f n} (@code{calc-min}) [@code{min}] and @kbd{f x} (@code{calc-max})
|
|
[@code{max}] commands take the minimum or maximum of two real numbers,
|
|
respectively. These commands also work on HMS forms, date forms,
|
|
intervals, and infinities. (In algebraic expressions, these functions
|
|
take any number of arguments and return the maximum or minimum among
|
|
all the arguments.)
|
|
|
|
@kindex f M
|
|
@kindex f X
|
|
@pindex calc-mant-part
|
|
@tindex mant
|
|
@pindex calc-xpon-part
|
|
@tindex xpon
|
|
The @kbd{f M} (@code{calc-mant-part}) [@code{mant}] function extracts
|
|
the ``mantissa'' part @expr{m} of its floating-point argument; @kbd{f X}
|
|
(@code{calc-xpon-part}) [@code{xpon}] extracts the ``exponent'' part
|
|
@expr{e}. The original number is equal to
|
|
@texline @math{m \times 10^e},
|
|
@infoline @expr{m * 10^e},
|
|
where @expr{m} is in the interval @samp{[1.0 ..@: 10.0)} except that
|
|
@expr{m=e=0} if the original number is zero. For integers
|
|
and fractions, @code{mant} returns the number unchanged and @code{xpon}
|
|
returns zero. The @kbd{v u} (@code{calc-unpack}) command can also be
|
|
used to ``unpack'' a floating-point number; this produces an integer
|
|
mantissa and exponent, with the constraint that the mantissa is not
|
|
a multiple of ten (again except for the @expr{m=e=0} case).
|
|
|
|
@kindex f S
|
|
@pindex calc-scale-float
|
|
@tindex scf
|
|
The @kbd{f S} (@code{calc-scale-float}) [@code{scf}] function scales a number
|
|
by a given power of ten. Thus, @samp{scf(mant(x), xpon(x)) = x} for any
|
|
real @samp{x}. The second argument must be an integer, but the first
|
|
may actually be any numeric value. For example, @samp{scf(5,-2) = 0.05}
|
|
or @samp{1:20} depending on the current Fraction mode.
|
|
|
|
@kindex f [
|
|
@kindex f ]
|
|
@pindex calc-decrement
|
|
@pindex calc-increment
|
|
@tindex decr
|
|
@tindex incr
|
|
The @kbd{f [} (@code{calc-decrement}) [@code{decr}] and @kbd{f ]}
|
|
(@code{calc-increment}) [@code{incr}] functions decrease or increase
|
|
a number by one unit. For integers, the effect is obvious. For
|
|
floating-point numbers, the change is by one unit in the last place.
|
|
For example, incrementing @samp{12.3456} when the current precision
|
|
is 6 digits yields @samp{12.3457}. If the current precision had been
|
|
8 digits, the result would have been @samp{12.345601}. Incrementing
|
|
@samp{0.0} produces
|
|
@texline @math{10^{-p}},
|
|
@infoline @expr{10^-p},
|
|
where @expr{p} is the current
|
|
precision. These operations are defined only on integers and floats.
|
|
With numeric prefix arguments, they change the number by @expr{n} units.
|
|
|
|
Note that incrementing followed by decrementing, or vice-versa, will
|
|
almost but not quite always cancel out. Suppose the precision is
|
|
6 digits and the number @samp{9.99999} is on the stack. Incrementing
|
|
will produce @samp{10.0000}; decrementing will produce @samp{9.9999}.
|
|
One digit has been dropped. This is an unavoidable consequence of the
|
|
way floating-point numbers work.
|
|
|
|
Incrementing a date/time form adjusts it by a certain number of seconds.
|
|
Incrementing a pure date form adjusts it by a certain number of days.
|
|
|
|
@node Integer Truncation, Complex Number Functions, Basic Arithmetic, Arithmetic
|
|
@section Integer Truncation
|
|
|
|
@noindent
|
|
There are four commands for truncating a real number to an integer,
|
|
differing mainly in their treatment of negative numbers. All of these
|
|
commands have the property that if the argument is an integer, the result
|
|
is the same integer. An integer-valued floating-point argument is converted
|
|
to integer form.
|
|
|
|
If you press @kbd{H} (@code{calc-hyperbolic}) first, the result will be
|
|
expressed as an integer-valued floating-point number.
|
|
|
|
@cindex Integer part of a number
|
|
@kindex F
|
|
@pindex calc-floor
|
|
@tindex floor
|
|
@tindex ffloor
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H F
|
|
The @kbd{F} (@code{calc-floor}) [@code{floor} or @code{ffloor}] command
|
|
truncates a real number to the next lower integer, i.e., toward minus
|
|
infinity. Thus @kbd{3.6 F} produces 3, but @kbd{_3.6 F} produces
|
|
@mathit{-4}.
|
|
|
|
@kindex I F
|
|
@pindex calc-ceiling
|
|
@tindex ceil
|
|
@tindex fceil
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I F
|
|
The @kbd{I F} (@code{calc-ceiling}) [@code{ceil} or @code{fceil}]
|
|
command truncates toward positive infinity. Thus @kbd{3.6 I F} produces
|
|
4, and @kbd{_3.6 I F} produces @mathit{-3}.
|
|
|
|
@kindex R
|
|
@pindex calc-round
|
|
@tindex round
|
|
@tindex fround
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H R
|
|
The @kbd{R} (@code{calc-round}) [@code{round} or @code{fround}] command
|
|
rounds to the nearest integer. When the fractional part is .5 exactly,
|
|
this command rounds away from zero. (All other rounding in the
|
|
Calculator uses this convention as well.) Thus @kbd{3.5 R} produces 4
|
|
but @kbd{3.4 R} produces 3; @kbd{_3.5 R} produces @mathit{-4}.
|
|
|
|
@kindex I R
|
|
@pindex calc-trunc
|
|
@tindex trunc
|
|
@tindex ftrunc
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I R
|
|
The @kbd{I R} (@code{calc-trunc}) [@code{trunc} or @code{ftrunc}]
|
|
command truncates toward zero. In other words, it ``chops off''
|
|
everything after the decimal point. Thus @kbd{3.6 I R} produces 3 and
|
|
@kbd{_3.6 I R} produces @mathit{-3}.
|
|
|
|
These functions may not be applied meaningfully to error forms, but they
|
|
do work for intervals. As a convenience, applying @code{floor} to a
|
|
modulo form floors the value part of the form. Applied to a vector,
|
|
these functions operate on all elements of the vector one by one.
|
|
Applied to a date form, they operate on the internal numerical
|
|
representation of dates, converting a date/time form into a pure date.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex rounde
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex roundu
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex frounde
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex froundu
|
|
There are two more rounding functions which can only be entered in
|
|
algebraic notation. The @code{roundu} function is like @code{round}
|
|
except that it rounds up, toward plus infinity, when the fractional
|
|
part is .5. This distinction matters only for negative arguments.
|
|
Also, @code{rounde} rounds to an even number in the case of a tie,
|
|
rounding up or down as necessary. For example, @samp{rounde(3.5)} and
|
|
@samp{rounde(4.5)} both return 4, but @samp{rounde(5.5)} returns 6.
|
|
The advantage of round-to-even is that the net error due to rounding
|
|
after a long calculation tends to cancel out to zero. An important
|
|
subtle point here is that the number being fed to @code{rounde} will
|
|
already have been rounded to the current precision before @code{rounde}
|
|
begins. For example, @samp{rounde(2.500001)} with a current precision
|
|
of 6 will incorrectly, or at least surprisingly, yield 2 because the
|
|
argument will first have been rounded down to @expr{2.5} (which
|
|
@code{rounde} sees as an exact tie between 2 and 3).
|
|
|
|
Each of these functions, when written in algebraic formulas, allows
|
|
a second argument which specifies the number of digits after the
|
|
decimal point to keep. For example, @samp{round(123.4567, 2)} will
|
|
produce the answer 123.46, and @samp{round(123.4567, -1)} will
|
|
produce 120 (i.e., the cutoff is one digit to the @emph{left} of
|
|
the decimal point). A second argument of zero is equivalent to
|
|
no second argument at all.
|
|
|
|
@cindex Fractional part of a number
|
|
To compute the fractional part of a number (i.e., the amount which, when
|
|
added to `@tfn{floor(}@var{n}@tfn{)}', will produce @var{n}) just take @var{n}
|
|
modulo 1 using the @code{%} command.
|
|
|
|
Note also the @kbd{\} (integer quotient), @kbd{f I} (integer logarithm),
|
|
and @kbd{f Q} (integer square root) commands, which are analogous to
|
|
@kbd{/}, @kbd{B}, and @kbd{Q}, respectively, except that they take integer
|
|
arguments and return the result rounded down to an integer.
|
|
|
|
@node Complex Number Functions, Conversions, Integer Truncation, Arithmetic
|
|
@section Complex Number Functions
|
|
|
|
@noindent
|
|
@kindex J
|
|
@pindex calc-conj
|
|
@tindex conj
|
|
The @kbd{J} (@code{calc-conj}) [@code{conj}] command computes the
|
|
complex conjugate of a number. For complex number @expr{a+bi}, the
|
|
complex conjugate is @expr{a-bi}. If the argument is a real number,
|
|
this command leaves it the same. If the argument is a vector or matrix,
|
|
this command replaces each element by its complex conjugate.
|
|
|
|
@kindex G
|
|
@pindex calc-argument
|
|
@tindex arg
|
|
The @kbd{G} (@code{calc-argument}) [@code{arg}] command computes the
|
|
``argument'' or polar angle of a complex number. For a number in polar
|
|
notation, this is simply the second component of the pair
|
|
@texline `@tfn{(}@var{r}@tfn{;}@math{\theta}@tfn{)}'.
|
|
@infoline `@tfn{(}@var{r}@tfn{;}@var{theta}@tfn{)}'.
|
|
The result is expressed according to the current angular mode and will
|
|
be in the range @mathit{-180} degrees (exclusive) to @mathit{+180} degrees
|
|
(inclusive), or the equivalent range in radians.
|
|
|
|
@pindex calc-imaginary
|
|
The @code{calc-imaginary} command multiplies the number on the
|
|
top of the stack by the imaginary number @expr{i = (0,1)}. This
|
|
command is not normally bound to a key in Calc, but it is available
|
|
on the @key{IMAG} button in Keypad mode.
|
|
|
|
@kindex f r
|
|
@pindex calc-re
|
|
@tindex re
|
|
The @kbd{f r} (@code{calc-re}) [@code{re}] command replaces a complex number
|
|
by its real part. This command has no effect on real numbers. (As an
|
|
added convenience, @code{re} applied to a modulo form extracts
|
|
the value part.)
|
|
|
|
@kindex f i
|
|
@pindex calc-im
|
|
@tindex im
|
|
The @kbd{f i} (@code{calc-im}) [@code{im}] command replaces a complex number
|
|
by its imaginary part; real numbers are converted to zero. With a vector
|
|
or matrix argument, these functions operate element-wise.
|
|
|
|
@ignore
|
|
@mindex v p
|
|
@end ignore
|
|
@kindex v p (complex)
|
|
@pindex calc-pack
|
|
The @kbd{v p} (@code{calc-pack}) command can pack the top two numbers on
|
|
the stack into a composite object such as a complex number. With
|
|
a prefix argument of @mathit{-1}, it produces a rectangular complex number;
|
|
with an argument of @mathit{-2}, it produces a polar complex number.
|
|
(Also, @pxref{Building Vectors}.)
|
|
|
|
@ignore
|
|
@mindex v u
|
|
@end ignore
|
|
@kindex v u (complex)
|
|
@pindex calc-unpack
|
|
The @kbd{v u} (@code{calc-unpack}) command takes the complex number
|
|
(or other composite object) on the top of the stack and unpacks it
|
|
into its separate components.
|
|
|
|
@node Conversions, Date Arithmetic, Complex Number Functions, Arithmetic
|
|
@section Conversions
|
|
|
|
@noindent
|
|
The commands described in this section convert numbers from one form
|
|
to another; they are two-key sequences beginning with the letter @kbd{c}.
|
|
|
|
@kindex c f
|
|
@pindex calc-float
|
|
@tindex pfloat
|
|
The @kbd{c f} (@code{calc-float}) [@code{pfloat}] command converts the
|
|
number on the top of the stack to floating-point form. For example,
|
|
@expr{23} is converted to @expr{23.0}, @expr{3:2} is converted to
|
|
@expr{1.5}, and @expr{2.3} is left the same. If the value is a composite
|
|
object such as a complex number or vector, each of the components is
|
|
converted to floating-point. If the value is a formula, all numbers
|
|
in the formula are converted to floating-point. Note that depending
|
|
on the current floating-point precision, conversion to floating-point
|
|
format may lose information.
|
|
|
|
As a special exception, integers which appear as powers or subscripts
|
|
are not floated by @kbd{c f}. If you really want to float a power,
|
|
you can use a @kbd{j s} command to select the power followed by @kbd{c f}.
|
|
Because @kbd{c f} cannot examine the formula outside of the selection,
|
|
it does not notice that the thing being floated is a power.
|
|
@xref{Selecting Subformulas}.
|
|
|
|
The normal @kbd{c f} command is ``pervasive'' in the sense that it
|
|
applies to all numbers throughout the formula. The @code{pfloat}
|
|
algebraic function never stays around in a formula; @samp{pfloat(a + 1)}
|
|
changes to @samp{a + 1.0} as soon as it is evaluated.
|
|
|
|
@kindex H c f
|
|
@tindex float
|
|
With the Hyperbolic flag, @kbd{H c f} [@code{float}] operates
|
|
only on the number or vector of numbers at the top level of its
|
|
argument. Thus, @samp{float(1)} is 1.0, but @samp{float(a + 1)}
|
|
is left unevaluated because its argument is not a number.
|
|
|
|
You should use @kbd{H c f} if you wish to guarantee that the final
|
|
value, once all the variables have been assigned, is a float; you
|
|
would use @kbd{c f} if you wish to do the conversion on the numbers
|
|
that appear right now.
|
|
|
|
@kindex c F
|
|
@pindex calc-fraction
|
|
@tindex pfrac
|
|
The @kbd{c F} (@code{calc-fraction}) [@code{pfrac}] command converts a
|
|
floating-point number into a fractional approximation. By default, it
|
|
produces a fraction whose decimal representation is the same as the
|
|
input number, to within the current precision. You can also give a
|
|
numeric prefix argument to specify a tolerance, either directly, or,
|
|
if the prefix argument is zero, by using the number on top of the stack
|
|
as the tolerance. If the tolerance is a positive integer, the fraction
|
|
is correct to within that many significant figures. If the tolerance is
|
|
a non-positive integer, it specifies how many digits fewer than the current
|
|
precision to use. If the tolerance is a floating-point number, the
|
|
fraction is correct to within that absolute amount.
|
|
|
|
@kindex H c F
|
|
@tindex frac
|
|
The @code{pfrac} function is pervasive, like @code{pfloat}.
|
|
There is also a non-pervasive version, @kbd{H c F} [@code{frac}],
|
|
which is analogous to @kbd{H c f} discussed above.
|
|
|
|
@kindex c d
|
|
@pindex calc-to-degrees
|
|
@tindex deg
|
|
The @kbd{c d} (@code{calc-to-degrees}) [@code{deg}] command converts a
|
|
number into degrees form. The value on the top of the stack may be an
|
|
HMS form (interpreted as degrees-minutes-seconds), or a real number which
|
|
will be interpreted in radians regardless of the current angular mode.
|
|
|
|
@kindex c r
|
|
@pindex calc-to-radians
|
|
@tindex rad
|
|
The @kbd{c r} (@code{calc-to-radians}) [@code{rad}] command converts an
|
|
HMS form or angle in degrees into an angle in radians.
|
|
|
|
@kindex c h
|
|
@pindex calc-to-hms
|
|
@tindex hms
|
|
The @kbd{c h} (@code{calc-to-hms}) [@code{hms}] command converts a real
|
|
number, interpreted according to the current angular mode, to an HMS
|
|
form describing the same angle. In algebraic notation, the @code{hms}
|
|
function also accepts three arguments: @samp{hms(@var{h}, @var{m}, @var{s})}.
|
|
(The three-argument version is independent of the current angular mode.)
|
|
|
|
@pindex calc-from-hms
|
|
The @code{calc-from-hms} command converts the HMS form on the top of the
|
|
stack into a real number according to the current angular mode.
|
|
|
|
@kindex c p
|
|
@kindex I c p
|
|
@pindex calc-polar
|
|
@tindex polar
|
|
@tindex rect
|
|
The @kbd{c p} (@code{calc-polar}) command converts the complex number on
|
|
the top of the stack from polar to rectangular form, or from rectangular
|
|
to polar form, whichever is appropriate. Real numbers are left the same.
|
|
This command is equivalent to the @code{rect} or @code{polar}
|
|
functions in algebraic formulas, depending on the direction of
|
|
conversion. (It uses @code{polar}, except that if the argument is
|
|
already a polar complex number, it uses @code{rect} instead. The
|
|
@kbd{I c p} command always uses @code{rect}.)
|
|
|
|
@kindex c c
|
|
@pindex calc-clean
|
|
@tindex pclean
|
|
The @kbd{c c} (@code{calc-clean}) [@code{pclean}] command ``cleans'' the
|
|
number on the top of the stack. Floating point numbers are re-rounded
|
|
according to the current precision. Polar numbers whose angular
|
|
components have strayed from the @mathit{-180} to @mathit{+180} degree range
|
|
are normalized. (Note that results will be undesirable if the current
|
|
angular mode is different from the one under which the number was
|
|
produced!) Integers and fractions are generally unaffected by this
|
|
operation. Vectors and formulas are cleaned by cleaning each component
|
|
number (i.e., pervasively).
|
|
|
|
If the simplification mode is set below the default level, it is raised
|
|
to the default level for the purposes of this command. Thus, @kbd{c c}
|
|
applies the default simplifications even if their automatic application
|
|
is disabled. @xref{Simplification Modes}.
|
|
|
|
@cindex Roundoff errors, correcting
|
|
A numeric prefix argument to @kbd{c c} sets the floating-point precision
|
|
to that value for the duration of the command. A positive prefix (of at
|
|
least 3) sets the precision to the specified value; a negative or zero
|
|
prefix decreases the precision by the specified amount.
|
|
|
|
@kindex c 0-9
|
|
@pindex calc-clean-num
|
|
The keystroke sequences @kbd{c 0} through @kbd{c 9} are equivalent
|
|
to @kbd{c c} with the corresponding negative prefix argument. If roundoff
|
|
errors have changed 2.0 into 1.999999, typing @kbd{c 1} to clip off one
|
|
decimal place often conveniently does the trick.
|
|
|
|
The @kbd{c c} command with a numeric prefix argument, and the @kbd{c 0}
|
|
through @kbd{c 9} commands, also ``clip'' very small floating-point
|
|
numbers to zero. If the exponent is less than or equal to the negative
|
|
of the specified precision, the number is changed to 0.0. For example,
|
|
if the current precision is 12, then @kbd{c 2} changes the vector
|
|
@samp{[1e-8, 1e-9, 1e-10, 1e-11]} to @samp{[1e-8, 1e-9, 0, 0]}.
|
|
Numbers this small generally arise from roundoff noise.
|
|
|
|
If the numbers you are using really are legitimately this small,
|
|
you should avoid using the @kbd{c 0} through @kbd{c 9} commands.
|
|
(The plain @kbd{c c} command rounds to the current precision but
|
|
does not clip small numbers.)
|
|
|
|
One more property of @kbd{c 0} through @kbd{c 9}, and of @kbd{c c} with
|
|
a prefix argument, is that integer-valued floats are converted to
|
|
plain integers, so that @kbd{c 1} on @samp{[1., 1.5, 2., 2.5, 3.]}
|
|
produces @samp{[1, 1.5, 2, 2.5, 3]}. This is not done for huge
|
|
numbers (@samp{1e100} is technically an integer-valued float, but
|
|
you wouldn't want it automatically converted to a 100-digit integer).
|
|
|
|
@kindex H c 0-9
|
|
@kindex H c c
|
|
@tindex clean
|
|
With the Hyperbolic flag, @kbd{H c c} and @kbd{H c 0} through @kbd{H c 9}
|
|
operate non-pervasively [@code{clean}].
|
|
|
|
@node Date Arithmetic, Financial Functions, Conversions, Arithmetic
|
|
@section Date Arithmetic
|
|
|
|
@noindent
|
|
@cindex Date arithmetic, additional functions
|
|
The commands described in this section perform various conversions
|
|
and calculations involving date forms (@pxref{Date Forms}). They
|
|
use the @kbd{t} (for time/date) prefix key followed by shifted
|
|
letters.
|
|
|
|
The simplest date arithmetic is done using the regular @kbd{+} and @kbd{-}
|
|
commands. In particular, adding a number to a date form advances the
|
|
date form by a certain number of days; adding an HMS form to a date
|
|
form advances the date by a certain amount of time; and subtracting two
|
|
date forms produces a difference measured in days. The commands
|
|
described here provide additional, more specialized operations on dates.
|
|
|
|
Many of these commands accept a numeric prefix argument; if you give
|
|
plain @kbd{C-u} as the prefix, these commands will instead take the
|
|
additional argument from the top of the stack.
|
|
|
|
@menu
|
|
* Date Conversions::
|
|
* Date Functions::
|
|
* Time Zones::
|
|
* Business Days::
|
|
@end menu
|
|
|
|
@node Date Conversions, Date Functions, Date Arithmetic, Date Arithmetic
|
|
@subsection Date Conversions
|
|
|
|
@noindent
|
|
@kindex t D
|
|
@pindex calc-date
|
|
@tindex date
|
|
The @kbd{t D} (@code{calc-date}) [@code{date}] command converts a
|
|
date form into a number, measured in days since Jan 1, 1 AD. The
|
|
result will be an integer if @var{date} is a pure date form, or a
|
|
fraction or float if @var{date} is a date/time form. Or, if its
|
|
argument is a number, it converts this number into a date form.
|
|
|
|
With a numeric prefix argument, @kbd{t D} takes that many objects
|
|
(up to six) from the top of the stack and interprets them in one
|
|
of the following ways:
|
|
|
|
The @samp{date(@var{year}, @var{month}, @var{day})} function
|
|
builds a pure date form out of the specified year, month, and
|
|
day, which must all be integers. @var{Year} is a year number,
|
|
such as 1991 (@emph{not} the same as 91!). @var{Month} must be
|
|
an integer in the range 1 to 12; @var{day} must be in the range
|
|
1 to 31. If the specified month has fewer than 31 days and
|
|
@var{day} is too large, the equivalent day in the following
|
|
month will be used.
|
|
|
|
The @samp{date(@var{month}, @var{day})} function builds a
|
|
pure date form using the current year, as determined by the
|
|
real-time clock.
|
|
|
|
The @samp{date(@var{year}, @var{month}, @var{day}, @var{hms})}
|
|
function builds a date/time form using an @var{hms} form.
|
|
|
|
The @samp{date(@var{year}, @var{month}, @var{day}, @var{hour},
|
|
@var{minute}, @var{second})} function builds a date/time form.
|
|
@var{hour} should be an integer in the range 0 to 23;
|
|
@var{minute} should be an integer in the range 0 to 59;
|
|
@var{second} should be any real number in the range @samp{[0 .. 60)}.
|
|
The last two arguments default to zero if omitted.
|
|
|
|
@kindex t J
|
|
@pindex calc-julian
|
|
@tindex julian
|
|
@cindex Julian day counts, conversions
|
|
The @kbd{t J} (@code{calc-julian}) [@code{julian}] command converts
|
|
a date form into a Julian day count, which is the number of days
|
|
since noon on Jan 1, 4713 BC. A pure date is converted to an integer
|
|
Julian count representing noon of that day. A date/time form is
|
|
converted to an exact floating-point Julian count, adjusted to
|
|
interpret the date form in the current time zone but the Julian
|
|
day count in Greenwich Mean Time. A numeric prefix argument allows
|
|
you to specify the time zone; @pxref{Time Zones}. Use a prefix of
|
|
zero to suppress the time zone adjustment. Note that pure date forms
|
|
are never time-zone adjusted.
|
|
|
|
This command can also do the opposite conversion, from a Julian day
|
|
count (either an integer day, or a floating-point day and time in
|
|
the GMT zone), into a pure date form or a date/time form in the
|
|
current or specified time zone.
|
|
|
|
@kindex t U
|
|
@pindex calc-unix-time
|
|
@tindex unixtime
|
|
@cindex Unix time format, conversions
|
|
The @kbd{t U} (@code{calc-unix-time}) [@code{unixtime}] command
|
|
converts a date form into a Unix time value, which is the number of
|
|
seconds since midnight on Jan 1, 1970, or vice-versa. The numeric result
|
|
will be an integer if the current precision is 12 or less; for higher
|
|
precisions, the result may be a float with (@var{precision}@minus{}12)
|
|
digits after the decimal. Just as for @kbd{t J}, the numeric time
|
|
is interpreted in the GMT time zone and the date form is interpreted
|
|
in the current or specified zone. Some systems use Unix-like
|
|
numbering but with the local time zone; give a prefix of zero to
|
|
suppress the adjustment if so.
|
|
|
|
@kindex t C
|
|
@pindex calc-convert-time-zones
|
|
@tindex tzconv
|
|
@cindex Time Zones, converting between
|
|
The @kbd{t C} (@code{calc-convert-time-zones}) [@code{tzconv}]
|
|
command converts a date form from one time zone to another. You
|
|
are prompted for each time zone name in turn; you can answer with
|
|
any suitable Calc time zone expression (@pxref{Time Zones}).
|
|
If you answer either prompt with a blank line, the local time
|
|
zone is used for that prompt. You can also answer the first
|
|
prompt with @kbd{$} to take the two time zone names from the
|
|
stack (and the date to be converted from the third stack level).
|
|
|
|
@node Date Functions, Business Days, Date Conversions, Date Arithmetic
|
|
@subsection Date Functions
|
|
|
|
@noindent
|
|
@kindex t N
|
|
@pindex calc-now
|
|
@tindex now
|
|
The @kbd{t N} (@code{calc-now}) [@code{now}] command pushes the
|
|
current date and time on the stack as a date form. The time is
|
|
reported in terms of the specified time zone; with no numeric prefix
|
|
argument, @kbd{t N} reports for the current time zone.
|
|
|
|
@kindex t P
|
|
@pindex calc-date-part
|
|
The @kbd{t P} (@code{calc-date-part}) command extracts one part
|
|
of a date form. The prefix argument specifies the part; with no
|
|
argument, this command prompts for a part code from 1 to 9.
|
|
The various part codes are described in the following paragraphs.
|
|
|
|
@tindex year
|
|
The @kbd{M-1 t P} [@code{year}] function extracts the year number
|
|
from a date form as an integer, e.g., 1991. This and the
|
|
following functions will also accept a real number for an
|
|
argument, which is interpreted as a standard Calc day number.
|
|
Note that this function will never return zero, since the year
|
|
1 BC immediately precedes the year 1 AD.
|
|
|
|
@tindex month
|
|
The @kbd{M-2 t P} [@code{month}] function extracts the month number
|
|
from a date form as an integer in the range 1 to 12.
|
|
|
|
@tindex day
|
|
The @kbd{M-3 t P} [@code{day}] function extracts the day number
|
|
from a date form as an integer in the range 1 to 31.
|
|
|
|
@tindex hour
|
|
The @kbd{M-4 t P} [@code{hour}] function extracts the hour from
|
|
a date form as an integer in the range 0 (midnight) to 23. Note
|
|
that 24-hour time is always used. This returns zero for a pure
|
|
date form. This function (and the following two) also accept
|
|
HMS forms as input.
|
|
|
|
@tindex minute
|
|
The @kbd{M-5 t P} [@code{minute}] function extracts the minute
|
|
from a date form as an integer in the range 0 to 59.
|
|
|
|
@tindex second
|
|
The @kbd{M-6 t P} [@code{second}] function extracts the second
|
|
from a date form. If the current precision is 12 or less,
|
|
the result is an integer in the range 0 to 59. For higher
|
|
precisions, the result may instead be a floating-point number.
|
|
|
|
@tindex weekday
|
|
The @kbd{M-7 t P} [@code{weekday}] function extracts the weekday
|
|
number from a date form as an integer in the range 0 (Sunday)
|
|
to 6 (Saturday).
|
|
|
|
@tindex yearday
|
|
The @kbd{M-8 t P} [@code{yearday}] function extracts the day-of-year
|
|
number from a date form as an integer in the range 1 (January 1)
|
|
to 366 (December 31 of a leap year).
|
|
|
|
@tindex time
|
|
The @kbd{M-9 t P} [@code{time}] function extracts the time portion
|
|
of a date form as an HMS form. This returns @samp{0@@ 0' 0"}
|
|
for a pure date form.
|
|
|
|
@kindex t M
|
|
@pindex calc-new-month
|
|
@tindex newmonth
|
|
The @kbd{t M} (@code{calc-new-month}) [@code{newmonth}] command
|
|
computes a new date form that represents the first day of the month
|
|
specified by the input date. The result is always a pure date
|
|
form; only the year and month numbers of the input are retained.
|
|
With a numeric prefix argument @var{n} in the range from 1 to 31,
|
|
@kbd{t M} computes the @var{n}th day of the month. (If @var{n}
|
|
is greater than the actual number of days in the month, or if
|
|
@var{n} is zero, the last day of the month is used.)
|
|
|
|
@kindex t Y
|
|
@pindex calc-new-year
|
|
@tindex newyear
|
|
The @kbd{t Y} (@code{calc-new-year}) [@code{newyear}] command
|
|
computes a new pure date form that represents the first day of
|
|
the year specified by the input. The month, day, and time
|
|
of the input date form are lost. With a numeric prefix argument
|
|
@var{n} in the range from 1 to 366, @kbd{t Y} computes the
|
|
@var{n}th day of the year (366 is treated as 365 in non-leap
|
|
years). A prefix argument of 0 computes the last day of the
|
|
year (December 31). A negative prefix argument from @mathit{-1} to
|
|
@mathit{-12} computes the first day of the @var{n}th month of the year.
|
|
|
|
@kindex t W
|
|
@pindex calc-new-week
|
|
@tindex newweek
|
|
The @kbd{t W} (@code{calc-new-week}) [@code{newweek}] command
|
|
computes a new pure date form that represents the Sunday on or before
|
|
the input date. With a numeric prefix argument, it can be made to
|
|
use any day of the week as the starting day; the argument must be in
|
|
the range from 0 (Sunday) to 6 (Saturday). This function always
|
|
subtracts between 0 and 6 days from the input date.
|
|
|
|
Here's an example use of @code{newweek}: Find the date of the next
|
|
Wednesday after a given date. Using @kbd{M-3 t W} or @samp{newweek(d, 3)}
|
|
will give you the @emph{preceding} Wednesday, so @samp{newweek(d+7, 3)}
|
|
will give you the following Wednesday. A further look at the definition
|
|
of @code{newweek} shows that if the input date is itself a Wednesday,
|
|
this formula will return the Wednesday one week in the future. An
|
|
exercise for the reader is to modify this formula to yield the same day
|
|
if the input is already a Wednesday. Another interesting exercise is
|
|
to preserve the time-of-day portion of the input (@code{newweek} resets
|
|
the time to midnight; hint:@: how can @code{newweek} be defined in terms
|
|
of the @code{weekday} function?).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pwday
|
|
The @samp{pwday(@var{date})} function (not on any key) computes the
|
|
day-of-month number of the Sunday on or before @var{date}. With
|
|
two arguments, @samp{pwday(@var{date}, @var{day})} computes the day
|
|
number of the Sunday on or before day number @var{day} of the month
|
|
specified by @var{date}. The @var{day} must be in the range from
|
|
7 to 31; if the day number is greater than the actual number of days
|
|
in the month, the true number of days is used instead. Thus
|
|
@samp{pwday(@var{date}, 7)} finds the first Sunday of the month, and
|
|
@samp{pwday(@var{date}, 31)} finds the last Sunday of the month.
|
|
With a third @var{weekday} argument, @code{pwday} can be made to look
|
|
for any day of the week instead of Sunday.
|
|
|
|
@kindex t I
|
|
@pindex calc-inc-month
|
|
@tindex incmonth
|
|
The @kbd{t I} (@code{calc-inc-month}) [@code{incmonth}] command
|
|
increases a date form by one month, or by an arbitrary number of
|
|
months specified by a numeric prefix argument. The time portion,
|
|
if any, of the date form stays the same. The day also stays the
|
|
same, except that if the new month has fewer days the day
|
|
number may be reduced to lie in the valid range. For example,
|
|
@samp{incmonth(<Jan 31, 1991>)} produces @samp{<Feb 28, 1991>}.
|
|
Because of this, @kbd{t I t I} and @kbd{M-2 t I} do not always give
|
|
the same results (@samp{<Mar 28, 1991>} versus @samp{<Mar 31, 1991>}
|
|
in this case).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex incyear
|
|
The @samp{incyear(@var{date}, @var{step})} function increases
|
|
a date form by the specified number of years, which may be
|
|
any positive or negative integer. Note that @samp{incyear(d, n)}
|
|
is equivalent to @w{@samp{incmonth(d, 12*n)}}, but these do not have
|
|
simple equivalents in terms of day arithmetic because
|
|
months and years have varying lengths. If the @var{step}
|
|
argument is omitted, 1 year is assumed. There is no keyboard
|
|
command for this function; use @kbd{C-u 12 t I} instead.
|
|
|
|
There is no @code{newday} function at all because @kbd{F} [@code{floor}]
|
|
serves this purpose. Similarly, instead of @code{incday} and
|
|
@code{incweek} simply use @expr{d + n} or @expr{d + 7 n}.
|
|
|
|
@xref{Basic Arithmetic}, for the @kbd{f ]} [@code{incr}] command
|
|
which can adjust a date/time form by a certain number of seconds.
|
|
|
|
@node Business Days, Time Zones, Date Functions, Date Arithmetic
|
|
@subsection Business Days
|
|
|
|
@noindent
|
|
Often time is measured in ``business days'' or ``working days,''
|
|
where weekends and holidays are skipped. Calc's normal date
|
|
arithmetic functions use calendar days, so that subtracting two
|
|
consecutive Mondays will yield a difference of 7 days. By contrast,
|
|
subtracting two consecutive Mondays would yield 5 business days
|
|
(assuming two-day weekends and the absence of holidays).
|
|
|
|
@kindex t +
|
|
@kindex t -
|
|
@tindex badd
|
|
@tindex bsub
|
|
@pindex calc-business-days-plus
|
|
@pindex calc-business-days-minus
|
|
The @kbd{t +} (@code{calc-business-days-plus}) [@code{badd}]
|
|
and @kbd{t -} (@code{calc-business-days-minus}) [@code{bsub}]
|
|
commands perform arithmetic using business days. For @kbd{t +},
|
|
one argument must be a date form and the other must be a real
|
|
number (positive or negative). If the number is not an integer,
|
|
then a certain amount of time is added as well as a number of
|
|
days; for example, adding 0.5 business days to a time in Friday
|
|
evening will produce a time in Monday morning. It is also
|
|
possible to add an HMS form; adding @samp{12@@ 0' 0"} also adds
|
|
half a business day. For @kbd{t -}, the arguments are either a
|
|
date form and a number or HMS form, or two date forms, in which
|
|
case the result is the number of business days between the two
|
|
dates.
|
|
|
|
@cindex @code{Holidays} variable
|
|
@vindex Holidays
|
|
By default, Calc considers any day that is not a Saturday or
|
|
Sunday to be a business day. You can define any number of
|
|
additional holidays by editing the variable @code{Holidays}.
|
|
(There is an @w{@kbd{s H}} convenience command for editing this
|
|
variable.) Initially, @code{Holidays} contains the vector
|
|
@samp{[sat, sun]}. Entries in the @code{Holidays} vector may
|
|
be any of the following kinds of objects:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Date forms (pure dates, not date/time forms). These specify
|
|
particular days which are to be treated as holidays.
|
|
|
|
@item
|
|
Intervals of date forms. These specify a range of days, all of
|
|
which are holidays (e.g., Christmas week). @xref{Interval Forms}.
|
|
|
|
@item
|
|
Nested vectors of date forms. Each date form in the vector is
|
|
considered to be a holiday.
|
|
|
|
@item
|
|
Any Calc formula which evaluates to one of the above three things.
|
|
If the formula involves the variable @expr{y}, it stands for a
|
|
yearly repeating holiday; @expr{y} will take on various year
|
|
numbers like 1992. For example, @samp{date(y, 12, 25)} specifies
|
|
Christmas day, and @samp{newweek(date(y, 11, 7), 4) + 21} specifies
|
|
Thanksgiving (which is held on the fourth Thursday of November).
|
|
If the formula involves the variable @expr{m}, that variable
|
|
takes on month numbers from 1 to 12: @samp{date(y, m, 15)} is
|
|
a holiday that takes place on the 15th of every month.
|
|
|
|
@item
|
|
A weekday name, such as @code{sat} or @code{sun}. This is really
|
|
a variable whose name is a three-letter, lower-case day name.
|
|
|
|
@item
|
|
An interval of year numbers (integers). This specifies the span of
|
|
years over which this holiday list is to be considered valid. Any
|
|
business-day arithmetic that goes outside this range will result
|
|
in an error message. Use this if you are including an explicit
|
|
list of holidays, rather than a formula to generate them, and you
|
|
want to make sure you don't accidentally go beyond the last point
|
|
where the holidays you entered are complete. If there is no
|
|
limiting interval in the @code{Holidays} vector, the default
|
|
@samp{[1 .. 2737]} is used. (This is the absolute range of years
|
|
for which Calc's business-day algorithms will operate.)
|
|
|
|
@item
|
|
An interval of HMS forms. This specifies the span of hours that
|
|
are to be considered one business day. For example, if this
|
|
range is @samp{[9@@ 0' 0" .. 17@@ 0' 0"]} (i.e., 9am to 5pm), then
|
|
the business day is only eight hours long, so that @kbd{1.5 t +}
|
|
on @samp{<4:00pm Fri Dec 13, 1991>} will add one business day and
|
|
four business hours to produce @samp{<12:00pm Tue Dec 17, 1991>}.
|
|
Likewise, @kbd{t -} will now express differences in time as
|
|
fractions of an eight-hour day. Times before 9am will be treated
|
|
as 9am by business date arithmetic, and times at or after 5pm will
|
|
be treated as 4:59:59pm. If there is no HMS interval in @code{Holidays},
|
|
the full 24-hour day @samp{[0@ 0' 0" .. 24@ 0' 0"]} is assumed.
|
|
(Regardless of the type of bounds you specify, the interval is
|
|
treated as inclusive on the low end and exclusive on the high end,
|
|
so that the work day goes from 9am up to, but not including, 5pm.)
|
|
@end itemize
|
|
|
|
If the @code{Holidays} vector is empty, then @kbd{t +} and
|
|
@kbd{t -} will act just like @kbd{+} and @kbd{-} because there will
|
|
then be no difference between business days and calendar days.
|
|
|
|
Calc expands the intervals and formulas you give into a complete
|
|
list of holidays for internal use. This is done mainly to make
|
|
sure it can detect multiple holidays. (For example,
|
|
@samp{<Jan 1, 1989>} is both New Year's Day and a Sunday, but
|
|
Calc's algorithms take care to count it only once when figuring
|
|
the number of holidays between two dates.)
|
|
|
|
Since the complete list of holidays for all the years from 1 to
|
|
2737 would be huge, Calc actually computes only the part of the
|
|
list between the smallest and largest years that have been involved
|
|
in business-day calculations so far. Normally, you won't have to
|
|
worry about this. Keep in mind, however, that if you do one
|
|
calculation for 1992, and another for 1792, even if both involve
|
|
only a small range of years, Calc will still work out all the
|
|
holidays that fall in that 200-year span.
|
|
|
|
If you add a (positive) number of days to a date form that falls on a
|
|
weekend or holiday, the date form is treated as if it were the most
|
|
recent business day. (Thus adding one business day to a Friday,
|
|
Saturday, or Sunday will all yield the following Monday.) If you
|
|
subtract a number of days from a weekend or holiday, the date is
|
|
effectively on the following business day. (So subtracting one business
|
|
day from Saturday, Sunday, or Monday yields the preceding Friday.) The
|
|
difference between two dates one or both of which fall on holidays
|
|
equals the number of actual business days between them. These
|
|
conventions are consistent in the sense that, if you add @var{n}
|
|
business days to any date, the difference between the result and the
|
|
original date will come out to @var{n} business days. (It can't be
|
|
completely consistent though; a subtraction followed by an addition
|
|
might come out a bit differently, since @kbd{t +} is incapable of
|
|
producing a date that falls on a weekend or holiday.)
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex holiday
|
|
There is a @code{holiday} function, not on any keys, that takes
|
|
any date form and returns 1 if that date falls on a weekend or
|
|
holiday, as defined in @code{Holidays}, or 0 if the date is a
|
|
business day.
|
|
|
|
@node Time Zones, , Business Days, Date Arithmetic
|
|
@subsection Time Zones
|
|
|
|
@noindent
|
|
@cindex Time zones
|
|
@cindex Daylight savings time
|
|
Time zones and daylight savings time are a complicated business.
|
|
The conversions to and from Julian and Unix-style dates automatically
|
|
compute the correct time zone and daylight savings adjustment to use,
|
|
provided they can figure out this information. This section describes
|
|
Calc's time zone adjustment algorithm in detail, in case you want to
|
|
do conversions in different time zones or in case Calc's algorithms
|
|
can't determine the right correction to use.
|
|
|
|
Adjustments for time zones and daylight savings time are done by
|
|
@kbd{t U}, @kbd{t J}, @kbd{t N}, and @kbd{t C}, but not by any other
|
|
commands. In particular, @samp{<may 1 1991> - <apr 1 1991>} evaluates
|
|
to exactly 30 days even though there is a daylight-savings
|
|
transition in between. This is also true for Julian pure dates:
|
|
@samp{julian(<may 1 1991>) - julian(<apr 1 1991>)}. But Julian
|
|
and Unix date/times will adjust for daylight savings time:
|
|
@samp{julian(<12am may 1 1991>) - julian(<12am apr 1 1991>)}
|
|
evaluates to @samp{29.95834} (that's 29 days and 23 hours)
|
|
because one hour was lost when daylight savings commenced on
|
|
April 7, 1991.
|
|
|
|
In brief, the idiom @samp{julian(@var{date1}) - julian(@var{date2})}
|
|
computes the actual number of 24-hour periods between two dates, whereas
|
|
@samp{@var{date1} - @var{date2}} computes the number of calendar
|
|
days between two dates without taking daylight savings into account.
|
|
|
|
@pindex calc-time-zone
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex tzone
|
|
The @code{calc-time-zone} [@code{tzone}] command converts the time
|
|
zone specified by its numeric prefix argument into a number of
|
|
seconds difference from Greenwich mean time (GMT). If the argument
|
|
is a number, the result is simply that value multiplied by 3600.
|
|
Typical arguments for North America are 5 (Eastern) or 8 (Pacific). If
|
|
Daylight Savings time is in effect, one hour should be subtracted from
|
|
the normal difference.
|
|
|
|
If you give a prefix of plain @kbd{C-u}, @code{calc-time-zone} (like other
|
|
date arithmetic commands that include a time zone argument) takes the
|
|
zone argument from the top of the stack. (In the case of @kbd{t J}
|
|
and @kbd{t U}, the normal argument is then taken from the second-to-top
|
|
stack position.) This allows you to give a non-integer time zone
|
|
adjustment. The time-zone argument can also be an HMS form, or
|
|
it can be a variable which is a time zone name in upper- or lower-case.
|
|
For example @samp{tzone(PST) = tzone(8)} and @samp{tzone(pdt) = tzone(7)}
|
|
(for Pacific standard and daylight savings times, respectively).
|
|
|
|
North American and European time zone names are defined as follows;
|
|
note that for each time zone there is one name for standard time,
|
|
another for daylight savings time, and a third for ``generalized'' time
|
|
in which the daylight savings adjustment is computed from context.
|
|
|
|
@smallexample
|
|
@group
|
|
YST PST MST CST EST AST NST GMT WET MET MEZ
|
|
9 8 7 6 5 4 3.5 0 -1 -2 -2
|
|
|
|
YDT PDT MDT CDT EDT ADT NDT BST WETDST METDST MESZ
|
|
8 7 6 5 4 3 2.5 -1 -2 -3 -3
|
|
|
|
YGT PGT MGT CGT EGT AGT NGT BGT WEGT MEGT MEGZ
|
|
9/8 8/7 7/6 6/5 5/4 4/3 3.5/2.5 0/-1 -1/-2 -2/-3 -2/-3
|
|
@end group
|
|
@end smallexample
|
|
|
|
@vindex math-tzone-names
|
|
To define time zone names that do not appear in the above table,
|
|
you must modify the Lisp variable @code{math-tzone-names}. This
|
|
is a list of lists describing the different time zone names; its
|
|
structure is best explained by an example. The three entries for
|
|
Pacific Time look like this:
|
|
|
|
@smallexample
|
|
@group
|
|
( ( "PST" 8 0 ) ; Name as an upper-case string, then standard
|
|
( "PDT" 8 -1 ) ; adjustment, then daylight savings adjustment.
|
|
( "PGT" 8 "PST" "PDT" ) ) ; Generalized time zone.
|
|
@end group
|
|
@end smallexample
|
|
|
|
@cindex @code{TimeZone} variable
|
|
@vindex TimeZone
|
|
With no arguments, @code{calc-time-zone} or @samp{tzone()} obtains an
|
|
argument from the Calc variable @code{TimeZone} if a value has been
|
|
stored for that variable. If not, Calc runs the Unix @samp{date}
|
|
command and looks for one of the above time zone names in the output;
|
|
if this does not succeed, @samp{tzone()} leaves itself unevaluated.
|
|
The time zone name in the @samp{date} output may be followed by a signed
|
|
adjustment, e.g., @samp{GMT+5} or @samp{GMT+0500} which specifies a
|
|
number of hours and minutes to be added to the base time zone.
|
|
Calc stores the time zone it finds into @code{TimeZone} to speed
|
|
later calls to @samp{tzone()}.
|
|
|
|
The special time zone name @code{local} is equivalent to no argument,
|
|
i.e., it uses the local time zone as obtained from the @code{date}
|
|
command.
|
|
|
|
If the time zone name found is one of the standard or daylight
|
|
savings zone names from the above table, and Calc's internal
|
|
daylight savings algorithm says that time and zone are consistent
|
|
(e.g., @code{PDT} accompanies a date that Calc's algorithm would also
|
|
consider to be daylight savings, or @code{PST} accompanies a date
|
|
that Calc would consider to be standard time), then Calc substitutes
|
|
the corresponding generalized time zone (like @code{PGT}).
|
|
|
|
If your system does not have a suitable @samp{date} command, you
|
|
may wish to put a @samp{(setq var-TimeZone ...)} in your Emacs
|
|
initialization file to set the time zone. (Since you are interacting
|
|
with the variable @code{TimeZone} directly from Emacs Lisp, the
|
|
@code{var-} prefix needs to be present.) The easiest way to do
|
|
this is to edit the @code{TimeZone} variable using Calc's @kbd{s T}
|
|
command, then use the @kbd{s p} (@code{calc-permanent-variable})
|
|
command to save the value of @code{TimeZone} permanently.
|
|
|
|
The @kbd{t J} and @code{t U} commands with no numeric prefix
|
|
arguments do the same thing as @samp{tzone()}. If the current
|
|
time zone is a generalized time zone, e.g., @code{EGT}, Calc
|
|
examines the date being converted to tell whether to use standard
|
|
or daylight savings time. But if the current time zone is explicit,
|
|
e.g., @code{EST} or @code{EDT}, then that adjustment is used exactly
|
|
and Calc's daylight savings algorithm is not consulted.
|
|
|
|
Some places don't follow the usual rules for daylight savings time.
|
|
The state of Arizona, for example, does not observe daylight savings
|
|
time. If you run Calc during the winter season in Arizona, the
|
|
Unix @code{date} command will report @code{MST} time zone, which
|
|
Calc will change to @code{MGT}. If you then convert a time that
|
|
lies in the summer months, Calc will apply an incorrect daylight
|
|
savings time adjustment. To avoid this, set your @code{TimeZone}
|
|
variable explicitly to @code{MST} to force the use of standard,
|
|
non-daylight-savings time.
|
|
|
|
@vindex math-daylight-savings-hook
|
|
@findex math-std-daylight-savings
|
|
By default Calc always considers daylight savings time to begin at
|
|
2 a.m.@: on the first Sunday of April, and to end at 2 a.m.@: on the
|
|
last Sunday of October. This is the rule that has been in effect
|
|
in North America since 1987. If you are in a country that uses
|
|
different rules for computing daylight savings time, you have two
|
|
choices: Write your own daylight savings hook, or control time
|
|
zones explicitly by setting the @code{TimeZone} variable and/or
|
|
always giving a time-zone argument for the conversion functions.
|
|
|
|
The Lisp variable @code{math-daylight-savings-hook} holds the
|
|
name of a function that is used to compute the daylight savings
|
|
adjustment for a given date. The default is
|
|
@code{math-std-daylight-savings}, which computes an adjustment
|
|
(either 0 or @mathit{-1}) using the North American rules given above.
|
|
|
|
The daylight savings hook function is called with four arguments:
|
|
The date, as a floating-point number in standard Calc format;
|
|
a six-element list of the date decomposed into year, month, day,
|
|
hour, minute, and second, respectively; a string which contains
|
|
the generalized time zone name in upper-case, e.g., @code{"WEGT"};
|
|
and a special adjustment to be applied to the hour value when
|
|
converting into a generalized time zone (see below).
|
|
|
|
@findex math-prev-weekday-in-month
|
|
The Lisp function @code{math-prev-weekday-in-month} is useful for
|
|
daylight savings computations. This is an internal version of
|
|
the user-level @code{pwday} function described in the previous
|
|
section. It takes four arguments: The floating-point date value,
|
|
the corresponding six-element date list, the day-of-month number,
|
|
and the weekday number (0-6).
|
|
|
|
The default daylight savings hook ignores the time zone name, but a
|
|
more sophisticated hook could use different algorithms for different
|
|
time zones. It would also be possible to use different algorithms
|
|
depending on the year number, but the default hook always uses the
|
|
algorithm for 1987 and later. Here is a listing of the default
|
|
daylight savings hook:
|
|
|
|
@smallexample
|
|
(defun math-std-daylight-savings (date dt zone bump)
|
|
(cond ((< (nth 1 dt) 4) 0)
|
|
((= (nth 1 dt) 4)
|
|
(let ((sunday (math-prev-weekday-in-month date dt 7 0)))
|
|
(cond ((< (nth 2 dt) sunday) 0)
|
|
((= (nth 2 dt) sunday)
|
|
(if (>= (nth 3 dt) (+ 3 bump)) -1 0))
|
|
(t -1))))
|
|
((< (nth 1 dt) 10) -1)
|
|
((= (nth 1 dt) 10)
|
|
(let ((sunday (math-prev-weekday-in-month date dt 31 0)))
|
|
(cond ((< (nth 2 dt) sunday) -1)
|
|
((= (nth 2 dt) sunday)
|
|
(if (>= (nth 3 dt) (+ 2 bump)) 0 -1))
|
|
(t 0))))
|
|
(t 0))
|
|
)
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The @code{bump} parameter is equal to zero when Calc is converting
|
|
from a date form in a generalized time zone into a GMT date value.
|
|
It is @mathit{-1} when Calc is converting in the other direction. The
|
|
adjustments shown above ensure that the conversion behaves correctly
|
|
and reasonably around the 2 a.m.@: transition in each direction.
|
|
|
|
There is a ``missing'' hour between 2 a.m.@: and 3 a.m.@: at the
|
|
beginning of daylight savings time; converting a date/time form that
|
|
falls in this hour results in a time value for the following hour,
|
|
from 3 a.m.@: to 4 a.m. At the end of daylight savings time, the
|
|
hour from 1 a.m.@: to 2 a.m.@: repeats itself; converting a date/time
|
|
form that falls in this hour results in a time value for the first
|
|
manifestation of that time (@emph{not} the one that occurs one hour later).
|
|
|
|
If @code{math-daylight-savings-hook} is @code{nil}, then the
|
|
daylight savings adjustment is always taken to be zero.
|
|
|
|
In algebraic formulas, @samp{tzone(@var{zone}, @var{date})}
|
|
computes the time zone adjustment for a given zone name at a
|
|
given date. The @var{date} is ignored unless @var{zone} is a
|
|
generalized time zone. If @var{date} is a date form, the
|
|
daylight savings computation is applied to it as it appears.
|
|
If @var{date} is a numeric date value, it is adjusted for the
|
|
daylight-savings version of @var{zone} before being given to
|
|
the daylight savings hook. This odd-sounding rule ensures
|
|
that the daylight-savings computation is always done in
|
|
local time, not in the GMT time that a numeric @var{date}
|
|
is typically represented in.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex dsadj
|
|
The @samp{dsadj(@var{date}, @var{zone})} function computes the
|
|
daylight savings adjustment that is appropriate for @var{date} in
|
|
time zone @var{zone}. If @var{zone} is explicitly in or not in
|
|
daylight savings time (e.g., @code{PDT} or @code{PST}) the
|
|
@var{date} is ignored. If @var{zone} is a generalized time zone,
|
|
the algorithms described above are used. If @var{zone} is omitted,
|
|
the computation is done for the current time zone.
|
|
|
|
@xref{Reporting Bugs}, for the address of Calc's author, if you
|
|
should wish to contribute your improved versions of
|
|
@code{math-tzone-names} and @code{math-daylight-savings-hook}
|
|
to the Calc distribution.
|
|
|
|
@node Financial Functions, Binary Functions, Date Arithmetic, Arithmetic
|
|
@section Financial Functions
|
|
|
|
@noindent
|
|
Calc's financial or business functions use the @kbd{b} prefix
|
|
key followed by a shifted letter. (The @kbd{b} prefix followed by
|
|
a lower-case letter is used for operations on binary numbers.)
|
|
|
|
Note that the rate and the number of intervals given to these
|
|
functions must be on the same time scale, e.g., both months or
|
|
both years. Mixing an annual interest rate with a time expressed
|
|
in months will give you very wrong answers!
|
|
|
|
It is wise to compute these functions to a higher precision than
|
|
you really need, just to make sure your answer is correct to the
|
|
last penny; also, you may wish to check the definitions at the end
|
|
of this section to make sure the functions have the meaning you expect.
|
|
|
|
@menu
|
|
* Percentages::
|
|
* Future Value::
|
|
* Present Value::
|
|
* Related Financial Functions::
|
|
* Depreciation Functions::
|
|
* Definitions of Financial Functions::
|
|
@end menu
|
|
|
|
@node Percentages, Future Value, Financial Functions, Financial Functions
|
|
@subsection Percentages
|
|
|
|
@kindex M-%
|
|
@pindex calc-percent
|
|
@tindex %
|
|
@tindex percent
|
|
The @kbd{M-%} (@code{calc-percent}) command takes a percentage value,
|
|
say 5.4, and converts it to an equivalent actual number. For example,
|
|
@kbd{5.4 M-%} enters 0.054 on the stack. (That's the @key{META} or
|
|
@key{ESC} key combined with @kbd{%}.)
|
|
|
|
Actually, @kbd{M-%} creates a formula of the form @samp{5.4%}.
|
|
You can enter @samp{5.4%} yourself during algebraic entry. The
|
|
@samp{%} operator simply means, ``the preceding value divided by
|
|
100.'' The @samp{%} operator has very high precedence, so that
|
|
@samp{1+8%} is interpreted as @samp{1+(8%)}, not as @samp{(1+8)%}.
|
|
(The @samp{%} operator is just a postfix notation for the
|
|
@code{percent} function, just like @samp{20!} is the notation for
|
|
@samp{fact(20)}, or twenty-factorial.)
|
|
|
|
The formula @samp{5.4%} would normally evaluate immediately to
|
|
0.054, but the @kbd{M-%} command suppresses evaluation as it puts
|
|
the formula onto the stack. However, the next Calc command that
|
|
uses the formula @samp{5.4%} will evaluate it as its first step.
|
|
The net effect is that you get to look at @samp{5.4%} on the stack,
|
|
but Calc commands see it as @samp{0.054}, which is what they expect.
|
|
|
|
In particular, @samp{5.4%} and @samp{0.054} are suitable values
|
|
for the @var{rate} arguments of the various financial functions,
|
|
but the number @samp{5.4} is probably @emph{not} suitable---it
|
|
represents a rate of 540 percent!
|
|
|
|
The key sequence @kbd{M-% *} effectively means ``percent-of.''
|
|
For example, @kbd{68 @key{RET} 25 M-% *} computes 17, which is 25% of
|
|
68 (and also 68% of 25, which comes out to the same thing).
|
|
|
|
@kindex c %
|
|
@pindex calc-convert-percent
|
|
The @kbd{c %} (@code{calc-convert-percent}) command converts the
|
|
value on the top of the stack from numeric to percentage form.
|
|
For example, if 0.08 is on the stack, @kbd{c %} converts it to
|
|
@samp{8%}. The quantity is the same, it's just represented
|
|
differently. (Contrast this with @kbd{M-%}, which would convert
|
|
this number to @samp{0.08%}.) The @kbd{=} key is a convenient way
|
|
to convert a formula like @samp{8%} back to numeric form, 0.08.
|
|
|
|
To compute what percentage one quantity is of another quantity,
|
|
use @kbd{/ c %}. For example, @w{@kbd{17 @key{RET} 68 / c %}} displays
|
|
@samp{25%}.
|
|
|
|
@kindex b %
|
|
@pindex calc-percent-change
|
|
@tindex relch
|
|
The @kbd{b %} (@code{calc-percent-change}) [@code{relch}] command
|
|
calculates the percentage change from one number to another.
|
|
For example, @kbd{40 @key{RET} 50 b %} produces the answer @samp{25%},
|
|
since 50 is 25% larger than 40. A negative result represents a
|
|
decrease: @kbd{50 @key{RET} 40 b %} produces @samp{-20%}, since 40 is
|
|
20% smaller than 50. (The answers are different in magnitude
|
|
because, in the first case, we're increasing by 25% of 40, but
|
|
in the second case, we're decreasing by 20% of 50.) The effect
|
|
of @kbd{40 @key{RET} 50 b %} is to compute @expr{(50-40)/40}, converting
|
|
the answer to percentage form as if by @kbd{c %}.
|
|
|
|
@node Future Value, Present Value, Percentages, Financial Functions
|
|
@subsection Future Value
|
|
|
|
@noindent
|
|
@kindex b F
|
|
@pindex calc-fin-fv
|
|
@tindex fv
|
|
The @kbd{b F} (@code{calc-fin-fv}) [@code{fv}] command computes
|
|
the future value of an investment. It takes three arguments
|
|
from the stack: @samp{fv(@var{rate}, @var{n}, @var{payment})}.
|
|
If you give payments of @var{payment} every year for @var{n}
|
|
years, and the money you have paid earns interest at @var{rate} per
|
|
year, then this function tells you what your investment would be
|
|
worth at the end of the period. (The actual interval doesn't
|
|
have to be years, as long as @var{n} and @var{rate} are expressed
|
|
in terms of the same intervals.) This function assumes payments
|
|
occur at the @emph{end} of each interval.
|
|
|
|
@kindex I b F
|
|
@tindex fvb
|
|
The @kbd{I b F} [@code{fvb}] command does the same computation,
|
|
but assuming your payments are at the beginning of each interval.
|
|
Suppose you plan to deposit $1000 per year in a savings account
|
|
earning 5.4% interest, starting right now. How much will be
|
|
in the account after five years? @code{fvb(5.4%, 5, 1000) = 5870.73}.
|
|
Thus you will have earned $870 worth of interest over the years.
|
|
Using the stack, this calculation would have been
|
|
@kbd{5.4 M-% 5 @key{RET} 1000 I b F}. Note that the rate is expressed
|
|
as a number between 0 and 1, @emph{not} as a percentage.
|
|
|
|
@kindex H b F
|
|
@tindex fvl
|
|
The @kbd{H b F} [@code{fvl}] command computes the future value
|
|
of an initial lump sum investment. Suppose you could deposit
|
|
those five thousand dollars in the bank right now; how much would
|
|
they be worth in five years? @code{fvl(5.4%, 5, 5000) = 6503.89}.
|
|
|
|
The algebraic functions @code{fv} and @code{fvb} accept an optional
|
|
fourth argument, which is used as an initial lump sum in the sense
|
|
of @code{fvl}. In other words, @code{fv(@var{rate}, @var{n},
|
|
@var{payment}, @var{initial}) = fv(@var{rate}, @var{n}, @var{payment})
|
|
+ fvl(@var{rate}, @var{n}, @var{initial})}.
|
|
|
|
To illustrate the relationships between these functions, we could
|
|
do the @code{fvb} calculation ``by hand'' using @code{fvl}. The
|
|
final balance will be the sum of the contributions of our five
|
|
deposits at various times. The first deposit earns interest for
|
|
five years: @code{fvl(5.4%, 5, 1000) = 1300.78}. The second
|
|
deposit only earns interest for four years: @code{fvl(5.4%, 4, 1000) =
|
|
1234.13}. And so on down to the last deposit, which earns one
|
|
year's interest: @code{fvl(5.4%, 1, 1000) = 1054.00}. The sum of
|
|
these five values is, sure enough, $5870.73, just as was computed
|
|
by @code{fvb} directly.
|
|
|
|
What does @code{fv(5.4%, 5, 1000) = 5569.96} mean? The payments
|
|
are now at the ends of the periods. The end of one year is the same
|
|
as the beginning of the next, so what this really means is that we've
|
|
lost the payment at year zero (which contributed $1300.78), but we're
|
|
now counting the payment at year five (which, since it didn't have
|
|
a chance to earn interest, counts as $1000). Indeed, @expr{5569.96 =
|
|
5870.73 - 1300.78 + 1000} (give or take a bit of roundoff error).
|
|
|
|
@node Present Value, Related Financial Functions, Future Value, Financial Functions
|
|
@subsection Present Value
|
|
|
|
@noindent
|
|
@kindex b P
|
|
@pindex calc-fin-pv
|
|
@tindex pv
|
|
The @kbd{b P} (@code{calc-fin-pv}) [@code{pv}] command computes
|
|
the present value of an investment. Like @code{fv}, it takes
|
|
three arguments: @code{pv(@var{rate}, @var{n}, @var{payment})}.
|
|
It computes the present value of a series of regular payments.
|
|
Suppose you have the chance to make an investment that will
|
|
pay $2000 per year over the next four years; as you receive
|
|
these payments you can put them in the bank at 9% interest.
|
|
You want to know whether it is better to make the investment, or
|
|
to keep the money in the bank where it earns 9% interest right
|
|
from the start. The calculation @code{pv(9%, 4, 2000)} gives the
|
|
result 6479.44. If your initial investment must be less than this,
|
|
say, $6000, then the investment is worthwhile. But if you had to
|
|
put up $7000, then it would be better just to leave it in the bank.
|
|
|
|
Here is the interpretation of the result of @code{pv}: You are
|
|
trying to compare the return from the investment you are
|
|
considering, which is @code{fv(9%, 4, 2000) = 9146.26}, with
|
|
the return from leaving the money in the bank, which is
|
|
@code{fvl(9%, 4, @var{x})} where @var{x} is the amount of money
|
|
you would have to put up in advance. The @code{pv} function
|
|
finds the break-even point, @expr{x = 6479.44}, at which
|
|
@code{fvl(9%, 4, 6479.44)} is also equal to 9146.26. This is
|
|
the largest amount you should be willing to invest.
|
|
|
|
@kindex I b P
|
|
@tindex pvb
|
|
The @kbd{I b P} [@code{pvb}] command solves the same problem,
|
|
but with payments occurring at the beginning of each interval.
|
|
It has the same relationship to @code{fvb} as @code{pv} has
|
|
to @code{fv}. For example @code{pvb(9%, 4, 2000) = 7062.59},
|
|
a larger number than @code{pv} produced because we get to start
|
|
earning interest on the return from our investment sooner.
|
|
|
|
@kindex H b P
|
|
@tindex pvl
|
|
The @kbd{H b P} [@code{pvl}] command computes the present value of
|
|
an investment that will pay off in one lump sum at the end of the
|
|
period. For example, if we get our $8000 all at the end of the
|
|
four years, @code{pvl(9%, 4, 8000) = 5667.40}. This is much
|
|
less than @code{pv} reported, because we don't earn any interest
|
|
on the return from this investment. Note that @code{pvl} and
|
|
@code{fvl} are simple inverses: @code{fvl(9%, 4, 5667.40) = 8000}.
|
|
|
|
You can give an optional fourth lump-sum argument to @code{pv}
|
|
and @code{pvb}; this is handled in exactly the same way as the
|
|
fourth argument for @code{fv} and @code{fvb}.
|
|
|
|
@kindex b N
|
|
@pindex calc-fin-npv
|
|
@tindex npv
|
|
The @kbd{b N} (@code{calc-fin-npv}) [@code{npv}] command computes
|
|
the net present value of a series of irregular investments.
|
|
The first argument is the interest rate. The second argument is
|
|
a vector which represents the expected return from the investment
|
|
at the end of each interval. For example, if the rate represents
|
|
a yearly interest rate, then the vector elements are the return
|
|
from the first year, second year, and so on.
|
|
|
|
Thus, @code{npv(9%, [2000,2000,2000,2000]) = pv(9%, 4, 2000) = 6479.44}.
|
|
Obviously this function is more interesting when the payments are
|
|
not all the same!
|
|
|
|
The @code{npv} function can actually have two or more arguments.
|
|
Multiple arguments are interpreted in the same way as for the
|
|
vector statistical functions like @code{vsum}.
|
|
@xref{Single-Variable Statistics}. Basically, if there are several
|
|
payment arguments, each either a vector or a plain number, all these
|
|
values are collected left-to-right into the complete list of payments.
|
|
A numeric prefix argument on the @kbd{b N} command says how many
|
|
payment values or vectors to take from the stack.
|
|
|
|
@kindex I b N
|
|
@tindex npvb
|
|
The @kbd{I b N} [@code{npvb}] command computes the net present
|
|
value where payments occur at the beginning of each interval
|
|
rather than at the end.
|
|
|
|
@node Related Financial Functions, Depreciation Functions, Present Value, Financial Functions
|
|
@subsection Related Financial Functions
|
|
|
|
@noindent
|
|
The functions in this section are basically inverses of the
|
|
present value functions with respect to the various arguments.
|
|
|
|
@kindex b M
|
|
@pindex calc-fin-pmt
|
|
@tindex pmt
|
|
The @kbd{b M} (@code{calc-fin-pmt}) [@code{pmt}] command computes
|
|
the amount of periodic payment necessary to amortize a loan.
|
|
Thus @code{pmt(@var{rate}, @var{n}, @var{amount})} equals the
|
|
value of @var{payment} such that @code{pv(@var{rate}, @var{n},
|
|
@var{payment}) = @var{amount}}.
|
|
|
|
@kindex I b M
|
|
@tindex pmtb
|
|
The @kbd{I b M} [@code{pmtb}] command does the same computation
|
|
but using @code{pvb} instead of @code{pv}. Like @code{pv} and
|
|
@code{pvb}, these functions can also take a fourth argument which
|
|
represents an initial lump-sum investment.
|
|
|
|
@kindex H b M
|
|
The @kbd{H b M} key just invokes the @code{fvl} function, which is
|
|
the inverse of @code{pvl}. There is no explicit @code{pmtl} function.
|
|
|
|
@kindex b #
|
|
@pindex calc-fin-nper
|
|
@tindex nper
|
|
The @kbd{b #} (@code{calc-fin-nper}) [@code{nper}] command computes
|
|
the number of regular payments necessary to amortize a loan.
|
|
Thus @code{nper(@var{rate}, @var{payment}, @var{amount})} equals
|
|
the value of @var{n} such that @code{pv(@var{rate}, @var{n},
|
|
@var{payment}) = @var{amount}}. If @var{payment} is too small
|
|
ever to amortize a loan for @var{amount} at interest rate @var{rate},
|
|
the @code{nper} function is left in symbolic form.
|
|
|
|
@kindex I b #
|
|
@tindex nperb
|
|
The @kbd{I b #} [@code{nperb}] command does the same computation
|
|
but using @code{pvb} instead of @code{pv}. You can give a fourth
|
|
lump-sum argument to these functions, but the computation will be
|
|
rather slow in the four-argument case.
|
|
|
|
@kindex H b #
|
|
@tindex nperl
|
|
The @kbd{H b #} [@code{nperl}] command does the same computation
|
|
using @code{pvl}. By exchanging @var{payment} and @var{amount} you
|
|
can also get the solution for @code{fvl}. For example,
|
|
@code{nperl(8%, 2000, 1000) = 9.006}, so if you place $1000 in a
|
|
bank account earning 8%, it will take nine years to grow to $2000.
|
|
|
|
@kindex b T
|
|
@pindex calc-fin-rate
|
|
@tindex rate
|
|
The @kbd{b T} (@code{calc-fin-rate}) [@code{rate}] command computes
|
|
the rate of return on an investment. This is also an inverse of @code{pv}:
|
|
@code{rate(@var{n}, @var{payment}, @var{amount})} computes the value of
|
|
@var{rate} such that @code{pv(@var{rate}, @var{n}, @var{payment}) =
|
|
@var{amount}}. The result is expressed as a formula like @samp{6.3%}.
|
|
|
|
@kindex I b T
|
|
@kindex H b T
|
|
@tindex rateb
|
|
@tindex ratel
|
|
The @kbd{I b T} [@code{rateb}] and @kbd{H b T} [@code{ratel}]
|
|
commands solve the analogous equations with @code{pvb} or @code{pvl}
|
|
in place of @code{pv}. Also, @code{rate} and @code{rateb} can
|
|
accept an optional fourth argument just like @code{pv} and @code{pvb}.
|
|
To redo the above example from a different perspective,
|
|
@code{ratel(9, 2000, 1000) = 8.00597%}, which says you will need an
|
|
interest rate of 8% in order to double your account in nine years.
|
|
|
|
@kindex b I
|
|
@pindex calc-fin-irr
|
|
@tindex irr
|
|
The @kbd{b I} (@code{calc-fin-irr}) [@code{irr}] command is the
|
|
analogous function to @code{rate} but for net present value.
|
|
Its argument is a vector of payments. Thus @code{irr(@var{payments})}
|
|
computes the @var{rate} such that @code{npv(@var{rate}, @var{payments}) = 0};
|
|
this rate is known as the @dfn{internal rate of return}.
|
|
|
|
@kindex I b I
|
|
@tindex irrb
|
|
The @kbd{I b I} [@code{irrb}] command computes the internal rate of
|
|
return assuming payments occur at the beginning of each period.
|
|
|
|
@node Depreciation Functions, Definitions of Financial Functions, Related Financial Functions, Financial Functions
|
|
@subsection Depreciation Functions
|
|
|
|
@noindent
|
|
The functions in this section calculate @dfn{depreciation}, which is
|
|
the amount of value that a possession loses over time. These functions
|
|
are characterized by three parameters: @var{cost}, the original cost
|
|
of the asset; @var{salvage}, the value the asset will have at the end
|
|
of its expected ``useful life''; and @var{life}, the number of years
|
|
(or other periods) of the expected useful life.
|
|
|
|
There are several methods for calculating depreciation that differ in
|
|
the way they spread the depreciation over the lifetime of the asset.
|
|
|
|
@kindex b S
|
|
@pindex calc-fin-sln
|
|
@tindex sln
|
|
The @kbd{b S} (@code{calc-fin-sln}) [@code{sln}] command computes the
|
|
``straight-line'' depreciation. In this method, the asset depreciates
|
|
by the same amount every year (or period). For example,
|
|
@samp{sln(12000, 2000, 5)} returns 2000. The asset costs $12000
|
|
initially and will be worth $2000 after five years; it loses $2000
|
|
per year.
|
|
|
|
@kindex b Y
|
|
@pindex calc-fin-syd
|
|
@tindex syd
|
|
The @kbd{b Y} (@code{calc-fin-syd}) [@code{syd}] command computes the
|
|
accelerated ``sum-of-years'-digits'' depreciation. Here the depreciation
|
|
is higher during the early years of the asset's life. Since the
|
|
depreciation is different each year, @kbd{b Y} takes a fourth @var{period}
|
|
parameter which specifies which year is requested, from 1 to @var{life}.
|
|
If @var{period} is outside this range, the @code{syd} function will
|
|
return zero.
|
|
|
|
@kindex b D
|
|
@pindex calc-fin-ddb
|
|
@tindex ddb
|
|
The @kbd{b D} (@code{calc-fin-ddb}) [@code{ddb}] command computes an
|
|
accelerated depreciation using the double-declining balance method.
|
|
It also takes a fourth @var{period} parameter.
|
|
|
|
For symmetry, the @code{sln} function will accept a @var{period}
|
|
parameter as well, although it will ignore its value except that the
|
|
return value will as usual be zero if @var{period} is out of range.
|
|
|
|
For example, pushing the vector @expr{[1,2,3,4,5]} (perhaps with @kbd{v x 5})
|
|
and then mapping @kbd{V M ' [sln(12000,2000,5,$), syd(12000,2000,5,$),
|
|
ddb(12000,2000,5,$)] @key{RET}} produces a matrix that allows us to compare
|
|
the three depreciation methods:
|
|
|
|
@example
|
|
@group
|
|
[ [ 2000, 3333, 4800 ]
|
|
[ 2000, 2667, 2880 ]
|
|
[ 2000, 2000, 1728 ]
|
|
[ 2000, 1333, 592 ]
|
|
[ 2000, 667, 0 ] ]
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
(Values have been rounded to nearest integers in this figure.)
|
|
We see that @code{sln} depreciates by the same amount each year,
|
|
@kbd{syd} depreciates more at the beginning and less at the end,
|
|
and @kbd{ddb} weights the depreciation even more toward the beginning.
|
|
|
|
Summing columns with @kbd{V R : +} yields @expr{[10000, 10000, 10000]};
|
|
the total depreciation in any method is (by definition) the
|
|
difference between the cost and the salvage value.
|
|
|
|
@node Definitions of Financial Functions, , Depreciation Functions, Financial Functions
|
|
@subsection Definitions
|
|
|
|
@noindent
|
|
For your reference, here are the actual formulas used to compute
|
|
Calc's financial functions.
|
|
|
|
Calc will not evaluate a financial function unless the @var{rate} or
|
|
@var{n} argument is known. However, @var{payment} or @var{amount} can
|
|
be a variable. Calc expands these functions according to the
|
|
formulas below for symbolic arguments only when you use the @kbd{a "}
|
|
(@code{calc-expand-formula}) command, or when taking derivatives or
|
|
integrals or solving equations involving the functions.
|
|
|
|
@ifinfo
|
|
These formulas are shown using the conventions of Big display
|
|
mode (@kbd{d B}); for example, the formula for @code{fv} written
|
|
linearly is @samp{pmt * ((1 + rate)^n) - 1) / rate}.
|
|
|
|
@example
|
|
n
|
|
(1 + rate) - 1
|
|
fv(rate, n, pmt) = pmt * ---------------
|
|
rate
|
|
|
|
n
|
|
((1 + rate) - 1) (1 + rate)
|
|
fvb(rate, n, pmt) = pmt * ----------------------------
|
|
rate
|
|
|
|
n
|
|
fvl(rate, n, pmt) = pmt * (1 + rate)
|
|
|
|
-n
|
|
1 - (1 + rate)
|
|
pv(rate, n, pmt) = pmt * ----------------
|
|
rate
|
|
|
|
-n
|
|
(1 - (1 + rate) ) (1 + rate)
|
|
pvb(rate, n, pmt) = pmt * -----------------------------
|
|
rate
|
|
|
|
-n
|
|
pvl(rate, n, pmt) = pmt * (1 + rate)
|
|
|
|
-1 -2 -3
|
|
npv(rate, [a, b, c]) = a*(1 + rate) + b*(1 + rate) + c*(1 + rate)
|
|
|
|
-1 -2
|
|
npvb(rate, [a, b, c]) = a + b*(1 + rate) + c*(1 + rate)
|
|
|
|
-n
|
|
(amt - x * (1 + rate) ) * rate
|
|
pmt(rate, n, amt, x) = -------------------------------
|
|
-n
|
|
1 - (1 + rate)
|
|
|
|
-n
|
|
(amt - x * (1 + rate) ) * rate
|
|
pmtb(rate, n, amt, x) = -------------------------------
|
|
-n
|
|
(1 - (1 + rate) ) (1 + rate)
|
|
|
|
amt * rate
|
|
nper(rate, pmt, amt) = - log(1 - ------------, 1 + rate)
|
|
pmt
|
|
|
|
amt * rate
|
|
nperb(rate, pmt, amt) = - log(1 - ---------------, 1 + rate)
|
|
pmt * (1 + rate)
|
|
|
|
amt
|
|
nperl(rate, pmt, amt) = - log(---, 1 + rate)
|
|
pmt
|
|
|
|
1/n
|
|
pmt
|
|
ratel(n, pmt, amt) = ------ - 1
|
|
1/n
|
|
amt
|
|
|
|
cost - salv
|
|
sln(cost, salv, life) = -----------
|
|
life
|
|
|
|
(cost - salv) * (life - per + 1)
|
|
syd(cost, salv, life, per) = --------------------------------
|
|
life * (life + 1) / 2
|
|
|
|
book * 2
|
|
ddb(cost, salv, life, per) = --------, book = cost - depreciation so far
|
|
life
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
$$ \code{fv}(r, n, p) = p { (1 + r)^n - 1 \over r } $$
|
|
$$ \code{fvb}(r, n, p) = p { ((1 + r)^n - 1) (1 + r) \over r } $$
|
|
$$ \code{fvl}(r, n, p) = p (1 + r)^n $$
|
|
$$ \code{pv}(r, n, p) = p { 1 - (1 + r)^{-n} \over r } $$
|
|
$$ \code{pvb}(r, n, p) = p { (1 - (1 + r)^{-n}) (1 + r) \over r } $$
|
|
$$ \code{pvl}(r, n, p) = p (1 + r)^{-n} $$
|
|
$$ \code{npv}(r, [a,b,c]) = a (1 + r)^{-1} + b (1 + r)^{-2} + c (1 + r)^{-3} $$
|
|
$$ \code{npvb}(r, [a,b,c]) = a + b (1 + r)^{-1} + c (1 + r)^{-2} $$
|
|
$$ \code{pmt}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over 1 - (1 + r)^{-n} }$$
|
|
$$ \code{pmtb}(r, n, a, x) = { (a - x (1 + r)^{-n}) r \over
|
|
(1 - (1 + r)^{-n}) (1 + r) } $$
|
|
$$ \code{nper}(r, p, a) = -\code{log}(1 - { a r \over p }, 1 + r) $$
|
|
$$ \code{nperb}(r, p, a) = -\code{log}(1 - { a r \over p (1 + r) }, 1 + r) $$
|
|
$$ \code{nperl}(r, p, a) = -\code{log}({a \over p}, 1 + r) $$
|
|
$$ \code{ratel}(n, p, a) = { p^{1/n} \over a^{1/n} } - 1 $$
|
|
$$ \code{sln}(c, s, l) = { c - s \over l } $$
|
|
$$ \code{syd}(c, s, l, p) = { (c - s) (l - p + 1) \over l (l+1) / 2 } $$
|
|
$$ \code{ddb}(c, s, l, p) = { 2 (c - \hbox{depreciation so far}) \over l } $$
|
|
@end tex
|
|
|
|
@noindent
|
|
In @code{pmt} and @code{pmtb}, @expr{x=0} if omitted.
|
|
|
|
These functions accept any numeric objects, including error forms,
|
|
intervals, and even (though not very usefully) complex numbers. The
|
|
above formulas specify exactly the behavior of these functions with
|
|
all sorts of inputs.
|
|
|
|
Note that if the first argument to the @code{log} in @code{nper} is
|
|
negative, @code{nper} leaves itself in symbolic form rather than
|
|
returning a (financially meaningless) complex number.
|
|
|
|
@samp{rate(num, pmt, amt)} solves the equation
|
|
@samp{pv(rate, num, pmt) = amt} for @samp{rate} using @kbd{H a R}
|
|
(@code{calc-find-root}), with the interval @samp{[.01% .. 100%]}
|
|
for an initial guess. The @code{rateb} function is the same except
|
|
that it uses @code{pvb}. Note that @code{ratel} can be solved
|
|
directly; its formula is shown in the above list.
|
|
|
|
Similarly, @samp{irr(pmts)} solves the equation @samp{npv(rate, pmts) = 0}
|
|
for @samp{rate}.
|
|
|
|
If you give a fourth argument to @code{nper} or @code{nperb}, Calc
|
|
will also use @kbd{H a R} to solve the equation using an initial
|
|
guess interval of @samp{[0 .. 100]}.
|
|
|
|
A fourth argument to @code{fv} simply sums the two components
|
|
calculated from the above formulas for @code{fv} and @code{fvl}.
|
|
The same is true of @code{fvb}, @code{pv}, and @code{pvb}.
|
|
|
|
The @kbd{ddb} function is computed iteratively; the ``book'' value
|
|
starts out equal to @var{cost}, and decreases according to the above
|
|
formula for the specified number of periods. If the book value
|
|
would decrease below @var{salvage}, it only decreases to @var{salvage}
|
|
and the depreciation is zero for all subsequent periods. The @code{ddb}
|
|
function returns the amount the book value decreased in the specified
|
|
period.
|
|
|
|
@node Binary Functions, , Financial Functions, Arithmetic
|
|
@section Binary Number Functions
|
|
|
|
@noindent
|
|
The commands in this chapter all use two-letter sequences beginning with
|
|
the @kbd{b} prefix.
|
|
|
|
@cindex Binary numbers
|
|
The ``binary'' operations actually work regardless of the currently
|
|
displayed radix, although their results make the most sense in a radix
|
|
like 2, 8, or 16 (as obtained by the @kbd{d 2}, @kbd{d 8}, or @w{@kbd{d 6}}
|
|
commands, respectively). You may also wish to enable display of leading
|
|
zeros with @kbd{d z}. @xref{Radix Modes}.
|
|
|
|
@cindex Word size for binary operations
|
|
The Calculator maintains a current @dfn{word size} @expr{w}, an
|
|
arbitrary positive or negative integer. For a positive word size, all
|
|
of the binary operations described here operate modulo @expr{2^w}. In
|
|
particular, negative arguments are converted to positive integers modulo
|
|
@expr{2^w} by all binary functions.
|
|
|
|
If the word size is negative, binary operations produce 2's complement
|
|
integers from
|
|
@texline @math{-2^{-w-1}}
|
|
@infoline @expr{-(2^(-w-1))}
|
|
to
|
|
@texline @math{2^{-w-1}-1}
|
|
@infoline @expr{2^(-w-1)-1}
|
|
inclusive. Either mode accepts inputs in any range; the sign of
|
|
@expr{w} affects only the results produced.
|
|
|
|
@kindex b c
|
|
@pindex calc-clip
|
|
@tindex clip
|
|
The @kbd{b c} (@code{calc-clip})
|
|
[@code{clip}] command can be used to clip a number by reducing it modulo
|
|
@expr{2^w}. The commands described in this chapter automatically clip
|
|
their results to the current word size. Note that other operations like
|
|
addition do not use the current word size, since integer addition
|
|
generally is not ``binary.'' (However, @pxref{Simplification Modes},
|
|
@code{calc-bin-simplify-mode}.) For example, with a word size of 8
|
|
bits @kbd{b c} converts a number to the range 0 to 255; with a word
|
|
size of @mathit{-8} @kbd{b c} converts to the range @mathit{-128} to 127.
|
|
|
|
@kindex b w
|
|
@pindex calc-word-size
|
|
The default word size is 32 bits. All operations except the shifts and
|
|
rotates allow you to specify a different word size for that one
|
|
operation by giving a numeric prefix argument: @kbd{C-u 8 b c} clips the
|
|
top of stack to the range 0 to 255 regardless of the current word size.
|
|
To set the word size permanently, use @kbd{b w} (@code{calc-word-size}).
|
|
This command displays a prompt with the current word size; press @key{RET}
|
|
immediately to keep this word size, or type a new word size at the prompt.
|
|
|
|
When the binary operations are written in symbolic form, they take an
|
|
optional second (or third) word-size parameter. When a formula like
|
|
@samp{and(a,b)} is finally evaluated, the word size current at that time
|
|
will be used, but when @samp{and(a,b,-8)} is evaluated, a word size of
|
|
@mathit{-8} will always be used. A symbolic binary function will be left
|
|
in symbolic form unless the all of its argument(s) are integers or
|
|
integer-valued floats.
|
|
|
|
If either or both arguments are modulo forms for which @expr{M} is a
|
|
power of two, that power of two is taken as the word size unless a
|
|
numeric prefix argument overrides it. The current word size is never
|
|
consulted when modulo-power-of-two forms are involved.
|
|
|
|
@kindex b a
|
|
@pindex calc-and
|
|
@tindex and
|
|
The @kbd{b a} (@code{calc-and}) [@code{and}] command computes the bitwise
|
|
AND of the two numbers on the top of the stack. In other words, for each
|
|
of the @expr{w} binary digits of the two numbers (pairwise), the corresponding
|
|
bit of the result is 1 if and only if both input bits are 1:
|
|
@samp{and(2#1100, 2#1010) = 2#1000}.
|
|
|
|
@kindex b o
|
|
@pindex calc-or
|
|
@tindex or
|
|
The @kbd{b o} (@code{calc-or}) [@code{or}] command computes the bitwise
|
|
inclusive OR of two numbers. A bit is 1 if either of the input bits, or
|
|
both, are 1: @samp{or(2#1100, 2#1010) = 2#1110}.
|
|
|
|
@kindex b x
|
|
@pindex calc-xor
|
|
@tindex xor
|
|
The @kbd{b x} (@code{calc-xor}) [@code{xor}] command computes the bitwise
|
|
exclusive OR of two numbers. A bit is 1 if exactly one of the input bits
|
|
is 1: @samp{xor(2#1100, 2#1010) = 2#0110}.
|
|
|
|
@kindex b d
|
|
@pindex calc-diff
|
|
@tindex diff
|
|
The @kbd{b d} (@code{calc-diff}) [@code{diff}] command computes the bitwise
|
|
difference of two numbers; this is defined by @samp{diff(a,b) = and(a,not(b))},
|
|
so that @samp{diff(2#1100, 2#1010) = 2#0100}.
|
|
|
|
@kindex b n
|
|
@pindex calc-not
|
|
@tindex not
|
|
The @kbd{b n} (@code{calc-not}) [@code{not}] command computes the bitwise
|
|
NOT of a number. A bit is 1 if the input bit is 0 and vice-versa.
|
|
|
|
@kindex b l
|
|
@pindex calc-lshift-binary
|
|
@tindex lsh
|
|
The @kbd{b l} (@code{calc-lshift-binary}) [@code{lsh}] command shifts a
|
|
number left by one bit, or by the number of bits specified in the numeric
|
|
prefix argument. A negative prefix argument performs a logical right shift,
|
|
in which zeros are shifted in on the left. In symbolic form, @samp{lsh(a)}
|
|
is short for @samp{lsh(a,1)}, which in turn is short for @samp{lsh(a,n,w)}.
|
|
Bits shifted ``off the end,'' according to the current word size, are lost.
|
|
|
|
@kindex H b l
|
|
@kindex H b r
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex H b L
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H b R
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H b t
|
|
The @kbd{H b l} command also does a left shift, but it takes two arguments
|
|
from the stack (the value to shift, and, at top-of-stack, the number of
|
|
bits to shift). This version interprets the prefix argument just like
|
|
the regular binary operations, i.e., as a word size. The Hyperbolic flag
|
|
has a similar effect on the rest of the binary shift and rotate commands.
|
|
|
|
@kindex b r
|
|
@pindex calc-rshift-binary
|
|
@tindex rsh
|
|
The @kbd{b r} (@code{calc-rshift-binary}) [@code{rsh}] command shifts a
|
|
number right by one bit, or by the number of bits specified in the numeric
|
|
prefix argument: @samp{rsh(a,n) = lsh(a,-n)}.
|
|
|
|
@kindex b L
|
|
@pindex calc-lshift-arith
|
|
@tindex ash
|
|
The @kbd{b L} (@code{calc-lshift-arith}) [@code{ash}] command shifts a
|
|
number left. It is analogous to @code{lsh}, except that if the shift
|
|
is rightward (the prefix argument is negative), an arithmetic shift
|
|
is performed as described below.
|
|
|
|
@kindex b R
|
|
@pindex calc-rshift-arith
|
|
@tindex rash
|
|
The @kbd{b R} (@code{calc-rshift-arith}) [@code{rash}] command performs
|
|
an ``arithmetic'' shift to the right, in which the leftmost bit (according
|
|
to the current word size) is duplicated rather than shifting in zeros.
|
|
This corresponds to dividing by a power of two where the input is interpreted
|
|
as a signed, twos-complement number. (The distinction between the @samp{rsh}
|
|
and @samp{rash} operations is totally independent from whether the word
|
|
size is positive or negative.) With a negative prefix argument, this
|
|
performs a standard left shift.
|
|
|
|
@kindex b t
|
|
@pindex calc-rotate-binary
|
|
@tindex rot
|
|
The @kbd{b t} (@code{calc-rotate-binary}) [@code{rot}] command rotates a
|
|
number one bit to the left. The leftmost bit (according to the current
|
|
word size) is dropped off the left and shifted in on the right. With a
|
|
numeric prefix argument, the number is rotated that many bits to the left
|
|
or right.
|
|
|
|
@xref{Set Operations}, for the @kbd{b p} and @kbd{b u} commands that
|
|
pack and unpack binary integers into sets. (For example, @kbd{b u}
|
|
unpacks the number @samp{2#11001} to the set of bit-numbers
|
|
@samp{[0, 3, 4]}.) Type @kbd{b u V #} to count the number of ``1''
|
|
bits in a binary integer.
|
|
|
|
Another interesting use of the set representation of binary integers
|
|
is to reverse the bits in, say, a 32-bit integer. Type @kbd{b u} to
|
|
unpack; type @kbd{31 @key{TAB} -} to replace each bit-number in the set
|
|
with 31 minus that bit-number; type @kbd{b p} to pack the set back
|
|
into a binary integer.
|
|
|
|
@node Scientific Functions, Matrix Functions, Arithmetic, Top
|
|
@chapter Scientific Functions
|
|
|
|
@noindent
|
|
The functions described here perform trigonometric and other transcendental
|
|
calculations. They generally produce floating-point answers correct to the
|
|
full current precision. The @kbd{H} (Hyperbolic) and @kbd{I} (Inverse)
|
|
flag keys must be used to get some of these functions from the keyboard.
|
|
|
|
@kindex P
|
|
@pindex calc-pi
|
|
@cindex @code{pi} variable
|
|
@vindex pi
|
|
@kindex H P
|
|
@cindex @code{e} variable
|
|
@vindex e
|
|
@kindex I P
|
|
@cindex @code{gamma} variable
|
|
@vindex gamma
|
|
@cindex Gamma constant, Euler's
|
|
@cindex Euler's gamma constant
|
|
@kindex H I P
|
|
@cindex @code{phi} variable
|
|
@cindex Phi, golden ratio
|
|
@cindex Golden ratio
|
|
One miscellaneous command is shift-@kbd{P} (@code{calc-pi}), which pushes
|
|
the value of @cpi{} (at the current precision) onto the stack. With the
|
|
Hyperbolic flag, it pushes the value @expr{e}, the base of natural logarithms.
|
|
With the Inverse flag, it pushes Euler's constant
|
|
@texline @math{\gamma}
|
|
@infoline @expr{gamma}
|
|
(about 0.5772). With both Inverse and Hyperbolic, it
|
|
pushes the ``golden ratio''
|
|
@texline @math{\phi}
|
|
@infoline @expr{phi}
|
|
(about 1.618). (At present, Euler's constant is not available
|
|
to unlimited precision; Calc knows only the first 100 digits.)
|
|
In Symbolic mode, these commands push the
|
|
actual variables @samp{pi}, @samp{e}, @samp{gamma}, and @samp{phi},
|
|
respectively, instead of their values; @pxref{Symbolic Mode}.
|
|
|
|
@ignore
|
|
@mindex Q
|
|
@end ignore
|
|
@ignore
|
|
@mindex I Q
|
|
@end ignore
|
|
@kindex I Q
|
|
@tindex sqr
|
|
The @kbd{Q} (@code{calc-sqrt}) [@code{sqrt}] function is described elsewhere;
|
|
@pxref{Basic Arithmetic}. With the Inverse flag [@code{sqr}], this command
|
|
computes the square of the argument.
|
|
|
|
@xref{Prefix Arguments}, for a discussion of the effect of numeric
|
|
prefix arguments on commands in this chapter which do not otherwise
|
|
interpret a prefix argument.
|
|
|
|
@menu
|
|
* Logarithmic Functions::
|
|
* Trigonometric and Hyperbolic Functions::
|
|
* Advanced Math Functions::
|
|
* Branch Cuts::
|
|
* Random Numbers::
|
|
* Combinatorial Functions::
|
|
* Probability Distribution Functions::
|
|
@end menu
|
|
|
|
@node Logarithmic Functions, Trigonometric and Hyperbolic Functions, Scientific Functions, Scientific Functions
|
|
@section Logarithmic Functions
|
|
|
|
@noindent
|
|
@kindex L
|
|
@pindex calc-ln
|
|
@tindex ln
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex I E
|
|
The shift-@kbd{L} (@code{calc-ln}) [@code{ln}] command computes the natural
|
|
logarithm of the real or complex number on the top of the stack. With
|
|
the Inverse flag it computes the exponential function instead, although
|
|
this is redundant with the @kbd{E} command.
|
|
|
|
@kindex E
|
|
@pindex calc-exp
|
|
@tindex exp
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex I L
|
|
The shift-@kbd{E} (@code{calc-exp}) [@code{exp}] command computes the
|
|
exponential, i.e., @expr{e} raised to the power of the number on the stack.
|
|
The meanings of the Inverse and Hyperbolic flags follow from those for
|
|
the @code{calc-ln} command.
|
|
|
|
@kindex H L
|
|
@kindex H E
|
|
@pindex calc-log10
|
|
@tindex log10
|
|
@tindex exp10
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I L
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I E
|
|
The @kbd{H L} (@code{calc-log10}) [@code{log10}] command computes the common
|
|
(base-10) logarithm of a number. (With the Inverse flag [@code{exp10}],
|
|
it raises ten to a given power.) Note that the common logarithm of a
|
|
complex number is computed by taking the natural logarithm and dividing
|
|
by
|
|
@texline @math{\ln10}.
|
|
@infoline @expr{ln(10)}.
|
|
|
|
@kindex B
|
|
@kindex I B
|
|
@pindex calc-log
|
|
@tindex log
|
|
@tindex alog
|
|
The @kbd{B} (@code{calc-log}) [@code{log}] command computes a logarithm
|
|
to any base. For example, @kbd{1024 @key{RET} 2 B} produces 10, since
|
|
@texline @math{2^{10} = 1024}.
|
|
@infoline @expr{2^10 = 1024}.
|
|
In certain cases like @samp{log(3,9)}, the result
|
|
will be either @expr{1:2} or @expr{0.5} depending on the current Fraction
|
|
mode setting. With the Inverse flag [@code{alog}], this command is
|
|
similar to @kbd{^} except that the order of the arguments is reversed.
|
|
|
|
@kindex f I
|
|
@pindex calc-ilog
|
|
@tindex ilog
|
|
The @kbd{f I} (@code{calc-ilog}) [@code{ilog}] command computes the
|
|
integer logarithm of a number to any base. The number and the base must
|
|
themselves be positive integers. This is the true logarithm, rounded
|
|
down to an integer. Thus @kbd{ilog(x,10)} is 3 for all @expr{x} in the
|
|
range from 1000 to 9999. If both arguments are positive integers, exact
|
|
integer arithmetic is used; otherwise, this is equivalent to
|
|
@samp{floor(log(x,b))}.
|
|
|
|
@kindex f E
|
|
@pindex calc-expm1
|
|
@tindex expm1
|
|
The @kbd{f E} (@code{calc-expm1}) [@code{expm1}] command computes
|
|
@texline @math{e^x - 1},
|
|
@infoline @expr{exp(x)-1},
|
|
but using an algorithm that produces a more accurate
|
|
answer when the result is close to zero, i.e., when
|
|
@texline @math{e^x}
|
|
@infoline @expr{exp(x)}
|
|
is close to one.
|
|
|
|
@kindex f L
|
|
@pindex calc-lnp1
|
|
@tindex lnp1
|
|
The @kbd{f L} (@code{calc-lnp1}) [@code{lnp1}] command computes
|
|
@texline @math{\ln(x+1)},
|
|
@infoline @expr{ln(x+1)},
|
|
producing a more accurate answer when @expr{x} is close to zero.
|
|
|
|
@node Trigonometric and Hyperbolic Functions, Advanced Math Functions, Logarithmic Functions, Scientific Functions
|
|
@section Trigonometric/Hyperbolic Functions
|
|
|
|
@noindent
|
|
@kindex S
|
|
@pindex calc-sin
|
|
@tindex sin
|
|
The shift-@kbd{S} (@code{calc-sin}) [@code{sin}] command computes the sine
|
|
of an angle or complex number. If the input is an HMS form, it is interpreted
|
|
as degrees-minutes-seconds; otherwise, the input is interpreted according
|
|
to the current angular mode. It is best to use Radians mode when operating
|
|
on complex numbers.
|
|
|
|
Calc's ``units'' mechanism includes angular units like @code{deg},
|
|
@code{rad}, and @code{grad}. While @samp{sin(45 deg)} is not evaluated
|
|
all the time, the @kbd{u s} (@code{calc-simplify-units}) command will
|
|
simplify @samp{sin(45 deg)} by taking the sine of 45 degrees, regardless
|
|
of the current angular mode. @xref{Basic Operations on Units}.
|
|
|
|
Also, the symbolic variable @code{pi} is not ordinarily recognized in
|
|
arguments to trigonometric functions, as in @samp{sin(3 pi / 4)}, but
|
|
the @kbd{a s} (@code{calc-simplify}) command recognizes many such
|
|
formulas when the current angular mode is Radians @emph{and} Symbolic
|
|
mode is enabled; this example would be replaced by @samp{sqrt(2) / 2}.
|
|
@xref{Symbolic Mode}. Beware, this simplification occurs even if you
|
|
have stored a different value in the variable @samp{pi}; this is one
|
|
reason why changing built-in variables is a bad idea. Arguments of
|
|
the form @expr{x} plus a multiple of @cpiover{2} are also simplified.
|
|
Calc includes similar formulas for @code{cos} and @code{tan}.
|
|
|
|
The @kbd{a s} command knows all angles which are integer multiples of
|
|
@cpiover{12}, @cpiover{10}, or @cpiover{8} radians. In Degrees mode,
|
|
analogous simplifications occur for integer multiples of 15 or 18
|
|
degrees, and for arguments plus multiples of 90 degrees.
|
|
|
|
@kindex I S
|
|
@pindex calc-arcsin
|
|
@tindex arcsin
|
|
With the Inverse flag, @code{calc-sin} computes an arcsine. This is also
|
|
available as the @code{calc-arcsin} command or @code{arcsin} algebraic
|
|
function. The returned argument is converted to degrees, radians, or HMS
|
|
notation depending on the current angular mode.
|
|
|
|
@kindex H S
|
|
@pindex calc-sinh
|
|
@tindex sinh
|
|
@kindex H I S
|
|
@pindex calc-arcsinh
|
|
@tindex arcsinh
|
|
With the Hyperbolic flag, @code{calc-sin} computes the hyperbolic
|
|
sine, also available as @code{calc-sinh} [@code{sinh}]. With the
|
|
Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
|
|
(@code{calc-arcsinh}) [@code{arcsinh}].
|
|
|
|
@kindex C
|
|
@pindex calc-cos
|
|
@tindex cos
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I C
|
|
@pindex calc-arccos
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex arccos
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H C
|
|
@pindex calc-cosh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex cosh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I C
|
|
@pindex calc-arccosh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex arccosh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex T
|
|
@pindex calc-tan
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex tan
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex I T
|
|
@pindex calc-arctan
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex arctan
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H T
|
|
@pindex calc-tanh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex tanh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I T
|
|
@pindex calc-arctanh
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex arctanh
|
|
The shift-@kbd{C} (@code{calc-cos}) [@code{cos}] command computes the cosine
|
|
of an angle or complex number, and shift-@kbd{T} (@code{calc-tan}) [@code{tan}]
|
|
computes the tangent, along with all the various inverse and hyperbolic
|
|
variants of these functions.
|
|
|
|
@kindex f T
|
|
@pindex calc-arctan2
|
|
@tindex arctan2
|
|
The @kbd{f T} (@code{calc-arctan2}) [@code{arctan2}] command takes two
|
|
numbers from the stack and computes the arc tangent of their ratio. The
|
|
result is in the full range from @mathit{-180} (exclusive) to @mathit{+180}
|
|
(inclusive) degrees, or the analogous range in radians. A similar
|
|
result would be obtained with @kbd{/} followed by @kbd{I T}, but the
|
|
value would only be in the range from @mathit{-90} to @mathit{+90} degrees
|
|
since the division loses information about the signs of the two
|
|
components, and an error might result from an explicit division by zero
|
|
which @code{arctan2} would avoid. By (arbitrary) definition,
|
|
@samp{arctan2(0,0)=0}.
|
|
|
|
@pindex calc-sincos
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex sincos
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex arc@idots
|
|
@end ignore
|
|
@tindex arcsincos
|
|
The @code{calc-sincos} [@code{sincos}] command computes the sine and
|
|
cosine of a number, returning them as a vector of the form
|
|
@samp{[@var{cos}, @var{sin}]}.
|
|
With the Inverse flag [@code{arcsincos}], this command takes a two-element
|
|
vector as an argument and computes @code{arctan2} of the elements.
|
|
(This command does not accept the Hyperbolic flag.)
|
|
|
|
@pindex calc-sec
|
|
@tindex sec
|
|
@pindex calc-csc
|
|
@tindex csc
|
|
@pindex calc-cot
|
|
@tindex cot
|
|
@pindex calc-sech
|
|
@tindex sech
|
|
@pindex calc-csch
|
|
@tindex csch
|
|
@pindex calc-coth
|
|
@tindex coth
|
|
The remaining trigonometric functions, @code{calc-sec} [@code{sec}],
|
|
@code{calc-csc} [@code{csc}] and @code{calc-sec} [@code{sec}], are also
|
|
available. With the Hyperbolic flag, these compute their hyperbolic
|
|
counterparts, which are also available separately as @code{calc-sech}
|
|
[@code{sech}], @code{calc-csch} [@code{csch}] and @code{calc-sech}
|
|
[@code{sech}]. (These commmands do not accept the Inverse flag.)
|
|
|
|
@node Advanced Math Functions, Branch Cuts, Trigonometric and Hyperbolic Functions, Scientific Functions
|
|
@section Advanced Mathematical Functions
|
|
|
|
@noindent
|
|
Calc can compute a variety of less common functions that arise in
|
|
various branches of mathematics. All of the functions described in
|
|
this section allow arbitrary complex arguments and, except as noted,
|
|
will work to arbitrarily large precisions. They can not at present
|
|
handle error forms or intervals as arguments.
|
|
|
|
NOTE: These functions are still experimental. In particular, their
|
|
accuracy is not guaranteed in all domains. It is advisable to set the
|
|
current precision comfortably higher than you actually need when
|
|
using these functions. Also, these functions may be impractically
|
|
slow for some values of the arguments.
|
|
|
|
@kindex f g
|
|
@pindex calc-gamma
|
|
@tindex gamma
|
|
The @kbd{f g} (@code{calc-gamma}) [@code{gamma}] command computes the Euler
|
|
gamma function. For positive integer arguments, this is related to the
|
|
factorial function: @samp{gamma(n+1) = fact(n)}. For general complex
|
|
arguments the gamma function can be defined by the following definite
|
|
integral:
|
|
@texline @math{\Gamma(a) = \int_0^\infty t^{a-1} e^t dt}.
|
|
@infoline @expr{gamma(a) = integ(t^(a-1) exp(t), t, 0, inf)}.
|
|
(The actual implementation uses far more efficient computational methods.)
|
|
|
|
@kindex f G
|
|
@tindex gammaP
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I f G
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H f G
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H I f G
|
|
@pindex calc-inc-gamma
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex gammaQ
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex gammag
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex gammaG
|
|
The @kbd{f G} (@code{calc-inc-gamma}) [@code{gammaP}] command computes
|
|
the incomplete gamma function, denoted @samp{P(a,x)}. This is defined by
|
|
the integral,
|
|
@texline @math{P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)}.
|
|
@infoline @expr{gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a)}.
|
|
This implies that @samp{gammaP(a,inf) = 1} for any @expr{a} (see the
|
|
definition of the normal gamma function).
|
|
|
|
Several other varieties of incomplete gamma function are defined.
|
|
The complement of @expr{P(a,x)}, called @expr{Q(a,x) = 1-P(a,x)} by
|
|
some authors, is computed by the @kbd{I f G} [@code{gammaQ}] command.
|
|
You can think of this as taking the other half of the integral, from
|
|
@expr{x} to infinity.
|
|
|
|
@ifinfo
|
|
The functions corresponding to the integrals that define @expr{P(a,x)}
|
|
and @expr{Q(a,x)} but without the normalizing @expr{1/gamma(a)}
|
|
factor are called @expr{g(a,x)} and @expr{G(a,x)}, respectively
|
|
(where @expr{g} and @expr{G} represent the lower- and upper-case Greek
|
|
letter gamma). You can obtain these using the @kbd{H f G} [@code{gammag}]
|
|
and @kbd{H I f G} [@code{gammaG}] commands.
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
The functions corresponding to the integrals that define $P(a,x)$
|
|
and $Q(a,x)$ but without the normalizing $1/\Gamma(a)$
|
|
factor are called $\gamma(a,x)$ and $\Gamma(a,x)$, respectively.
|
|
You can obtain these using the \kbd{H f G} [\code{gammag}] and
|
|
\kbd{I H f G} [\code{gammaG}] commands.
|
|
@end tex
|
|
|
|
@kindex f b
|
|
@pindex calc-beta
|
|
@tindex beta
|
|
The @kbd{f b} (@code{calc-beta}) [@code{beta}] command computes the
|
|
Euler beta function, which is defined in terms of the gamma function as
|
|
@texline @math{B(a,b) = \Gamma(a) \Gamma(b) / \Gamma(a+b)},
|
|
@infoline @expr{beta(a,b) = gamma(a) gamma(b) / gamma(a+b)},
|
|
or by
|
|
@texline @math{B(a,b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt}.
|
|
@infoline @expr{beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1)}.
|
|
|
|
@kindex f B
|
|
@kindex H f B
|
|
@pindex calc-inc-beta
|
|
@tindex betaI
|
|
@tindex betaB
|
|
The @kbd{f B} (@code{calc-inc-beta}) [@code{betaI}] command computes
|
|
the incomplete beta function @expr{I(x,a,b)}. It is defined by
|
|
@texline @math{I(x,a,b) = \left( \int_0^x t^{a-1} (1-t)^{b-1} dt \right) / B(a,b)}.
|
|
@infoline @expr{betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b)}.
|
|
Once again, the @kbd{H} (hyperbolic) prefix gives the corresponding
|
|
un-normalized version [@code{betaB}].
|
|
|
|
@kindex f e
|
|
@kindex I f e
|
|
@pindex calc-erf
|
|
@tindex erf
|
|
@tindex erfc
|
|
The @kbd{f e} (@code{calc-erf}) [@code{erf}] command computes the
|
|
error function
|
|
@texline @math{\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt}.
|
|
@infoline @expr{erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi)}.
|
|
The complementary error function @kbd{I f e} (@code{calc-erfc}) [@code{erfc}]
|
|
is the corresponding integral from @samp{x} to infinity; the sum
|
|
@texline @math{\hbox{erf}(x) + \hbox{erfc}(x) = 1}.
|
|
@infoline @expr{erf(x) + erfc(x) = 1}.
|
|
|
|
@kindex f j
|
|
@kindex f y
|
|
@pindex calc-bessel-J
|
|
@pindex calc-bessel-Y
|
|
@tindex besJ
|
|
@tindex besY
|
|
The @kbd{f j} (@code{calc-bessel-J}) [@code{besJ}] and @kbd{f y}
|
|
(@code{calc-bessel-Y}) [@code{besY}] commands compute the Bessel
|
|
functions of the first and second kinds, respectively.
|
|
In @samp{besJ(n,x)} and @samp{besY(n,x)} the ``order'' parameter
|
|
@expr{n} is often an integer, but is not required to be one.
|
|
Calc's implementation of the Bessel functions currently limits the
|
|
precision to 8 digits, and may not be exact even to that precision.
|
|
Use with care!
|
|
|
|
@node Branch Cuts, Random Numbers, Advanced Math Functions, Scientific Functions
|
|
@section Branch Cuts and Principal Values
|
|
|
|
@noindent
|
|
@cindex Branch cuts
|
|
@cindex Principal values
|
|
All of the logarithmic, trigonometric, and other scientific functions are
|
|
defined for complex numbers as well as for reals.
|
|
This section describes the values
|
|
returned in cases where the general result is a family of possible values.
|
|
Calc follows section 12.5.3 of Steele's @dfn{Common Lisp, the Language},
|
|
second edition, in these matters. This section will describe each
|
|
function briefly; for a more detailed discussion (including some nifty
|
|
diagrams), consult Steele's book.
|
|
|
|
Note that the branch cuts for @code{arctan} and @code{arctanh} were
|
|
changed between the first and second editions of Steele. Versions of
|
|
Calc starting with 2.00 follow the second edition.
|
|
|
|
The new branch cuts exactly match those of the HP-28/48 calculators.
|
|
They also match those of Mathematica 1.2, except that Mathematica's
|
|
@code{arctan} cut is always in the right half of the complex plane,
|
|
and its @code{arctanh} cut is always in the top half of the plane.
|
|
Calc's cuts are continuous with quadrants I and III for @code{arctan},
|
|
or II and IV for @code{arctanh}.
|
|
|
|
Note: The current implementations of these functions with complex arguments
|
|
are designed with proper behavior around the branch cuts in mind, @emph{not}
|
|
efficiency or accuracy. You may need to increase the floating precision
|
|
and wait a while to get suitable answers from them.
|
|
|
|
For @samp{sqrt(a+bi)}: When @expr{a<0} and @expr{b} is small but positive
|
|
or zero, the result is close to the @expr{+i} axis. For @expr{b} small and
|
|
negative, the result is close to the @expr{-i} axis. The result always lies
|
|
in the right half of the complex plane.
|
|
|
|
For @samp{ln(a+bi)}: The real part is defined as @samp{ln(abs(a+bi))}.
|
|
The imaginary part is defined as @samp{arg(a+bi) = arctan2(b,a)}.
|
|
Thus the branch cuts for @code{sqrt} and @code{ln} both lie on the
|
|
negative real axis.
|
|
|
|
The following table describes these branch cuts in another way.
|
|
If the real and imaginary parts of @expr{z} are as shown, then
|
|
the real and imaginary parts of @expr{f(z)} will be as shown.
|
|
Here @code{eps} stands for a small positive value; each
|
|
occurrence of @code{eps} may stand for a different small value.
|
|
|
|
@smallexample
|
|
z sqrt(z) ln(z)
|
|
----------------------------------------
|
|
+, 0 +, 0 any, 0
|
|
-, 0 0, + any, pi
|
|
-, +eps +eps, + +eps, +
|
|
-, -eps +eps, - +eps, -
|
|
@end smallexample
|
|
|
|
For @samp{z1^z2}: This is defined by @samp{exp(ln(z1)*z2)}.
|
|
One interesting consequence of this is that @samp{(-8)^1:3} does
|
|
not evaluate to @mathit{-2} as you might expect, but to the complex
|
|
number @expr{(1., 1.732)}. Both of these are valid cube roots
|
|
of @mathit{-8} (as is @expr{(1., -1.732)}); Calc chooses a perhaps
|
|
less-obvious root for the sake of mathematical consistency.
|
|
|
|
For @samp{arcsin(z)}: This is defined by @samp{-i*ln(i*z + sqrt(1-z^2))}.
|
|
The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
|
|
|
|
For @samp{arccos(z)}: This is defined by @samp{-i*ln(z + i*sqrt(1-z^2))},
|
|
or equivalently by @samp{pi/2 - arcsin(z)}. The branch cuts are on
|
|
the real axis, less than @mathit{-1} and greater than 1.
|
|
|
|
For @samp{arctan(z)}: This is defined by
|
|
@samp{(ln(1+i*z) - ln(1-i*z)) / (2*i)}. The branch cuts are on the
|
|
imaginary axis, below @expr{-i} and above @expr{i}.
|
|
|
|
For @samp{arcsinh(z)}: This is defined by @samp{ln(z + sqrt(1+z^2))}.
|
|
The branch cuts are on the imaginary axis, below @expr{-i} and
|
|
above @expr{i}.
|
|
|
|
For @samp{arccosh(z)}: This is defined by
|
|
@samp{ln(z + (z+1)*sqrt((z-1)/(z+1)))}. The branch cut is on the
|
|
real axis less than 1.
|
|
|
|
For @samp{arctanh(z)}: This is defined by @samp{(ln(1+z) - ln(1-z)) / 2}.
|
|
The branch cuts are on the real axis, less than @mathit{-1} and greater than 1.
|
|
|
|
The following tables for @code{arcsin}, @code{arccos}, and
|
|
@code{arctan} assume the current angular mode is Radians. The
|
|
hyperbolic functions operate independently of the angular mode.
|
|
|
|
@smallexample
|
|
z arcsin(z) arccos(z)
|
|
-------------------------------------------------------
|
|
(-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0
|
|
(-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps
|
|
(-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps
|
|
<-1, 0 -pi/2, + pi, -
|
|
<-1, +eps -pi/2 + eps, + pi - eps, -
|
|
<-1, -eps -pi/2 + eps, - pi - eps, +
|
|
>1, 0 pi/2, - 0, +
|
|
>1, +eps pi/2 - eps, + +eps, -
|
|
>1, -eps pi/2 - eps, - +eps, +
|
|
@end smallexample
|
|
|
|
@smallexample
|
|
z arccosh(z) arctanh(z)
|
|
-----------------------------------------------------
|
|
(-1..1), 0 0, (0..pi) any, 0
|
|
(-1..1), +eps +eps, (0..pi) any, +eps
|
|
(-1..1), -eps +eps, (-pi..0) any, -eps
|
|
<-1, 0 +, pi -, pi/2
|
|
<-1, +eps +, pi - eps -, pi/2 - eps
|
|
<-1, -eps +, -pi + eps -, -pi/2 + eps
|
|
>1, 0 +, 0 +, -pi/2
|
|
>1, +eps +, +eps +, pi/2 - eps
|
|
>1, -eps +, -eps +, -pi/2 + eps
|
|
@end smallexample
|
|
|
|
@smallexample
|
|
z arcsinh(z) arctan(z)
|
|
-----------------------------------------------------
|
|
0, (-1..1) 0, (-pi/2..pi/2) 0, any
|
|
0, <-1 -, -pi/2 -pi/2, -
|
|
+eps, <-1 +, -pi/2 + eps pi/2 - eps, -
|
|
-eps, <-1 -, -pi/2 + eps -pi/2 + eps, -
|
|
0, >1 +, pi/2 pi/2, +
|
|
+eps, >1 +, pi/2 - eps pi/2 - eps, +
|
|
-eps, >1 -, pi/2 - eps -pi/2 + eps, +
|
|
@end smallexample
|
|
|
|
Finally, the following identities help to illustrate the relationship
|
|
between the complex trigonometric and hyperbolic functions. They
|
|
are valid everywhere, including on the branch cuts.
|
|
|
|
@smallexample
|
|
sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z)
|
|
cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z)
|
|
tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z)
|
|
sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)
|
|
@end smallexample
|
|
|
|
The ``advanced math'' functions (gamma, Bessel, etc.@:) are also defined
|
|
for general complex arguments, but their branch cuts and principal values
|
|
are not rigorously specified at present.
|
|
|
|
@node Random Numbers, Combinatorial Functions, Branch Cuts, Scientific Functions
|
|
@section Random Numbers
|
|
|
|
@noindent
|
|
@kindex k r
|
|
@pindex calc-random
|
|
@tindex random
|
|
The @kbd{k r} (@code{calc-random}) [@code{random}] command produces
|
|
random numbers of various sorts.
|
|
|
|
Given a positive numeric prefix argument @expr{M}, it produces a random
|
|
integer @expr{N} in the range
|
|
@texline @math{0 \le N < M}.
|
|
@infoline @expr{0 <= N < M}.
|
|
Each of the @expr{M} values appears with equal probability.
|
|
|
|
With no numeric prefix argument, the @kbd{k r} command takes its argument
|
|
from the stack instead. Once again, if this is a positive integer @expr{M}
|
|
the result is a random integer less than @expr{M}. However, note that
|
|
while numeric prefix arguments are limited to six digits or so, an @expr{M}
|
|
taken from the stack can be arbitrarily large. If @expr{M} is negative,
|
|
the result is a random integer in the range
|
|
@texline @math{M < N \le 0}.
|
|
@infoline @expr{M < N <= 0}.
|
|
|
|
If the value on the stack is a floating-point number @expr{M}, the result
|
|
is a random floating-point number @expr{N} in the range
|
|
@texline @math{0 \le N < M}
|
|
@infoline @expr{0 <= N < M}
|
|
or
|
|
@texline @math{M < N \le 0},
|
|
@infoline @expr{M < N <= 0},
|
|
according to the sign of @expr{M}.
|
|
|
|
If @expr{M} is zero, the result is a Gaussian-distributed random real
|
|
number; the distribution has a mean of zero and a standard deviation
|
|
of one. The algorithm used generates random numbers in pairs; thus,
|
|
every other call to this function will be especially fast.
|
|
|
|
If @expr{M} is an error form
|
|
@texline @math{m} @code{+/-} @math{\sigma}
|
|
@infoline @samp{m +/- s}
|
|
where @var{m} and
|
|
@texline @math{\sigma}
|
|
@infoline @var{s}
|
|
are both real numbers, the result uses a Gaussian distribution with mean
|
|
@var{m} and standard deviation
|
|
@texline @math{\sigma}.
|
|
@infoline @var{s}.
|
|
|
|
If @expr{M} is an interval form, the lower and upper bounds specify the
|
|
acceptable limits of the random numbers. If both bounds are integers,
|
|
the result is a random integer in the specified range. If either bound
|
|
is floating-point, the result is a random real number in the specified
|
|
range. If the interval is open at either end, the result will be sure
|
|
not to equal that end value. (This makes a big difference for integer
|
|
intervals, but for floating-point intervals it's relatively minor:
|
|
with a precision of 6, @samp{random([1.0..2.0))} will return any of one
|
|
million numbers from 1.00000 to 1.99999; @samp{random([1.0..2.0])} may
|
|
additionally return 2.00000, but the probability of this happening is
|
|
extremely small.)
|
|
|
|
If @expr{M} is a vector, the result is one element taken at random from
|
|
the vector. All elements of the vector are given equal probabilities.
|
|
|
|
@vindex RandSeed
|
|
The sequence of numbers produced by @kbd{k r} is completely random by
|
|
default, i.e., the sequence is seeded each time you start Calc using
|
|
the current time and other information. You can get a reproducible
|
|
sequence by storing a particular ``seed value'' in the Calc variable
|
|
@code{RandSeed}. Any integer will do for a seed; integers of from 1
|
|
to 12 digits are good. If you later store a different integer into
|
|
@code{RandSeed}, Calc will switch to a different pseudo-random
|
|
sequence. If you ``unstore'' @code{RandSeed}, Calc will re-seed itself
|
|
from the current time. If you store the same integer that you used
|
|
before back into @code{RandSeed}, you will get the exact same sequence
|
|
of random numbers as before.
|
|
|
|
@pindex calc-rrandom
|
|
The @code{calc-rrandom} command (not on any key) produces a random real
|
|
number between zero and one. It is equivalent to @samp{random(1.0)}.
|
|
|
|
@kindex k a
|
|
@pindex calc-random-again
|
|
The @kbd{k a} (@code{calc-random-again}) command produces another random
|
|
number, re-using the most recent value of @expr{M}. With a numeric
|
|
prefix argument @var{n}, it produces @var{n} more random numbers using
|
|
that value of @expr{M}.
|
|
|
|
@kindex k h
|
|
@pindex calc-shuffle
|
|
@tindex shuffle
|
|
The @kbd{k h} (@code{calc-shuffle}) command produces a vector of several
|
|
random values with no duplicates. The value on the top of the stack
|
|
specifies the set from which the random values are drawn, and may be any
|
|
of the @expr{M} formats described above. The numeric prefix argument
|
|
gives the length of the desired list. (If you do not provide a numeric
|
|
prefix argument, the length of the list is taken from the top of the
|
|
stack, and @expr{M} from second-to-top.)
|
|
|
|
If @expr{M} is a floating-point number, zero, or an error form (so
|
|
that the random values are being drawn from the set of real numbers)
|
|
there is little practical difference between using @kbd{k h} and using
|
|
@kbd{k r} several times. But if the set of possible values consists
|
|
of just a few integers, or the elements of a vector, then there is
|
|
a very real chance that multiple @kbd{k r}'s will produce the same
|
|
number more than once. The @kbd{k h} command produces a vector whose
|
|
elements are always distinct. (Actually, there is a slight exception:
|
|
If @expr{M} is a vector, no given vector element will be drawn more
|
|
than once, but if several elements of @expr{M} are equal, they may
|
|
each make it into the result vector.)
|
|
|
|
One use of @kbd{k h} is to rearrange a list at random. This happens
|
|
if the prefix argument is equal to the number of values in the list:
|
|
@kbd{[1, 1.5, 2, 2.5, 3] 5 k h} might produce the permuted list
|
|
@samp{[2.5, 1, 1.5, 3, 2]}. As a convenient feature, if the argument
|
|
@var{n} is negative it is replaced by the size of the set represented
|
|
by @expr{M}. Naturally, this is allowed only when @expr{M} specifies
|
|
a small discrete set of possibilities.
|
|
|
|
To do the equivalent of @kbd{k h} but with duplications allowed,
|
|
given @expr{M} on the stack and with @var{n} just entered as a numeric
|
|
prefix, use @kbd{v b} to build a vector of copies of @expr{M}, then use
|
|
@kbd{V M k r} to ``map'' the normal @kbd{k r} function over the
|
|
elements of this vector. @xref{Matrix Functions}.
|
|
|
|
@menu
|
|
* Random Number Generator:: (Complete description of Calc's algorithm)
|
|
@end menu
|
|
|
|
@node Random Number Generator, , Random Numbers, Random Numbers
|
|
@subsection Random Number Generator
|
|
|
|
Calc's random number generator uses several methods to ensure that
|
|
the numbers it produces are highly random. Knuth's @emph{Art of
|
|
Computer Programming}, Volume II, contains a thorough description
|
|
of the theory of random number generators and their measurement and
|
|
characterization.
|
|
|
|
If @code{RandSeed} has no stored value, Calc calls Emacs' built-in
|
|
@code{random} function to get a stream of random numbers, which it
|
|
then treats in various ways to avoid problems inherent in the simple
|
|
random number generators that many systems use to implement @code{random}.
|
|
|
|
When Calc's random number generator is first invoked, it ``seeds''
|
|
the low-level random sequence using the time of day, so that the
|
|
random number sequence will be different every time you use Calc.
|
|
|
|
Since Emacs Lisp doesn't specify the range of values that will be
|
|
returned by its @code{random} function, Calc exercises the function
|
|
several times to estimate the range. When Calc subsequently uses
|
|
the @code{random} function, it takes only 10 bits of the result
|
|
near the most-significant end. (It avoids at least the bottom
|
|
four bits, preferably more, and also tries to avoid the top two
|
|
bits.) This strategy works well with the linear congruential
|
|
generators that are typically used to implement @code{random}.
|
|
|
|
If @code{RandSeed} contains an integer, Calc uses this integer to
|
|
seed an ``additive congruential'' method (Knuth's algorithm 3.2.2A,
|
|
computing
|
|
@texline @math{X_{n-55} - X_{n-24}}.
|
|
@infoline @expr{X_n-55 - X_n-24}).
|
|
This method expands the seed
|
|
value into a large table which is maintained internally; the variable
|
|
@code{RandSeed} is changed from, e.g., 42 to the vector @expr{[42]}
|
|
to indicate that the seed has been absorbed into this table. When
|
|
@code{RandSeed} contains a vector, @kbd{k r} and related commands
|
|
continue to use the same internal table as last time. There is no
|
|
way to extract the complete state of the random number generator
|
|
so that you can restart it from any point; you can only restart it
|
|
from the same initial seed value. A simple way to restart from the
|
|
same seed is to type @kbd{s r RandSeed} to get the seed vector,
|
|
@kbd{v u} to unpack it back into a number, then @kbd{s t RandSeed}
|
|
to reseed the generator with that number.
|
|
|
|
Calc uses a ``shuffling'' method as described in algorithm 3.2.2B
|
|
of Knuth. It fills a table with 13 random 10-bit numbers. Then,
|
|
to generate a new random number, it uses the previous number to
|
|
index into the table, picks the value it finds there as the new
|
|
random number, then replaces that table entry with a new value
|
|
obtained from a call to the base random number generator (either
|
|
the additive congruential generator or the @code{random} function
|
|
supplied by the system). If there are any flaws in the base
|
|
generator, shuffling will tend to even them out. But if the system
|
|
provides an excellent @code{random} function, shuffling will not
|
|
damage its randomness.
|
|
|
|
To create a random integer of a certain number of digits, Calc
|
|
builds the integer three decimal digits at a time. For each group
|
|
of three digits, Calc calls its 10-bit shuffling random number generator
|
|
(which returns a value from 0 to 1023); if the random value is 1000
|
|
or more, Calc throws it out and tries again until it gets a suitable
|
|
value.
|
|
|
|
To create a random floating-point number with precision @var{p}, Calc
|
|
simply creates a random @var{p}-digit integer and multiplies by
|
|
@texline @math{10^{-p}}.
|
|
@infoline @expr{10^-p}.
|
|
The resulting random numbers should be very clean, but note
|
|
that relatively small numbers will have few significant random digits.
|
|
In other words, with a precision of 12, you will occasionally get
|
|
numbers on the order of
|
|
@texline @math{10^{-9}}
|
|
@infoline @expr{10^-9}
|
|
or
|
|
@texline @math{10^{-10}},
|
|
@infoline @expr{10^-10},
|
|
but those numbers will only have two or three random digits since they
|
|
correspond to small integers times
|
|
@texline @math{10^{-12}}.
|
|
@infoline @expr{10^-12}.
|
|
|
|
To create a random integer in the interval @samp{[0 .. @var{m})}, Calc
|
|
counts the digits in @var{m}, creates a random integer with three
|
|
additional digits, then reduces modulo @var{m}. Unless @var{m} is a
|
|
power of ten the resulting values will be very slightly biased toward
|
|
the lower numbers, but this bias will be less than 0.1%. (For example,
|
|
if @var{m} is 42, Calc will reduce a random integer less than 100000
|
|
modulo 42 to get a result less than 42. It is easy to show that the
|
|
numbers 40 and 41 will be only 2380/2381 as likely to result from this
|
|
modulo operation as numbers 39 and below.) If @var{m} is a power of
|
|
ten, however, the numbers should be completely unbiased.
|
|
|
|
The Gaussian random numbers generated by @samp{random(0.0)} use the
|
|
``polar'' method described in Knuth section 3.4.1C. This method
|
|
generates a pair of Gaussian random numbers at a time, so only every
|
|
other call to @samp{random(0.0)} will require significant calculations.
|
|
|
|
@node Combinatorial Functions, Probability Distribution Functions, Random Numbers, Scientific Functions
|
|
@section Combinatorial Functions
|
|
|
|
@noindent
|
|
Commands relating to combinatorics and number theory begin with the
|
|
@kbd{k} key prefix.
|
|
|
|
@kindex k g
|
|
@pindex calc-gcd
|
|
@tindex gcd
|
|
The @kbd{k g} (@code{calc-gcd}) [@code{gcd}] command computes the
|
|
Greatest Common Divisor of two integers. It also accepts fractions;
|
|
the GCD of two fractions is defined by taking the GCD of the
|
|
numerators, and the LCM of the denominators. This definition is
|
|
consistent with the idea that @samp{a / gcd(a,x)} should yield an
|
|
integer for any @samp{a} and @samp{x}. For other types of arguments,
|
|
the operation is left in symbolic form.
|
|
|
|
@kindex k l
|
|
@pindex calc-lcm
|
|
@tindex lcm
|
|
The @kbd{k l} (@code{calc-lcm}) [@code{lcm}] command computes the
|
|
Least Common Multiple of two integers or fractions. The product of
|
|
the LCM and GCD of two numbers is equal to the product of the
|
|
numbers.
|
|
|
|
@kindex k E
|
|
@pindex calc-extended-gcd
|
|
@tindex egcd
|
|
The @kbd{k E} (@code{calc-extended-gcd}) [@code{egcd}] command computes
|
|
the GCD of two integers @expr{x} and @expr{y} and returns a vector
|
|
@expr{[g, a, b]} where
|
|
@texline @math{g = \gcd(x,y) = a x + b y}.
|
|
@infoline @expr{g = gcd(x,y) = a x + b y}.
|
|
|
|
@kindex !
|
|
@pindex calc-factorial
|
|
@tindex fact
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex !
|
|
The @kbd{!} (@code{calc-factorial}) [@code{fact}] command computes the
|
|
factorial of the number at the top of the stack. If the number is an
|
|
integer, the result is an exact integer. If the number is an
|
|
integer-valued float, the result is a floating-point approximation. If
|
|
the number is a non-integral real number, the generalized factorial is used,
|
|
as defined by the Euler Gamma function. Please note that computation of
|
|
large factorials can be slow; using floating-point format will help
|
|
since fewer digits must be maintained. The same is true of many of
|
|
the commands in this section.
|
|
|
|
@kindex k d
|
|
@pindex calc-double-factorial
|
|
@tindex dfact
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex !!
|
|
The @kbd{k d} (@code{calc-double-factorial}) [@code{dfact}] command
|
|
computes the ``double factorial'' of an integer. For an even integer,
|
|
this is the product of even integers from 2 to @expr{N}. For an odd
|
|
integer, this is the product of odd integers from 3 to @expr{N}. If
|
|
the argument is an integer-valued float, the result is a floating-point
|
|
approximation. This function is undefined for negative even integers.
|
|
The notation @expr{N!!} is also recognized for double factorials.
|
|
|
|
@kindex k c
|
|
@pindex calc-choose
|
|
@tindex choose
|
|
The @kbd{k c} (@code{calc-choose}) [@code{choose}] command computes the
|
|
binomial coefficient @expr{N}-choose-@expr{M}, where @expr{M} is the number
|
|
on the top of the stack and @expr{N} is second-to-top. If both arguments
|
|
are integers, the result is an exact integer. Otherwise, the result is a
|
|
floating-point approximation. The binomial coefficient is defined for all
|
|
real numbers by
|
|
@texline @math{N! \over M! (N-M)!\,}.
|
|
@infoline @expr{N! / M! (N-M)!}.
|
|
|
|
@kindex H k c
|
|
@pindex calc-perm
|
|
@tindex perm
|
|
@ifinfo
|
|
The @kbd{H k c} (@code{calc-perm}) [@code{perm}] command computes the
|
|
number-of-permutations function @expr{N! / (N-M)!}.
|
|
@end ifinfo
|
|
@tex
|
|
The \kbd{H k c} (\code{calc-perm}) [\code{perm}] command computes the
|
|
number-of-perm\-utations function $N! \over (N-M)!\,$.
|
|
@end tex
|
|
|
|
@kindex k b
|
|
@kindex H k b
|
|
@pindex calc-bernoulli-number
|
|
@tindex bern
|
|
The @kbd{k b} (@code{calc-bernoulli-number}) [@code{bern}] command
|
|
computes a given Bernoulli number. The value at the top of the stack
|
|
is a nonnegative integer @expr{n} that specifies which Bernoulli number
|
|
is desired. The @kbd{H k b} command computes a Bernoulli polynomial,
|
|
taking @expr{n} from the second-to-top position and @expr{x} from the
|
|
top of the stack. If @expr{x} is a variable or formula the result is
|
|
a polynomial in @expr{x}; if @expr{x} is a number the result is a number.
|
|
|
|
@kindex k e
|
|
@kindex H k e
|
|
@pindex calc-euler-number
|
|
@tindex euler
|
|
The @kbd{k e} (@code{calc-euler-number}) [@code{euler}] command similarly
|
|
computes an Euler number, and @w{@kbd{H k e}} computes an Euler polynomial.
|
|
Bernoulli and Euler numbers occur in the Taylor expansions of several
|
|
functions.
|
|
|
|
@kindex k s
|
|
@kindex H k s
|
|
@pindex calc-stirling-number
|
|
@tindex stir1
|
|
@tindex stir2
|
|
The @kbd{k s} (@code{calc-stirling-number}) [@code{stir1}] command
|
|
computes a Stirling number of the first
|
|
@texline kind@tie{}@math{n \brack m},
|
|
@infoline kind,
|
|
given two integers @expr{n} and @expr{m} on the stack. The @kbd{H k s}
|
|
[@code{stir2}] command computes a Stirling number of the second
|
|
@texline kind@tie{}@math{n \brace m}.
|
|
@infoline kind.
|
|
These are the number of @expr{m}-cycle permutations of @expr{n} objects,
|
|
and the number of ways to partition @expr{n} objects into @expr{m}
|
|
non-empty sets, respectively.
|
|
|
|
@kindex k p
|
|
@pindex calc-prime-test
|
|
@cindex Primes
|
|
The @kbd{k p} (@code{calc-prime-test}) command checks if the integer on
|
|
the top of the stack is prime. For integers less than eight million, the
|
|
answer is always exact and reasonably fast. For larger integers, a
|
|
probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
|
|
The number is first checked against small prime factors (up to 13). Then,
|
|
any number of iterations of the algorithm are performed. Each step either
|
|
discovers that the number is non-prime, or substantially increases the
|
|
certainty that the number is prime. After a few steps, the chance that
|
|
a number was mistakenly described as prime will be less than one percent.
|
|
(Indeed, this is a worst-case estimate of the probability; in practice
|
|
even a single iteration is quite reliable.) After the @kbd{k p} command,
|
|
the number will be reported as definitely prime or non-prime if possible,
|
|
or otherwise ``probably'' prime with a certain probability of error.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex prime
|
|
The normal @kbd{k p} command performs one iteration of the primality
|
|
test. Pressing @kbd{k p} repeatedly for the same integer will perform
|
|
additional iterations. Also, @kbd{k p} with a numeric prefix performs
|
|
the specified number of iterations. There is also an algebraic function
|
|
@samp{prime(n)} or @samp{prime(n,iters)} which returns 1 if @expr{n}
|
|
is (probably) prime and 0 if not.
|
|
|
|
@kindex k f
|
|
@pindex calc-prime-factors
|
|
@tindex prfac
|
|
The @kbd{k f} (@code{calc-prime-factors}) [@code{prfac}] command
|
|
attempts to decompose an integer into its prime factors. For numbers up
|
|
to 25 million, the answer is exact although it may take some time. The
|
|
result is a vector of the prime factors in increasing order. For larger
|
|
inputs, prime factors above 5000 may not be found, in which case the
|
|
last number in the vector will be an unfactored integer greater than 25
|
|
million (with a warning message). For negative integers, the first
|
|
element of the list will be @mathit{-1}. For inputs @mathit{-1}, @mathit{0}, and
|
|
@mathit{1}, the result is a list of the same number.
|
|
|
|
@kindex k n
|
|
@pindex calc-next-prime
|
|
@ignore
|
|
@mindex nextpr@idots
|
|
@end ignore
|
|
@tindex nextprime
|
|
The @kbd{k n} (@code{calc-next-prime}) [@code{nextprime}] command finds
|
|
the next prime above a given number. Essentially, it searches by calling
|
|
@code{calc-prime-test} on successive integers until it finds one that
|
|
passes the test. This is quite fast for integers less than eight million,
|
|
but once the probabilistic test comes into play the search may be rather
|
|
slow. Ordinarily this command stops for any prime that passes one iteration
|
|
of the primality test. With a numeric prefix argument, a number must pass
|
|
the specified number of iterations before the search stops. (This only
|
|
matters when searching above eight million.) You can always use additional
|
|
@kbd{k p} commands to increase your certainty that the number is indeed
|
|
prime.
|
|
|
|
@kindex I k n
|
|
@pindex calc-prev-prime
|
|
@ignore
|
|
@mindex prevpr@idots
|
|
@end ignore
|
|
@tindex prevprime
|
|
The @kbd{I k n} (@code{calc-prev-prime}) [@code{prevprime}] command
|
|
analogously finds the next prime less than a given number.
|
|
|
|
@kindex k t
|
|
@pindex calc-totient
|
|
@tindex totient
|
|
The @kbd{k t} (@code{calc-totient}) [@code{totient}] command computes the
|
|
Euler ``totient''
|
|
@texline function@tie{}@math{\phi(n)},
|
|
@infoline function,
|
|
the number of integers less than @expr{n} which
|
|
are relatively prime to @expr{n}.
|
|
|
|
@kindex k m
|
|
@pindex calc-moebius
|
|
@tindex moebius
|
|
The @kbd{k m} (@code{calc-moebius}) [@code{moebius}] command computes the
|
|
@texline M@"obius @math{\mu}
|
|
@infoline Moebius ``mu''
|
|
function. If the input number is a product of @expr{k}
|
|
distinct factors, this is @expr{(-1)^k}. If the input number has any
|
|
duplicate factors (i.e., can be divided by the same prime more than once),
|
|
the result is zero.
|
|
|
|
@node Probability Distribution Functions, , Combinatorial Functions, Scientific Functions
|
|
@section Probability Distribution Functions
|
|
|
|
@noindent
|
|
The functions in this section compute various probability distributions.
|
|
For continuous distributions, this is the integral of the probability
|
|
density function from @expr{x} to infinity. (These are the ``upper
|
|
tail'' distribution functions; there are also corresponding ``lower
|
|
tail'' functions which integrate from minus infinity to @expr{x}.)
|
|
For discrete distributions, the upper tail function gives the sum
|
|
from @expr{x} to infinity; the lower tail function gives the sum
|
|
from minus infinity up to, but not including,@w{ }@expr{x}.
|
|
|
|
To integrate from @expr{x} to @expr{y}, just use the distribution
|
|
function twice and subtract. For example, the probability that a
|
|
Gaussian random variable with mean 2 and standard deviation 1 will
|
|
lie in the range from 2.5 to 2.8 is @samp{utpn(2.5,2,1) - utpn(2.8,2,1)}
|
|
(``the probability that it is greater than 2.5, but not greater than 2.8''),
|
|
or equivalently @samp{ltpn(2.8,2,1) - ltpn(2.5,2,1)}.
|
|
|
|
@kindex k B
|
|
@kindex I k B
|
|
@pindex calc-utpb
|
|
@tindex utpb
|
|
@tindex ltpb
|
|
The @kbd{k B} (@code{calc-utpb}) [@code{utpb}] function uses the
|
|
binomial distribution. Push the parameters @var{n}, @var{p}, and
|
|
then @var{x} onto the stack; the result (@samp{utpb(x,n,p)}) is the
|
|
probability that an event will occur @var{x} or more times out
|
|
of @var{n} trials, if its probability of occurring in any given
|
|
trial is @var{p}. The @kbd{I k B} [@code{ltpb}] function is
|
|
the probability that the event will occur fewer than @var{x} times.
|
|
|
|
The other probability distribution functions similarly take the
|
|
form @kbd{k @var{X}} (@code{calc-utp@var{x}}) [@code{utp@var{x}}]
|
|
and @kbd{I k @var{X}} [@code{ltp@var{x}}], for various letters
|
|
@var{x}. The arguments to the algebraic functions are the value of
|
|
the random variable first, then whatever other parameters define the
|
|
distribution. Note these are among the few Calc functions where the
|
|
order of the arguments in algebraic form differs from the order of
|
|
arguments as found on the stack. (The random variable comes last on
|
|
the stack, so that you can type, e.g., @kbd{2 @key{RET} 1 @key{RET} 2.5
|
|
k N M-@key{RET} @key{DEL} 2.8 k N -}, using @kbd{M-@key{RET} @key{DEL}} to
|
|
recover the original arguments but substitute a new value for @expr{x}.)
|
|
|
|
@kindex k C
|
|
@pindex calc-utpc
|
|
@tindex utpc
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I k C
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ltpc
|
|
The @samp{utpc(x,v)} function uses the chi-square distribution with
|
|
@texline @math{\nu}
|
|
@infoline @expr{v}
|
|
degrees of freedom. It is the probability that a model is
|
|
correct if its chi-square statistic is @expr{x}.
|
|
|
|
@kindex k F
|
|
@pindex calc-utpf
|
|
@tindex utpf
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I k F
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ltpf
|
|
The @samp{utpf(F,v1,v2)} function uses the F distribution, used in
|
|
various statistical tests. The parameters
|
|
@texline @math{\nu_1}
|
|
@infoline @expr{v1}
|
|
and
|
|
@texline @math{\nu_2}
|
|
@infoline @expr{v2}
|
|
are the degrees of freedom in the numerator and denominator,
|
|
respectively, used in computing the statistic @expr{F}.
|
|
|
|
@kindex k N
|
|
@pindex calc-utpn
|
|
@tindex utpn
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I k N
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ltpn
|
|
The @samp{utpn(x,m,s)} function uses a normal (Gaussian) distribution
|
|
with mean @expr{m} and standard deviation
|
|
@texline @math{\sigma}.
|
|
@infoline @expr{s}.
|
|
It is the probability that such a normal-distributed random variable
|
|
would exceed @expr{x}.
|
|
|
|
@kindex k P
|
|
@pindex calc-utpp
|
|
@tindex utpp
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I k P
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ltpp
|
|
The @samp{utpp(n,x)} function uses a Poisson distribution with
|
|
mean @expr{x}. It is the probability that @expr{n} or more such
|
|
Poisson random events will occur.
|
|
|
|
@kindex k T
|
|
@pindex calc-ltpt
|
|
@tindex utpt
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex I k T
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex ltpt
|
|
The @samp{utpt(t,v)} function uses the Student's ``t'' distribution
|
|
with
|
|
@texline @math{\nu}
|
|
@infoline @expr{v}
|
|
degrees of freedom. It is the probability that a
|
|
t-distributed random variable will be greater than @expr{t}.
|
|
(Note: This computes the distribution function
|
|
@texline @math{A(t|\nu)}
|
|
@infoline @expr{A(t|v)}
|
|
where
|
|
@texline @math{A(0|\nu) = 1}
|
|
@infoline @expr{A(0|v) = 1}
|
|
and
|
|
@texline @math{A(\infty|\nu) \to 0}.
|
|
@infoline @expr{A(inf|v) -> 0}.
|
|
The @code{UTPT} operation on the HP-48 uses a different definition which
|
|
returns half of Calc's value: @samp{UTPT(t,v) = .5*utpt(t,v)}.)
|
|
|
|
While Calc does not provide inverses of the probability distribution
|
|
functions, the @kbd{a R} command can be used to solve for the inverse.
|
|
Since the distribution functions are monotonic, @kbd{a R} is guaranteed
|
|
to be able to find a solution given any initial guess.
|
|
@xref{Numerical Solutions}.
|
|
|
|
@node Matrix Functions, Algebra, Scientific Functions, Top
|
|
@chapter Vector/Matrix Functions
|
|
|
|
@noindent
|
|
Many of the commands described here begin with the @kbd{v} prefix.
|
|
(For convenience, the shift-@kbd{V} prefix is equivalent to @kbd{v}.)
|
|
The commands usually apply to both plain vectors and matrices; some
|
|
apply only to matrices or only to square matrices. If the argument
|
|
has the wrong dimensions the operation is left in symbolic form.
|
|
|
|
Vectors are entered and displayed using @samp{[a,b,c]} notation.
|
|
Matrices are vectors of which all elements are vectors of equal length.
|
|
(Though none of the standard Calc commands use this concept, a
|
|
three-dimensional matrix or rank-3 tensor could be defined as a
|
|
vector of matrices, and so on.)
|
|
|
|
@menu
|
|
* Packing and Unpacking::
|
|
* Building Vectors::
|
|
* Extracting Elements::
|
|
* Manipulating Vectors::
|
|
* Vector and Matrix Arithmetic::
|
|
* Set Operations::
|
|
* Statistical Operations::
|
|
* Reducing and Mapping::
|
|
* Vector and Matrix Formats::
|
|
@end menu
|
|
|
|
@node Packing and Unpacking, Building Vectors, Matrix Functions, Matrix Functions
|
|
@section Packing and Unpacking
|
|
|
|
@noindent
|
|
Calc's ``pack'' and ``unpack'' commands collect stack entries to build
|
|
composite objects such as vectors and complex numbers. They are
|
|
described in this chapter because they are most often used to build
|
|
vectors.
|
|
|
|
@kindex v p
|
|
@pindex calc-pack
|
|
The @kbd{v p} (@code{calc-pack}) [@code{pack}] command collects several
|
|
elements from the stack into a matrix, complex number, HMS form, error
|
|
form, etc. It uses a numeric prefix argument to specify the kind of
|
|
object to be built; this argument is referred to as the ``packing mode.''
|
|
If the packing mode is a nonnegative integer, a vector of that
|
|
length is created. For example, @kbd{C-u 5 v p} will pop the top
|
|
five stack elements and push back a single vector of those five
|
|
elements. (@kbd{C-u 0 v p} simply creates an empty vector.)
|
|
|
|
The same effect can be had by pressing @kbd{[} to push an incomplete
|
|
vector on the stack, using @key{TAB} (@code{calc-roll-down}) to sneak
|
|
the incomplete object up past a certain number of elements, and
|
|
then pressing @kbd{]} to complete the vector.
|
|
|
|
Negative packing modes create other kinds of composite objects:
|
|
|
|
@table @cite
|
|
@item -1
|
|
Two values are collected to build a complex number. For example,
|
|
@kbd{5 @key{RET} 7 C-u -1 v p} creates the complex number
|
|
@expr{(5, 7)}. The result is always a rectangular complex
|
|
number. The two input values must both be real numbers,
|
|
i.e., integers, fractions, or floats. If they are not, Calc
|
|
will instead build a formula like @samp{a + (0, 1) b}. (The
|
|
other packing modes also create a symbolic answer if the
|
|
components are not suitable.)
|
|
|
|
@item -2
|
|
Two values are collected to build a polar complex number.
|
|
The first is the magnitude; the second is the phase expressed
|
|
in either degrees or radians according to the current angular
|
|
mode.
|
|
|
|
@item -3
|
|
Three values are collected into an HMS form. The first
|
|
two values (hours and minutes) must be integers or
|
|
integer-valued floats. The third value may be any real
|
|
number.
|
|
|
|
@item -4
|
|
Two values are collected into an error form. The inputs
|
|
may be real numbers or formulas.
|
|
|
|
@item -5
|
|
Two values are collected into a modulo form. The inputs
|
|
must be real numbers.
|
|
|
|
@item -6
|
|
Two values are collected into the interval @samp{[a .. b]}.
|
|
The inputs may be real numbers, HMS or date forms, or formulas.
|
|
|
|
@item -7
|
|
Two values are collected into the interval @samp{[a .. b)}.
|
|
|
|
@item -8
|
|
Two values are collected into the interval @samp{(a .. b]}.
|
|
|
|
@item -9
|
|
Two values are collected into the interval @samp{(a .. b)}.
|
|
|
|
@item -10
|
|
Two integer values are collected into a fraction.
|
|
|
|
@item -11
|
|
Two values are collected into a floating-point number.
|
|
The first is the mantissa; the second, which must be an
|
|
integer, is the exponent. The result is the mantissa
|
|
times ten to the power of the exponent.
|
|
|
|
@item -12
|
|
This is treated the same as @mathit{-11} by the @kbd{v p} command.
|
|
When unpacking, @mathit{-12} specifies that a floating-point mantissa
|
|
is desired.
|
|
|
|
@item -13
|
|
A real number is converted into a date form.
|
|
|
|
@item -14
|
|
Three numbers (year, month, day) are packed into a pure date form.
|
|
|
|
@item -15
|
|
Six numbers are packed into a date/time form.
|
|
@end table
|
|
|
|
With any of the two-input negative packing modes, either or both
|
|
of the inputs may be vectors. If both are vectors of the same
|
|
length, the result is another vector made by packing corresponding
|
|
elements of the input vectors. If one input is a vector and the
|
|
other is a plain number, the number is packed along with each vector
|
|
element to produce a new vector. For example, @kbd{C-u -4 v p}
|
|
could be used to convert a vector of numbers and a vector of errors
|
|
into a single vector of error forms; @kbd{C-u -5 v p} could convert
|
|
a vector of numbers and a single number @var{M} into a vector of
|
|
numbers modulo @var{M}.
|
|
|
|
If you don't give a prefix argument to @kbd{v p}, it takes
|
|
the packing mode from the top of the stack. The elements to
|
|
be packed then begin at stack level 2. Thus
|
|
@kbd{1 @key{RET} 2 @key{RET} 4 n v p} is another way to
|
|
enter the error form @samp{1 +/- 2}.
|
|
|
|
If the packing mode taken from the stack is a vector, the result is a
|
|
matrix with the dimensions specified by the elements of the vector,
|
|
which must each be integers. For example, if the packing mode is
|
|
@samp{[2, 3]}, then six numbers will be taken from the stack and
|
|
returned in the form @samp{[@w{[a, b, c]}, [d, e, f]]}.
|
|
|
|
If any elements of the vector are negative, other kinds of
|
|
packing are done at that level as described above. For
|
|
example, @samp{[2, 3, -4]} takes 12 objects and creates a
|
|
@texline @math{2\times3}
|
|
@infoline 2x3
|
|
matrix of error forms: @samp{[[a +/- b, c +/- d ... ]]}.
|
|
Also, @samp{[-4, -10]} will convert four integers into an
|
|
error form consisting of two fractions: @samp{a:b +/- c:d}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pack
|
|
There is an equivalent algebraic function,
|
|
@samp{pack(@var{mode}, @var{items})} where @var{mode} is a
|
|
packing mode (an integer or a vector of integers) and @var{items}
|
|
is a vector of objects to be packed (re-packed, really) according
|
|
to that mode. For example, @samp{pack([3, -4], [a,b,c,d,e,f])}
|
|
yields @samp{[a +/- b, @w{c +/- d}, e +/- f]}. The function is
|
|
left in symbolic form if the packing mode is invalid, or if the
|
|
number of data items does not match the number of items required
|
|
by the mode.
|
|
|
|
@kindex v u
|
|
@pindex calc-unpack
|
|
The @kbd{v u} (@code{calc-unpack}) command takes the vector, complex
|
|
number, HMS form, or other composite object on the top of the stack and
|
|
``unpacks'' it, pushing each of its elements onto the stack as separate
|
|
objects. Thus, it is the ``inverse'' of @kbd{v p}. If the value
|
|
at the top of the stack is a formula, @kbd{v u} unpacks it by pushing
|
|
each of the arguments of the top-level operator onto the stack.
|
|
|
|
You can optionally give a numeric prefix argument to @kbd{v u}
|
|
to specify an explicit (un)packing mode. If the packing mode is
|
|
negative and the input is actually a vector or matrix, the result
|
|
will be two or more similar vectors or matrices of the elements.
|
|
For example, given the vector @samp{[@w{a +/- b}, c^2, d +/- 7]},
|
|
the result of @kbd{C-u -4 v u} will be the two vectors
|
|
@samp{[a, c^2, d]} and @w{@samp{[b, 0, 7]}}.
|
|
|
|
Note that the prefix argument can have an effect even when the input is
|
|
not a vector. For example, if the input is the number @mathit{-5}, then
|
|
@kbd{c-u -1 v u} yields @mathit{-5} and 0 (the components of @mathit{-5}
|
|
when viewed as a rectangular complex number); @kbd{C-u -2 v u} yields 5
|
|
and 180 (assuming Degrees mode); and @kbd{C-u -10 v u} yields @mathit{-5}
|
|
and 1 (the numerator and denominator of @mathit{-5}, viewed as a rational
|
|
number). Plain @kbd{v u} with this input would complain that the input
|
|
is not a composite object.
|
|
|
|
Unpacking mode @mathit{-11} converts a float into an integer mantissa and
|
|
an integer exponent, where the mantissa is not divisible by 10
|
|
(except that 0.0 is represented by a mantissa and exponent of 0).
|
|
Unpacking mode @mathit{-12} converts a float into a floating-point mantissa
|
|
and integer exponent, where the mantissa (for non-zero numbers)
|
|
is guaranteed to lie in the range [1 .. 10). In both cases,
|
|
the mantissa is shifted left or right (and the exponent adjusted
|
|
to compensate) in order to satisfy these constraints.
|
|
|
|
Positive unpacking modes are treated differently than for @kbd{v p}.
|
|
A mode of 1 is much like plain @kbd{v u} with no prefix argument,
|
|
except that in addition to the components of the input object,
|
|
a suitable packing mode to re-pack the object is also pushed.
|
|
Thus, @kbd{C-u 1 v u} followed by @kbd{v p} will re-build the
|
|
original object.
|
|
|
|
A mode of 2 unpacks two levels of the object; the resulting
|
|
re-packing mode will be a vector of length 2. This might be used
|
|
to unpack a matrix, say, or a vector of error forms. Higher
|
|
unpacking modes unpack the input even more deeply.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex unpack
|
|
There are two algebraic functions analogous to @kbd{v u}.
|
|
The @samp{unpack(@var{mode}, @var{item})} function unpacks the
|
|
@var{item} using the given @var{mode}, returning the result as
|
|
a vector of components. Here the @var{mode} must be an
|
|
integer, not a vector. For example, @samp{unpack(-4, a +/- b)}
|
|
returns @samp{[a, b]}, as does @samp{unpack(1, a +/- b)}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex unpackt
|
|
The @code{unpackt} function is like @code{unpack} but instead
|
|
of returning a simple vector of items, it returns a vector of
|
|
two things: The mode, and the vector of items. For example,
|
|
@samp{unpackt(1, 2:3 +/- 1:4)} returns @samp{[-4, [2:3, 1:4]]},
|
|
and @samp{unpackt(2, 2:3 +/- 1:4)} returns @samp{[[-4, -10], [2, 3, 1, 4]]}.
|
|
The identity for re-building the original object is
|
|
@samp{apply(pack, unpackt(@var{n}, @var{x})) = @var{x}}. (The
|
|
@code{apply} function builds a function call given the function
|
|
name and a vector of arguments.)
|
|
|
|
@cindex Numerator of a fraction, extracting
|
|
Subscript notation is a useful way to extract a particular part
|
|
of an object. For example, to get the numerator of a rational
|
|
number, you can use @samp{unpack(-10, @var{x})_1}.
|
|
|
|
@node Building Vectors, Extracting Elements, Packing and Unpacking, Matrix Functions
|
|
@section Building Vectors
|
|
|
|
@noindent
|
|
Vectors and matrices can be added,
|
|
subtracted, multiplied, and divided; @pxref{Basic Arithmetic}.
|
|
|
|
@kindex |
|
|
@pindex calc-concat
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex |
|
|
The @kbd{|} (@code{calc-concat}) [@code{vconcat}] command ``concatenates'' two vectors
|
|
into one. For example, after @kbd{@w{[ 1 , 2 ]} [ 3 , 4 ] |}, the stack
|
|
will contain the single vector @samp{[1, 2, 3, 4]}. If the arguments
|
|
are matrices, the rows of the first matrix are concatenated with the
|
|
rows of the second. (In other words, two matrices are just two vectors
|
|
of row-vectors as far as @kbd{|} is concerned.)
|
|
|
|
If either argument to @kbd{|} is a scalar (a non-vector), it is treated
|
|
like a one-element vector for purposes of concatenation: @kbd{1 [ 2 , 3 ] |}
|
|
produces the vector @samp{[1, 2, 3]}. Likewise, if one argument is a
|
|
matrix and the other is a plain vector, the vector is treated as a
|
|
one-row matrix.
|
|
|
|
@kindex H |
|
|
@tindex append
|
|
The @kbd{H |} (@code{calc-append}) [@code{append}] command concatenates
|
|
two vectors without any special cases. Both inputs must be vectors.
|
|
Whether or not they are matrices is not taken into account. If either
|
|
argument is a scalar, the @code{append} function is left in symbolic form.
|
|
See also @code{cons} and @code{rcons} below.
|
|
|
|
@kindex I |
|
|
@kindex H I |
|
|
The @kbd{I |} and @kbd{H I |} commands are similar, but they use their
|
|
two stack arguments in the opposite order. Thus @kbd{I |} is equivalent
|
|
to @kbd{@key{TAB} |}, but possibly more convenient and also a bit faster.
|
|
|
|
@kindex v d
|
|
@pindex calc-diag
|
|
@tindex diag
|
|
The @kbd{v d} (@code{calc-diag}) [@code{diag}] function builds a diagonal
|
|
square matrix. The optional numeric prefix gives the number of rows
|
|
and columns in the matrix. If the value at the top of the stack is a
|
|
vector, the elements of the vector are used as the diagonal elements; the
|
|
prefix, if specified, must match the size of the vector. If the value on
|
|
the stack is a scalar, it is used for each element on the diagonal, and
|
|
the prefix argument is required.
|
|
|
|
To build a constant square matrix, e.g., a
|
|
@texline @math{3\times3}
|
|
@infoline 3x3
|
|
matrix filled with ones, use @kbd{0 M-3 v d 1 +}, i.e., build a zero
|
|
matrix first and then add a constant value to that matrix. (Another
|
|
alternative would be to use @kbd{v b} and @kbd{v a}; see below.)
|
|
|
|
@kindex v i
|
|
@pindex calc-ident
|
|
@tindex idn
|
|
The @kbd{v i} (@code{calc-ident}) [@code{idn}] function builds an identity
|
|
matrix of the specified size. It is a convenient form of @kbd{v d}
|
|
where the diagonal element is always one. If no prefix argument is given,
|
|
this command prompts for one.
|
|
|
|
In algebraic notation, @samp{idn(a,n)} acts much like @samp{diag(a,n)},
|
|
except that @expr{a} is required to be a scalar (non-vector) quantity.
|
|
If @expr{n} is omitted, @samp{idn(a)} represents @expr{a} times an
|
|
identity matrix of unknown size. Calc can operate algebraically on
|
|
such generic identity matrices, and if one is combined with a matrix
|
|
whose size is known, it is converted automatically to an identity
|
|
matrix of a suitable matching size. The @kbd{v i} command with an
|
|
argument of zero creates a generic identity matrix, @samp{idn(1)}.
|
|
Note that in dimensioned Matrix mode (@pxref{Matrix Mode}), generic
|
|
identity matrices are immediately expanded to the current default
|
|
dimensions.
|
|
|
|
@kindex v x
|
|
@pindex calc-index
|
|
@tindex index
|
|
The @kbd{v x} (@code{calc-index}) [@code{index}] function builds a vector
|
|
of consecutive integers from 1 to @var{n}, where @var{n} is the numeric
|
|
prefix argument. If you do not provide a prefix argument, you will be
|
|
prompted to enter a suitable number. If @var{n} is negative, the result
|
|
is a vector of negative integers from @var{n} to @mathit{-1}.
|
|
|
|
With a prefix argument of just @kbd{C-u}, the @kbd{v x} command takes
|
|
three values from the stack: @var{n}, @var{start}, and @var{incr} (with
|
|
@var{incr} at top-of-stack). Counting starts at @var{start} and increases
|
|
by @var{incr} for successive vector elements. If @var{start} or @var{n}
|
|
is in floating-point format, the resulting vector elements will also be
|
|
floats. Note that @var{start} and @var{incr} may in fact be any kind
|
|
of numbers or formulas.
|
|
|
|
When @var{start} and @var{incr} are specified, a negative @var{n} has a
|
|
different interpretation: It causes a geometric instead of arithmetic
|
|
sequence to be generated. For example, @samp{index(-3, a, b)} produces
|
|
@samp{[a, a b, a b^2]}. If you omit @var{incr} in the algebraic form,
|
|
@samp{index(@var{n}, @var{start})}, the default value for @var{incr}
|
|
is one for positive @var{n} or two for negative @var{n}.
|
|
|
|
@kindex v b
|
|
@pindex calc-build-vector
|
|
@tindex cvec
|
|
The @kbd{v b} (@code{calc-build-vector}) [@code{cvec}] function builds a
|
|
vector of @var{n} copies of the value on the top of the stack, where @var{n}
|
|
is the numeric prefix argument. In algebraic formulas, @samp{cvec(x,n,m)}
|
|
can also be used to build an @var{n}-by-@var{m} matrix of copies of @var{x}.
|
|
(Interactively, just use @kbd{v b} twice: once to build a row, then again
|
|
to build a matrix of copies of that row.)
|
|
|
|
@kindex v h
|
|
@kindex I v h
|
|
@pindex calc-head
|
|
@pindex calc-tail
|
|
@tindex head
|
|
@tindex tail
|
|
The @kbd{v h} (@code{calc-head}) [@code{head}] function returns the first
|
|
element of a vector. The @kbd{I v h} (@code{calc-tail}) [@code{tail}]
|
|
function returns the vector with its first element removed. In both
|
|
cases, the argument must be a non-empty vector.
|
|
|
|
@kindex v k
|
|
@pindex calc-cons
|
|
@tindex cons
|
|
The @kbd{v k} (@code{calc-cons}) [@code{cons}] function takes a value @var{h}
|
|
and a vector @var{t} from the stack, and produces the vector whose head is
|
|
@var{h} and whose tail is @var{t}. This is similar to @kbd{|}, except
|
|
if @var{h} is itself a vector, @kbd{|} will concatenate the two vectors
|
|
whereas @code{cons} will insert @var{h} at the front of the vector @var{t}.
|
|
|
|
@kindex H v h
|
|
@tindex rhead
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex H I v h
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex H v k
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex rtail
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex rcons
|
|
Each of these three functions also accepts the Hyperbolic flag [@code{rhead},
|
|
@code{rtail}, @code{rcons}] in which case @var{t} instead represents
|
|
the @emph{last} single element of the vector, with @var{h}
|
|
representing the remainder of the vector. Thus the vector
|
|
@samp{[a, b, c, d] = cons(a, [b, c, d]) = rcons([a, b, c], d)}.
|
|
Also, @samp{head([a, b, c, d]) = a}, @samp{tail([a, b, c, d]) = [b, c, d]},
|
|
@samp{rhead([a, b, c, d]) = [a, b, c]}, and @samp{rtail([a, b, c, d]) = d}.
|
|
|
|
@node Extracting Elements, Manipulating Vectors, Building Vectors, Matrix Functions
|
|
@section Extracting Vector Elements
|
|
|
|
@noindent
|
|
@kindex v r
|
|
@pindex calc-mrow
|
|
@tindex mrow
|
|
The @kbd{v r} (@code{calc-mrow}) [@code{mrow}] command extracts one row of
|
|
the matrix on the top of the stack, or one element of the plain vector on
|
|
the top of the stack. The row or element is specified by the numeric
|
|
prefix argument; the default is to prompt for the row or element number.
|
|
The matrix or vector is replaced by the specified row or element in the
|
|
form of a vector or scalar, respectively.
|
|
|
|
@cindex Permutations, applying
|
|
With a prefix argument of @kbd{C-u} only, @kbd{v r} takes the index of
|
|
the element or row from the top of the stack, and the vector or matrix
|
|
from the second-to-top position. If the index is itself a vector of
|
|
integers, the result is a vector of the corresponding elements of the
|
|
input vector, or a matrix of the corresponding rows of the input matrix.
|
|
This command can be used to obtain any permutation of a vector.
|
|
|
|
With @kbd{C-u}, if the index is an interval form with integer components,
|
|
it is interpreted as a range of indices and the corresponding subvector or
|
|
submatrix is returned.
|
|
|
|
@cindex Subscript notation
|
|
@kindex a _
|
|
@pindex calc-subscript
|
|
@tindex subscr
|
|
@tindex _
|
|
Subscript notation in algebraic formulas (@samp{a_b}) stands for the
|
|
Calc function @code{subscr}, which is synonymous with @code{mrow}.
|
|
Thus, @samp{[x, y, z]_k} produces @expr{x}, @expr{y}, or @expr{z} if
|
|
@expr{k} is one, two, or three, respectively. A double subscript
|
|
(@samp{M_i_j}, equivalent to @samp{subscr(subscr(M, i), j)}) will
|
|
access the element at row @expr{i}, column @expr{j} of a matrix.
|
|
The @kbd{a _} (@code{calc-subscript}) command creates a subscript
|
|
formula @samp{a_b} out of two stack entries. (It is on the @kbd{a}
|
|
``algebra'' prefix because subscripted variables are often used
|
|
purely as an algebraic notation.)
|
|
|
|
@tindex mrrow
|
|
Given a negative prefix argument, @kbd{v r} instead deletes one row or
|
|
element from the matrix or vector on the top of the stack. Thus
|
|
@kbd{C-u 2 v r} replaces a matrix with its second row, but @kbd{C-u -2 v r}
|
|
replaces the matrix with the same matrix with its second row removed.
|
|
In algebraic form this function is called @code{mrrow}.
|
|
|
|
@tindex getdiag
|
|
Given a prefix argument of zero, @kbd{v r} extracts the diagonal elements
|
|
of a square matrix in the form of a vector. In algebraic form this
|
|
function is called @code{getdiag}.
|
|
|
|
@kindex v c
|
|
@pindex calc-mcol
|
|
@tindex mcol
|
|
@tindex mrcol
|
|
The @kbd{v c} (@code{calc-mcol}) [@code{mcol} or @code{mrcol}] command is
|
|
the analogous operation on columns of a matrix. Given a plain vector
|
|
it extracts (or removes) one element, just like @kbd{v r}. If the
|
|
index in @kbd{C-u v c} is an interval or vector and the argument is a
|
|
matrix, the result is a submatrix with only the specified columns
|
|
retained (and possibly permuted in the case of a vector index).
|
|
|
|
To extract a matrix element at a given row and column, use @kbd{v r} to
|
|
extract the row as a vector, then @kbd{v c} to extract the column element
|
|
from that vector. In algebraic formulas, it is often more convenient to
|
|
use subscript notation: @samp{m_i_j} gives row @expr{i}, column @expr{j}
|
|
of matrix @expr{m}.
|
|
|
|
@kindex v s
|
|
@pindex calc-subvector
|
|
@tindex subvec
|
|
The @kbd{v s} (@code{calc-subvector}) [@code{subvec}] command extracts
|
|
a subvector of a vector. The arguments are the vector, the starting
|
|
index, and the ending index, with the ending index in the top-of-stack
|
|
position. The starting index indicates the first element of the vector
|
|
to take. The ending index indicates the first element @emph{past} the
|
|
range to be taken. Thus, @samp{subvec([a, b, c, d, e], 2, 4)} produces
|
|
the subvector @samp{[b, c]}. You could get the same result using
|
|
@samp{mrow([a, b, c, d, e], @w{[2 .. 4)})}.
|
|
|
|
If either the start or the end index is zero or negative, it is
|
|
interpreted as relative to the end of the vector. Thus
|
|
@samp{subvec([a, b, c, d, e], 2, -2)} also produces @samp{[b, c]}. In
|
|
the algebraic form, the end index can be omitted in which case it
|
|
is taken as zero, i.e., elements from the starting element to the
|
|
end of the vector are used. The infinity symbol, @code{inf}, also
|
|
has this effect when used as the ending index.
|
|
|
|
@kindex I v s
|
|
@tindex rsubvec
|
|
With the Inverse flag, @kbd{I v s} [@code{rsubvec}] removes a subvector
|
|
from a vector. The arguments are interpreted the same as for the
|
|
normal @kbd{v s} command. Thus, @samp{rsubvec([a, b, c, d, e], 2, 4)}
|
|
produces @samp{[a, d, e]}. It is always true that @code{subvec} and
|
|
@code{rsubvec} return complementary parts of the input vector.
|
|
|
|
@xref{Selecting Subformulas}, for an alternative way to operate on
|
|
vectors one element at a time.
|
|
|
|
@node Manipulating Vectors, Vector and Matrix Arithmetic, Extracting Elements, Matrix Functions
|
|
@section Manipulating Vectors
|
|
|
|
@noindent
|
|
@kindex v l
|
|
@pindex calc-vlength
|
|
@tindex vlen
|
|
The @kbd{v l} (@code{calc-vlength}) [@code{vlen}] command computes the
|
|
length of a vector. The length of a non-vector is considered to be zero.
|
|
Note that matrices are just vectors of vectors for the purposes of this
|
|
command.
|
|
|
|
@kindex H v l
|
|
@tindex mdims
|
|
With the Hyperbolic flag, @kbd{H v l} [@code{mdims}] computes a vector
|
|
of the dimensions of a vector, matrix, or higher-order object. For
|
|
example, @samp{mdims([[a,b,c],[d,e,f]])} returns @samp{[2, 3]} since
|
|
its argument is a
|
|
@texline @math{2\times3}
|
|
@infoline 2x3
|
|
matrix.
|
|
|
|
@kindex v f
|
|
@pindex calc-vector-find
|
|
@tindex find
|
|
The @kbd{v f} (@code{calc-vector-find}) [@code{find}] command searches
|
|
along a vector for the first element equal to a given target. The target
|
|
is on the top of the stack; the vector is in the second-to-top position.
|
|
If a match is found, the result is the index of the matching element.
|
|
Otherwise, the result is zero. The numeric prefix argument, if given,
|
|
allows you to select any starting index for the search.
|
|
|
|
@kindex v a
|
|
@pindex calc-arrange-vector
|
|
@tindex arrange
|
|
@cindex Arranging a matrix
|
|
@cindex Reshaping a matrix
|
|
@cindex Flattening a matrix
|
|
The @kbd{v a} (@code{calc-arrange-vector}) [@code{arrange}] command
|
|
rearranges a vector to have a certain number of columns and rows. The
|
|
numeric prefix argument specifies the number of columns; if you do not
|
|
provide an argument, you will be prompted for the number of columns.
|
|
The vector or matrix on the top of the stack is @dfn{flattened} into a
|
|
plain vector. If the number of columns is nonzero, this vector is
|
|
then formed into a matrix by taking successive groups of @var{n} elements.
|
|
If the number of columns does not evenly divide the number of elements
|
|
in the vector, the last row will be short and the result will not be
|
|
suitable for use as a matrix. For example, with the matrix
|
|
@samp{[[1, 2], @w{[3, 4]}]} on the stack, @kbd{v a 4} produces
|
|
@samp{[[1, 2, 3, 4]]} (a
|
|
@texline @math{1\times4}
|
|
@infoline 1x4
|
|
matrix), @kbd{v a 1} produces @samp{[[1], [2], [3], [4]]} (a
|
|
@texline @math{4\times1}
|
|
@infoline 4x1
|
|
matrix), @kbd{v a 2} produces @samp{[[1, 2], [3, 4]]} (the original
|
|
@texline @math{2\times2}
|
|
@infoline 2x2
|
|
matrix), @w{@kbd{v a 3}} produces @samp{[[1, 2, 3], [4]]} (not a
|
|
matrix), and @kbd{v a 0} produces the flattened list
|
|
@samp{[1, 2, @w{3, 4}]}.
|
|
|
|
@cindex Sorting data
|
|
@kindex V S
|
|
@kindex I V S
|
|
@pindex calc-sort
|
|
@tindex sort
|
|
@tindex rsort
|
|
The @kbd{V S} (@code{calc-sort}) [@code{sort}] command sorts the elements of
|
|
a vector into increasing order. Real numbers, real infinities, and
|
|
constant interval forms come first in this ordering; next come other
|
|
kinds of numbers, then variables (in alphabetical order), then finally
|
|
come formulas and other kinds of objects; these are sorted according
|
|
to a kind of lexicographic ordering with the useful property that
|
|
one vector is less or greater than another if the first corresponding
|
|
unequal elements are less or greater, respectively. Since quoted strings
|
|
are stored by Calc internally as vectors of ASCII character codes
|
|
(@pxref{Strings}), this means vectors of strings are also sorted into
|
|
alphabetical order by this command.
|
|
|
|
The @kbd{I V S} [@code{rsort}] command sorts a vector into decreasing order.
|
|
|
|
@cindex Permutation, inverse of
|
|
@cindex Inverse of permutation
|
|
@cindex Index tables
|
|
@cindex Rank tables
|
|
@kindex V G
|
|
@kindex I V G
|
|
@pindex calc-grade
|
|
@tindex grade
|
|
@tindex rgrade
|
|
The @kbd{V G} (@code{calc-grade}) [@code{grade}, @code{rgrade}] command
|
|
produces an index table or permutation vector which, if applied to the
|
|
input vector (as the index of @kbd{C-u v r}, say), would sort the vector.
|
|
A permutation vector is just a vector of integers from 1 to @var{n}, where
|
|
each integer occurs exactly once. One application of this is to sort a
|
|
matrix of data rows using one column as the sort key; extract that column,
|
|
grade it with @kbd{V G}, then use the result to reorder the original matrix
|
|
with @kbd{C-u v r}. Another interesting property of the @code{V G} command
|
|
is that, if the input is itself a permutation vector, the result will
|
|
be the inverse of the permutation. The inverse of an index table is
|
|
a rank table, whose @var{k}th element says where the @var{k}th original
|
|
vector element will rest when the vector is sorted. To get a rank
|
|
table, just use @kbd{V G V G}.
|
|
|
|
With the Inverse flag, @kbd{I V G} produces an index table that would
|
|
sort the input into decreasing order. Note that @kbd{V S} and @kbd{V G}
|
|
use a ``stable'' sorting algorithm, i.e., any two elements which are equal
|
|
will not be moved out of their original order. Generally there is no way
|
|
to tell with @kbd{V S}, since two elements which are equal look the same,
|
|
but with @kbd{V G} this can be an important issue. In the matrix-of-rows
|
|
example, suppose you have names and telephone numbers as two columns and
|
|
you wish to sort by phone number primarily, and by name when the numbers
|
|
are equal. You can sort the data matrix by names first, and then again
|
|
by phone numbers. Because the sort is stable, any two rows with equal
|
|
phone numbers will remain sorted by name even after the second sort.
|
|
|
|
@cindex Histograms
|
|
@kindex V H
|
|
@pindex calc-histogram
|
|
@ignore
|
|
@mindex histo@idots
|
|
@end ignore
|
|
@tindex histogram
|
|
The @kbd{V H} (@code{calc-histogram}) [@code{histogram}] command builds a
|
|
histogram of a vector of numbers. Vector elements are assumed to be
|
|
integers or real numbers in the range [0..@var{n}) for some ``number of
|
|
bins'' @var{n}, which is the numeric prefix argument given to the
|
|
command. The result is a vector of @var{n} counts of how many times
|
|
each value appeared in the original vector. Non-integers in the input
|
|
are rounded down to integers. Any vector elements outside the specified
|
|
range are ignored. (You can tell if elements have been ignored by noting
|
|
that the counts in the result vector don't add up to the length of the
|
|
input vector.)
|
|
|
|
@kindex H V H
|
|
With the Hyperbolic flag, @kbd{H V H} pulls two vectors from the stack.
|
|
The second-to-top vector is the list of numbers as before. The top
|
|
vector is an equal-sized list of ``weights'' to attach to the elements
|
|
of the data vector. For example, if the first data element is 4.2 and
|
|
the first weight is 10, then 10 will be added to bin 4 of the result
|
|
vector. Without the hyperbolic flag, every element has a weight of one.
|
|
|
|
@kindex v t
|
|
@pindex calc-transpose
|
|
@tindex trn
|
|
The @kbd{v t} (@code{calc-transpose}) [@code{trn}] command computes
|
|
the transpose of the matrix at the top of the stack. If the argument
|
|
is a plain vector, it is treated as a row vector and transposed into
|
|
a one-column matrix.
|
|
|
|
@kindex v v
|
|
@pindex calc-reverse-vector
|
|
@tindex rev
|
|
The @kbd{v v} (@code{calc-reverse-vector}) [@code{rev}] command reverses
|
|
a vector end-for-end. Given a matrix, it reverses the order of the rows.
|
|
(To reverse the columns instead, just use @kbd{v t v v v t}. The same
|
|
principle can be used to apply other vector commands to the columns of
|
|
a matrix.)
|
|
|
|
@kindex v m
|
|
@pindex calc-mask-vector
|
|
@tindex vmask
|
|
The @kbd{v m} (@code{calc-mask-vector}) [@code{vmask}] command uses
|
|
one vector as a mask to extract elements of another vector. The mask
|
|
is in the second-to-top position; the target vector is on the top of
|
|
the stack. These vectors must have the same length. The result is
|
|
the same as the target vector, but with all elements which correspond
|
|
to zeros in the mask vector deleted. Thus, for example,
|
|
@samp{vmask([1, 0, 1, 0, 1], [a, b, c, d, e])} produces @samp{[a, c, e]}.
|
|
@xref{Logical Operations}.
|
|
|
|
@kindex v e
|
|
@pindex calc-expand-vector
|
|
@tindex vexp
|
|
The @kbd{v e} (@code{calc-expand-vector}) [@code{vexp}] command
|
|
expands a vector according to another mask vector. The result is a
|
|
vector the same length as the mask, but with nonzero elements replaced
|
|
by successive elements from the target vector. The length of the target
|
|
vector is normally the number of nonzero elements in the mask. If the
|
|
target vector is longer, its last few elements are lost. If the target
|
|
vector is shorter, the last few nonzero mask elements are left
|
|
unreplaced in the result. Thus @samp{vexp([2, 0, 3, 0, 7], [a, b])}
|
|
produces @samp{[a, 0, b, 0, 7]}.
|
|
|
|
@kindex H v e
|
|
With the Hyperbolic flag, @kbd{H v e} takes a filler value from the
|
|
top of the stack; the mask and target vectors come from the third and
|
|
second elements of the stack. This filler is used where the mask is
|
|
zero: @samp{vexp([2, 0, 3, 0, 7], [a, b], z)} produces
|
|
@samp{[a, z, c, z, 7]}. If the filler value is itself a vector,
|
|
then successive values are taken from it, so that the effect is to
|
|
interleave two vectors according to the mask:
|
|
@samp{vexp([2, 0, 3, 7, 0, 0], [a, b], [x, y])} produces
|
|
@samp{[a, x, b, 7, y, 0]}.
|
|
|
|
Another variation on the masking idea is to combine @samp{[a, b, c, d, e]}
|
|
with the mask @samp{[1, 0, 1, 0, 1]} to produce @samp{[a, 0, c, 0, e]}.
|
|
You can accomplish this with @kbd{V M a &}, mapping the logical ``and''
|
|
operation across the two vectors. @xref{Logical Operations}. Note that
|
|
the @code{? :} operation also discussed there allows other types of
|
|
masking using vectors.
|
|
|
|
@node Vector and Matrix Arithmetic, Set Operations, Manipulating Vectors, Matrix Functions
|
|
@section Vector and Matrix Arithmetic
|
|
|
|
@noindent
|
|
Basic arithmetic operations like addition and multiplication are defined
|
|
for vectors and matrices as well as for numbers. Division of matrices, in
|
|
the sense of multiplying by the inverse, is supported. (Division by a
|
|
matrix actually uses LU-decomposition for greater accuracy and speed.)
|
|
@xref{Basic Arithmetic}.
|
|
|
|
The following functions are applied element-wise if their arguments are
|
|
vectors or matrices: @code{change-sign}, @code{conj}, @code{arg},
|
|
@code{re}, @code{im}, @code{polar}, @code{rect}, @code{clean},
|
|
@code{float}, @code{frac}. @xref{Function Index}.
|
|
|
|
@kindex V J
|
|
@pindex calc-conj-transpose
|
|
@tindex ctrn
|
|
The @kbd{V J} (@code{calc-conj-transpose}) [@code{ctrn}] command computes
|
|
the conjugate transpose of its argument, i.e., @samp{conj(trn(x))}.
|
|
|
|
@ignore
|
|
@mindex A
|
|
@end ignore
|
|
@kindex A (vectors)
|
|
@pindex calc-abs (vectors)
|
|
@ignore
|
|
@mindex abs
|
|
@end ignore
|
|
@tindex abs (vectors)
|
|
The @kbd{A} (@code{calc-abs}) [@code{abs}] command computes the
|
|
Frobenius norm of a vector or matrix argument. This is the square
|
|
root of the sum of the squares of the absolute values of the
|
|
elements of the vector or matrix. If the vector is interpreted as
|
|
a point in two- or three-dimensional space, this is the distance
|
|
from that point to the origin.
|
|
|
|
@kindex v n
|
|
@pindex calc-rnorm
|
|
@tindex rnorm
|
|
The @kbd{v n} (@code{calc-rnorm}) [@code{rnorm}] command computes
|
|
the row norm, or infinity-norm, of a vector or matrix. For a plain
|
|
vector, this is the maximum of the absolute values of the elements.
|
|
For a matrix, this is the maximum of the row-absolute-value-sums,
|
|
i.e., of the sums of the absolute values of the elements along the
|
|
various rows.
|
|
|
|
@kindex V N
|
|
@pindex calc-cnorm
|
|
@tindex cnorm
|
|
The @kbd{V N} (@code{calc-cnorm}) [@code{cnorm}] command computes
|
|
the column norm, or one-norm, of a vector or matrix. For a plain
|
|
vector, this is the sum of the absolute values of the elements.
|
|
For a matrix, this is the maximum of the column-absolute-value-sums.
|
|
General @expr{k}-norms for @expr{k} other than one or infinity are
|
|
not provided.
|
|
|
|
@kindex V C
|
|
@pindex calc-cross
|
|
@tindex cross
|
|
The @kbd{V C} (@code{calc-cross}) [@code{cross}] command computes the
|
|
right-handed cross product of two vectors, each of which must have
|
|
exactly three elements.
|
|
|
|
@ignore
|
|
@mindex &
|
|
@end ignore
|
|
@kindex & (matrices)
|
|
@pindex calc-inv (matrices)
|
|
@ignore
|
|
@mindex inv
|
|
@end ignore
|
|
@tindex inv (matrices)
|
|
The @kbd{&} (@code{calc-inv}) [@code{inv}] command computes the
|
|
inverse of a square matrix. If the matrix is singular, the inverse
|
|
operation is left in symbolic form. Matrix inverses are recorded so
|
|
that once an inverse (or determinant) of a particular matrix has been
|
|
computed, the inverse and determinant of the matrix can be recomputed
|
|
quickly in the future.
|
|
|
|
If the argument to @kbd{&} is a plain number @expr{x}, this
|
|
command simply computes @expr{1/x}. This is okay, because the
|
|
@samp{/} operator also does a matrix inversion when dividing one
|
|
by a matrix.
|
|
|
|
@kindex V D
|
|
@pindex calc-mdet
|
|
@tindex det
|
|
The @kbd{V D} (@code{calc-mdet}) [@code{det}] command computes the
|
|
determinant of a square matrix.
|
|
|
|
@kindex V L
|
|
@pindex calc-mlud
|
|
@tindex lud
|
|
The @kbd{V L} (@code{calc-mlud}) [@code{lud}] command computes the
|
|
LU decomposition of a matrix. The result is a list of three matrices
|
|
which, when multiplied together left-to-right, form the original matrix.
|
|
The first is a permutation matrix that arises from pivoting in the
|
|
algorithm, the second is lower-triangular with ones on the diagonal,
|
|
and the third is upper-triangular.
|
|
|
|
@kindex V T
|
|
@pindex calc-mtrace
|
|
@tindex tr
|
|
The @kbd{V T} (@code{calc-mtrace}) [@code{tr}] command computes the
|
|
trace of a square matrix. This is defined as the sum of the diagonal
|
|
elements of the matrix.
|
|
|
|
@node Set Operations, Statistical Operations, Vector and Matrix Arithmetic, Matrix Functions
|
|
@section Set Operations using Vectors
|
|
|
|
@noindent
|
|
@cindex Sets, as vectors
|
|
Calc includes several commands which interpret vectors as @dfn{sets} of
|
|
objects. A set is a collection of objects; any given object can appear
|
|
only once in the set. Calc stores sets as vectors of objects in
|
|
sorted order. Objects in a Calc set can be any of the usual things,
|
|
such as numbers, variables, or formulas. Two set elements are considered
|
|
equal if they are identical, except that numerically equal numbers like
|
|
the integer 4 and the float 4.0 are considered equal even though they
|
|
are not ``identical.'' Variables are treated like plain symbols without
|
|
attached values by the set operations; subtracting the set @samp{[b]}
|
|
from @samp{[a, b]} always yields the set @samp{[a]} even though if
|
|
the variables @samp{a} and @samp{b} both equaled 17, you might
|
|
expect the answer @samp{[]}.
|
|
|
|
If a set contains interval forms, then it is assumed to be a set of
|
|
real numbers. In this case, all set operations require the elements
|
|
of the set to be only things that are allowed in intervals: Real
|
|
numbers, plus and minus infinity, HMS forms, and date forms. If
|
|
there are variables or other non-real objects present in a real set,
|
|
all set operations on it will be left in unevaluated form.
|
|
|
|
If the input to a set operation is a plain number or interval form
|
|
@var{a}, it is treated like the one-element vector @samp{[@var{a}]}.
|
|
The result is always a vector, except that if the set consists of a
|
|
single interval, the interval itself is returned instead.
|
|
|
|
@xref{Logical Operations}, for the @code{in} function which tests if
|
|
a certain value is a member of a given set. To test if the set @expr{A}
|
|
is a subset of the set @expr{B}, use @samp{vdiff(A, B) = []}.
|
|
|
|
@kindex V +
|
|
@pindex calc-remove-duplicates
|
|
@tindex rdup
|
|
The @kbd{V +} (@code{calc-remove-duplicates}) [@code{rdup}] command
|
|
converts an arbitrary vector into set notation. It works by sorting
|
|
the vector as if by @kbd{V S}, then removing duplicates. (For example,
|
|
@kbd{[a, 5, 4, a, 4.0]} is sorted to @samp{[4, 4.0, 5, a, a]} and then
|
|
reduced to @samp{[4, 5, a]}). Overlapping intervals are merged as
|
|
necessary. You rarely need to use @kbd{V +} explicitly, since all the
|
|
other set-based commands apply @kbd{V +} to their inputs before using
|
|
them.
|
|
|
|
@kindex V V
|
|
@pindex calc-set-union
|
|
@tindex vunion
|
|
The @kbd{V V} (@code{calc-set-union}) [@code{vunion}] command computes
|
|
the union of two sets. An object is in the union of two sets if and
|
|
only if it is in either (or both) of the input sets. (You could
|
|
accomplish the same thing by concatenating the sets with @kbd{|},
|
|
then using @kbd{V +}.)
|
|
|
|
@kindex V ^
|
|
@pindex calc-set-intersect
|
|
@tindex vint
|
|
The @kbd{V ^} (@code{calc-set-intersect}) [@code{vint}] command computes
|
|
the intersection of two sets. An object is in the intersection if
|
|
and only if it is in both of the input sets. Thus if the input
|
|
sets are disjoint, i.e., if they share no common elements, the result
|
|
will be the empty vector @samp{[]}. Note that the characters @kbd{V}
|
|
and @kbd{^} were chosen to be close to the conventional mathematical
|
|
notation for set
|
|
@texline union@tie{}(@math{A \cup B})
|
|
@infoline union
|
|
and
|
|
@texline intersection@tie{}(@math{A \cap B}).
|
|
@infoline intersection.
|
|
|
|
@kindex V -
|
|
@pindex calc-set-difference
|
|
@tindex vdiff
|
|
The @kbd{V -} (@code{calc-set-difference}) [@code{vdiff}] command computes
|
|
the difference between two sets. An object is in the difference
|
|
@expr{A - B} if and only if it is in @expr{A} but not in @expr{B}.
|
|
Thus subtracting @samp{[y,z]} from a set will remove the elements
|
|
@samp{y} and @samp{z} if they are present. You can also think of this
|
|
as a general @dfn{set complement} operator; if @expr{A} is the set of
|
|
all possible values, then @expr{A - B} is the ``complement'' of @expr{B}.
|
|
Obviously this is only practical if the set of all possible values in
|
|
your problem is small enough to list in a Calc vector (or simple
|
|
enough to express in a few intervals).
|
|
|
|
@kindex V X
|
|
@pindex calc-set-xor
|
|
@tindex vxor
|
|
The @kbd{V X} (@code{calc-set-xor}) [@code{vxor}] command computes
|
|
the ``exclusive-or,'' or ``symmetric difference'' of two sets.
|
|
An object is in the symmetric difference of two sets if and only
|
|
if it is in one, but @emph{not} both, of the sets. Objects that
|
|
occur in both sets ``cancel out.''
|
|
|
|
@kindex V ~
|
|
@pindex calc-set-complement
|
|
@tindex vcompl
|
|
The @kbd{V ~} (@code{calc-set-complement}) [@code{vcompl}] command
|
|
computes the complement of a set with respect to the real numbers.
|
|
Thus @samp{vcompl(x)} is equivalent to @samp{vdiff([-inf .. inf], x)}.
|
|
For example, @samp{vcompl([2, (3 .. 4]])} evaluates to
|
|
@samp{[[-inf .. 2), (2 .. 3], (4 .. inf]]}.
|
|
|
|
@kindex V F
|
|
@pindex calc-set-floor
|
|
@tindex vfloor
|
|
The @kbd{V F} (@code{calc-set-floor}) [@code{vfloor}] command
|
|
reinterprets a set as a set of integers. Any non-integer values,
|
|
and intervals that do not enclose any integers, are removed. Open
|
|
intervals are converted to equivalent closed intervals. Successive
|
|
integers are converted into intervals of integers. For example, the
|
|
complement of the set @samp{[2, 6, 7, 8]} is messy, but if you wanted
|
|
the complement with respect to the set of integers you could type
|
|
@kbd{V ~ V F} to get @samp{[[-inf .. 1], [3 .. 5], [9 .. inf]]}.
|
|
|
|
@kindex V E
|
|
@pindex calc-set-enumerate
|
|
@tindex venum
|
|
The @kbd{V E} (@code{calc-set-enumerate}) [@code{venum}] command
|
|
converts a set of integers into an explicit vector. Intervals in
|
|
the set are expanded out to lists of all integers encompassed by
|
|
the intervals. This only works for finite sets (i.e., sets which
|
|
do not involve @samp{-inf} or @samp{inf}).
|
|
|
|
@kindex V :
|
|
@pindex calc-set-span
|
|
@tindex vspan
|
|
The @kbd{V :} (@code{calc-set-span}) [@code{vspan}] command converts any
|
|
set of reals into an interval form that encompasses all its elements.
|
|
The lower limit will be the smallest element in the set; the upper
|
|
limit will be the largest element. For an empty set, @samp{vspan([])}
|
|
returns the empty interval @w{@samp{[0 .. 0)}}.
|
|
|
|
@kindex V #
|
|
@pindex calc-set-cardinality
|
|
@tindex vcard
|
|
The @kbd{V #} (@code{calc-set-cardinality}) [@code{vcard}] command counts
|
|
the number of integers in a set. The result is the length of the vector
|
|
that would be produced by @kbd{V E}, although the computation is much
|
|
more efficient than actually producing that vector.
|
|
|
|
@cindex Sets, as binary numbers
|
|
Another representation for sets that may be more appropriate in some
|
|
cases is binary numbers. If you are dealing with sets of integers
|
|
in the range 0 to 49, you can use a 50-bit binary number where a
|
|
particular bit is 1 if the corresponding element is in the set.
|
|
@xref{Binary Functions}, for a list of commands that operate on
|
|
binary numbers. Note that many of the above set operations have
|
|
direct equivalents in binary arithmetic: @kbd{b o} (@code{calc-or}),
|
|
@kbd{b a} (@code{calc-and}), @kbd{b d} (@code{calc-diff}),
|
|
@kbd{b x} (@code{calc-xor}), and @kbd{b n} (@code{calc-not}),
|
|
respectively. You can use whatever representation for sets is most
|
|
convenient to you.
|
|
|
|
@kindex b p
|
|
@kindex b u
|
|
@pindex calc-pack-bits
|
|
@pindex calc-unpack-bits
|
|
@tindex vpack
|
|
@tindex vunpack
|
|
The @kbd{b u} (@code{calc-unpack-bits}) [@code{vunpack}] command
|
|
converts an integer that represents a set in binary into a set
|
|
in vector/interval notation. For example, @samp{vunpack(67)}
|
|
returns @samp{[[0 .. 1], 6]}. If the input is negative, the set
|
|
it represents is semi-infinite: @samp{vunpack(-4) = [2 .. inf)}.
|
|
Use @kbd{V E} afterwards to expand intervals to individual
|
|
values if you wish. Note that this command uses the @kbd{b}
|
|
(binary) prefix key.
|
|
|
|
The @kbd{b p} (@code{calc-pack-bits}) [@code{vpack}] command
|
|
converts the other way, from a vector or interval representing
|
|
a set of nonnegative integers into a binary integer describing
|
|
the same set. The set may include positive infinity, but must
|
|
not include any negative numbers. The input is interpreted as a
|
|
set of integers in the sense of @kbd{V F} (@code{vfloor}). Beware
|
|
that a simple input like @samp{[100]} can result in a huge integer
|
|
representation
|
|
@texline (@math{2^{100}}, a 31-digit integer, in this case).
|
|
@infoline (@expr{2^100}, a 31-digit integer, in this case).
|
|
|
|
@node Statistical Operations, Reducing and Mapping, Set Operations, Matrix Functions
|
|
@section Statistical Operations on Vectors
|
|
|
|
@noindent
|
|
@cindex Statistical functions
|
|
The commands in this section take vectors as arguments and compute
|
|
various statistical measures on the data stored in the vectors. The
|
|
references used in the definitions of these functions are Bevington's
|
|
@emph{Data Reduction and Error Analysis for the Physical Sciences},
|
|
and @emph{Numerical Recipes} by Press, Flannery, Teukolsky and
|
|
Vetterling.
|
|
|
|
The statistical commands use the @kbd{u} prefix key followed by
|
|
a shifted letter or other character.
|
|
|
|
@xref{Manipulating Vectors}, for a description of @kbd{V H}
|
|
(@code{calc-histogram}).
|
|
|
|
@xref{Curve Fitting}, for the @kbd{a F} command for doing
|
|
least-squares fits to statistical data.
|
|
|
|
@xref{Probability Distribution Functions}, for several common
|
|
probability distribution functions.
|
|
|
|
@menu
|
|
* Single-Variable Statistics::
|
|
* Paired-Sample Statistics::
|
|
@end menu
|
|
|
|
@node Single-Variable Statistics, Paired-Sample Statistics, Statistical Operations, Statistical Operations
|
|
@subsection Single-Variable Statistics
|
|
|
|
@noindent
|
|
These functions do various statistical computations on single
|
|
vectors. Given a numeric prefix argument, they actually pop
|
|
@var{n} objects from the stack and combine them into a data
|
|
vector. Each object may be either a number or a vector; if a
|
|
vector, any sub-vectors inside it are ``flattened'' as if by
|
|
@kbd{v a 0}; @pxref{Manipulating Vectors}. By default one object
|
|
is popped, which (in order to be useful) is usually a vector.
|
|
|
|
If an argument is a variable name, and the value stored in that
|
|
variable is a vector, then the stored vector is used. This method
|
|
has the advantage that if your data vector is large, you can avoid
|
|
the slow process of manipulating it directly on the stack.
|
|
|
|
These functions are left in symbolic form if any of their arguments
|
|
are not numbers or vectors, e.g., if an argument is a formula, or
|
|
a non-vector variable. However, formulas embedded within vector
|
|
arguments are accepted; the result is a symbolic representation
|
|
of the computation, based on the assumption that the formula does
|
|
not itself represent a vector. All varieties of numbers such as
|
|
error forms and interval forms are acceptable.
|
|
|
|
Some of the functions in this section also accept a single error form
|
|
or interval as an argument. They then describe a property of the
|
|
normal or uniform (respectively) statistical distribution described
|
|
by the argument. The arguments are interpreted in the same way as
|
|
the @var{M} argument of the random number function @kbd{k r}. In
|
|
particular, an interval with integer limits is considered an integer
|
|
distribution, so that @samp{[2 .. 6)} is the same as @samp{[2 .. 5]}.
|
|
An interval with at least one floating-point limit is a continuous
|
|
distribution: @samp{[2.0 .. 6.0)} is @emph{not} the same as
|
|
@samp{[2.0 .. 5.0]}!
|
|
|
|
@kindex u #
|
|
@pindex calc-vector-count
|
|
@tindex vcount
|
|
The @kbd{u #} (@code{calc-vector-count}) [@code{vcount}] command
|
|
computes the number of data values represented by the inputs.
|
|
For example, @samp{vcount(1, [2, 3], [[4, 5], [], x, y])} returns 7.
|
|
If the argument is a single vector with no sub-vectors, this
|
|
simply computes the length of the vector.
|
|
|
|
@kindex u +
|
|
@kindex u *
|
|
@pindex calc-vector-sum
|
|
@pindex calc-vector-prod
|
|
@tindex vsum
|
|
@tindex vprod
|
|
@cindex Summations (statistical)
|
|
The @kbd{u +} (@code{calc-vector-sum}) [@code{vsum}] command
|
|
computes the sum of the data values. The @kbd{u *}
|
|
(@code{calc-vector-prod}) [@code{vprod}] command computes the
|
|
product of the data values. If the input is a single flat vector,
|
|
these are the same as @kbd{V R +} and @kbd{V R *}
|
|
(@pxref{Reducing and Mapping}).
|
|
|
|
@kindex u X
|
|
@kindex u N
|
|
@pindex calc-vector-max
|
|
@pindex calc-vector-min
|
|
@tindex vmax
|
|
@tindex vmin
|
|
The @kbd{u X} (@code{calc-vector-max}) [@code{vmax}] command
|
|
computes the maximum of the data values, and the @kbd{u N}
|
|
(@code{calc-vector-min}) [@code{vmin}] command computes the minimum.
|
|
If the argument is an interval, this finds the minimum or maximum
|
|
value in the interval. (Note that @samp{vmax([2..6)) = 5} as
|
|
described above.) If the argument is an error form, this returns
|
|
plus or minus infinity.
|
|
|
|
@kindex u M
|
|
@pindex calc-vector-mean
|
|
@tindex vmean
|
|
@cindex Mean of data values
|
|
The @kbd{u M} (@code{calc-vector-mean}) [@code{vmean}] command
|
|
computes the average (arithmetic mean) of the data values.
|
|
If the inputs are error forms
|
|
@texline @math{x \pm \sigma},
|
|
@infoline @samp{x +/- s},
|
|
this is the weighted mean of the @expr{x} values with weights
|
|
@texline @math{1 /\sigma^2}.
|
|
@infoline @expr{1 / s^2}.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \mu = { \displaystyle \sum { x_i \over \sigma_i^2 } \over
|
|
\displaystyle \sum { 1 \over \sigma_i^2 } } $$
|
|
@end tex
|
|
If the inputs are not error forms, this is simply the sum of the
|
|
values divided by the count of the values.
|
|
|
|
Note that a plain number can be considered an error form with
|
|
error
|
|
@texline @math{\sigma = 0}.
|
|
@infoline @expr{s = 0}.
|
|
If the input to @kbd{u M} is a mixture of
|
|
plain numbers and error forms, the result is the mean of the
|
|
plain numbers, ignoring all values with non-zero errors. (By the
|
|
above definitions it's clear that a plain number effectively
|
|
has an infinite weight, next to which an error form with a finite
|
|
weight is completely negligible.)
|
|
|
|
This function also works for distributions (error forms or
|
|
intervals). The mean of an error form `@var{a} @tfn{+/-} @var{b}' is simply
|
|
@expr{a}. The mean of an interval is the mean of the minimum
|
|
and maximum values of the interval.
|
|
|
|
@kindex I u M
|
|
@pindex calc-vector-mean-error
|
|
@tindex vmeane
|
|
The @kbd{I u M} (@code{calc-vector-mean-error}) [@code{vmeane}]
|
|
command computes the mean of the data points expressed as an
|
|
error form. This includes the estimated error associated with
|
|
the mean. If the inputs are error forms, the error is the square
|
|
root of the reciprocal of the sum of the reciprocals of the squares
|
|
of the input errors. (I.e., the variance is the reciprocal of the
|
|
sum of the reciprocals of the variances.)
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sigma_\mu^2 = {1 \over \displaystyle \sum {1 \over \sigma_i^2}} $$
|
|
@end tex
|
|
If the inputs are plain
|
|
numbers, the error is equal to the standard deviation of the values
|
|
divided by the square root of the number of values. (This works
|
|
out to be equivalent to calculating the standard deviation and
|
|
then assuming each value's error is equal to this standard
|
|
deviation.)
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sigma_\mu^2 = {\sigma^2 \over N} $$
|
|
@end tex
|
|
|
|
@kindex H u M
|
|
@pindex calc-vector-median
|
|
@tindex vmedian
|
|
@cindex Median of data values
|
|
The @kbd{H u M} (@code{calc-vector-median}) [@code{vmedian}]
|
|
command computes the median of the data values. The values are
|
|
first sorted into numerical order; the median is the middle
|
|
value after sorting. (If the number of data values is even,
|
|
the median is taken to be the average of the two middle values.)
|
|
The median function is different from the other functions in
|
|
this section in that the arguments must all be real numbers;
|
|
variables are not accepted even when nested inside vectors.
|
|
(Otherwise it is not possible to sort the data values.) If
|
|
any of the input values are error forms, their error parts are
|
|
ignored.
|
|
|
|
The median function also accepts distributions. For both normal
|
|
(error form) and uniform (interval) distributions, the median is
|
|
the same as the mean.
|
|
|
|
@kindex H I u M
|
|
@pindex calc-vector-harmonic-mean
|
|
@tindex vhmean
|
|
@cindex Harmonic mean
|
|
The @kbd{H I u M} (@code{calc-vector-harmonic-mean}) [@code{vhmean}]
|
|
command computes the harmonic mean of the data values. This is
|
|
defined as the reciprocal of the arithmetic mean of the reciprocals
|
|
of the values.
|
|
@tex
|
|
\turnoffactive
|
|
$$ { N \over \displaystyle \sum {1 \over x_i} } $$
|
|
@end tex
|
|
|
|
@kindex u G
|
|
@pindex calc-vector-geometric-mean
|
|
@tindex vgmean
|
|
@cindex Geometric mean
|
|
The @kbd{u G} (@code{calc-vector-geometric-mean}) [@code{vgmean}]
|
|
command computes the geometric mean of the data values. This
|
|
is the @var{n}th root of the product of the values. This is also
|
|
equal to the @code{exp} of the arithmetic mean of the logarithms
|
|
of the data values.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \exp \left ( \sum { \ln x_i } \right ) =
|
|
\left ( \prod { x_i } \right)^{1 / N} $$
|
|
@end tex
|
|
|
|
@kindex H u G
|
|
@tindex agmean
|
|
The @kbd{H u G} [@code{agmean}] command computes the ``arithmetic-geometric
|
|
mean'' of two numbers taken from the stack. This is computed by
|
|
replacing the two numbers with their arithmetic mean and geometric
|
|
mean, then repeating until the two values converge.
|
|
@tex
|
|
\turnoffactive
|
|
$$ a_{i+1} = { a_i + b_i \over 2 } , \qquad b_{i+1} = \sqrt{a_i b_i} $$
|
|
@end tex
|
|
|
|
@cindex Root-mean-square
|
|
Another commonly used mean, the RMS (root-mean-square), can be computed
|
|
for a vector of numbers simply by using the @kbd{A} command.
|
|
|
|
@kindex u S
|
|
@pindex calc-vector-sdev
|
|
@tindex vsdev
|
|
@cindex Standard deviation
|
|
@cindex Sample statistics
|
|
The @kbd{u S} (@code{calc-vector-sdev}) [@code{vsdev}] command
|
|
computes the standard
|
|
@texline deviation@tie{}@math{\sigma}
|
|
@infoline deviation
|
|
of the data values. If the values are error forms, the errors are used
|
|
as weights just as for @kbd{u M}. This is the @emph{sample} standard
|
|
deviation, whose value is the square root of the sum of the squares of
|
|
the differences between the values and the mean of the @expr{N} values,
|
|
divided by @expr{N-1}.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sigma^2 = {1 \over N - 1} \sum (x_i - \mu)^2 $$
|
|
@end tex
|
|
|
|
This function also applies to distributions. The standard deviation
|
|
of a single error form is simply the error part. The standard deviation
|
|
of a continuous interval happens to equal the difference between the
|
|
limits, divided by
|
|
@texline @math{\sqrt{12}}.
|
|
@infoline @expr{sqrt(12)}.
|
|
The standard deviation of an integer interval is the same as the
|
|
standard deviation of a vector of those integers.
|
|
|
|
@kindex I u S
|
|
@pindex calc-vector-pop-sdev
|
|
@tindex vpsdev
|
|
@cindex Population statistics
|
|
The @kbd{I u S} (@code{calc-vector-pop-sdev}) [@code{vpsdev}]
|
|
command computes the @emph{population} standard deviation.
|
|
It is defined by the same formula as above but dividing
|
|
by @expr{N} instead of by @expr{N-1}. The population standard
|
|
deviation is used when the input represents the entire set of
|
|
data values in the distribution; the sample standard deviation
|
|
is used when the input represents a sample of the set of all
|
|
data values, so that the mean computed from the input is itself
|
|
only an estimate of the true mean.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sigma^2 = {1 \over N} \sum (x_i - \mu)^2 $$
|
|
@end tex
|
|
|
|
For error forms and continuous intervals, @code{vpsdev} works
|
|
exactly like @code{vsdev}. For integer intervals, it computes the
|
|
population standard deviation of the equivalent vector of integers.
|
|
|
|
@kindex H u S
|
|
@kindex H I u S
|
|
@pindex calc-vector-variance
|
|
@pindex calc-vector-pop-variance
|
|
@tindex vvar
|
|
@tindex vpvar
|
|
@cindex Variance of data values
|
|
The @kbd{H u S} (@code{calc-vector-variance}) [@code{vvar}] and
|
|
@kbd{H I u S} (@code{calc-vector-pop-variance}) [@code{vpvar}]
|
|
commands compute the variance of the data values. The variance
|
|
is the
|
|
@texline square@tie{}@math{\sigma^2}
|
|
@infoline square
|
|
of the standard deviation, i.e., the sum of the
|
|
squares of the deviations of the data values from the mean.
|
|
(This definition also applies when the argument is a distribution.)
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex vflat
|
|
The @code{vflat} algebraic function returns a vector of its
|
|
arguments, interpreted in the same way as the other functions
|
|
in this section. For example, @samp{vflat(1, [2, [3, 4]], 5)}
|
|
returns @samp{[1, 2, 3, 4, 5]}.
|
|
|
|
@node Paired-Sample Statistics, , Single-Variable Statistics, Statistical Operations
|
|
@subsection Paired-Sample Statistics
|
|
|
|
@noindent
|
|
The functions in this section take two arguments, which must be
|
|
vectors of equal size. The vectors are each flattened in the same
|
|
way as by the single-variable statistical functions. Given a numeric
|
|
prefix argument of 1, these functions instead take one object from
|
|
the stack, which must be an
|
|
@texline @math{N\times2}
|
|
@infoline Nx2
|
|
matrix of data values. Once again, variable names can be used in place
|
|
of actual vectors and matrices.
|
|
|
|
@kindex u C
|
|
@pindex calc-vector-covariance
|
|
@tindex vcov
|
|
@cindex Covariance
|
|
The @kbd{u C} (@code{calc-vector-covariance}) [@code{vcov}] command
|
|
computes the sample covariance of two vectors. The covariance
|
|
of vectors @var{x} and @var{y} is the sum of the products of the
|
|
differences between the elements of @var{x} and the mean of @var{x}
|
|
times the differences between the corresponding elements of @var{y}
|
|
and the mean of @var{y}, all divided by @expr{N-1}. Note that
|
|
the variance of a vector is just the covariance of the vector
|
|
with itself. Once again, if the inputs are error forms the
|
|
errors are used as weight factors. If both @var{x} and @var{y}
|
|
are composed of error forms, the error for a given data point
|
|
is taken as the square root of the sum of the squares of the two
|
|
input errors.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sigma_{x\!y}^2 = {1 \over N-1} \sum (x_i - \mu_x) (y_i - \mu_y) $$
|
|
$$ \sigma_{x\!y}^2 =
|
|
{\displaystyle {1 \over N-1}
|
|
\sum {(x_i - \mu_x) (y_i - \mu_y) \over \sigma_i^2}
|
|
\over \displaystyle {1 \over N} \sum {1 \over \sigma_i^2}}
|
|
$$
|
|
@end tex
|
|
|
|
@kindex I u C
|
|
@pindex calc-vector-pop-covariance
|
|
@tindex vpcov
|
|
The @kbd{I u C} (@code{calc-vector-pop-covariance}) [@code{vpcov}]
|
|
command computes the population covariance, which is the same as the
|
|
sample covariance computed by @kbd{u C} except dividing by @expr{N}
|
|
instead of @expr{N-1}.
|
|
|
|
@kindex H u C
|
|
@pindex calc-vector-correlation
|
|
@tindex vcorr
|
|
@cindex Correlation coefficient
|
|
@cindex Linear correlation
|
|
The @kbd{H u C} (@code{calc-vector-correlation}) [@code{vcorr}]
|
|
command computes the linear correlation coefficient of two vectors.
|
|
This is defined by the covariance of the vectors divided by the
|
|
product of their standard deviations. (There is no difference
|
|
between sample or population statistics here.)
|
|
@tex
|
|
\turnoffactive
|
|
$$ r_{x\!y} = { \sigma_{x\!y}^2 \over \sigma_x^2 \sigma_y^2 } $$
|
|
@end tex
|
|
|
|
@node Reducing and Mapping, Vector and Matrix Formats, Statistical Operations, Matrix Functions
|
|
@section Reducing and Mapping Vectors
|
|
|
|
@noindent
|
|
The commands in this section allow for more general operations on the
|
|
elements of vectors.
|
|
|
|
@kindex V A
|
|
@pindex calc-apply
|
|
@tindex apply
|
|
The simplest of these operations is @kbd{V A} (@code{calc-apply})
|
|
[@code{apply}], which applies a given operator to the elements of a vector.
|
|
For example, applying the hypothetical function @code{f} to the vector
|
|
@w{@samp{[1, 2, 3]}} would produce the function call @samp{f(1, 2, 3)}.
|
|
Applying the @code{+} function to the vector @samp{[a, b]} gives
|
|
@samp{a + b}. Applying @code{+} to the vector @samp{[a, b, c]} is an
|
|
error, since the @code{+} function expects exactly two arguments.
|
|
|
|
While @kbd{V A} is useful in some cases, you will usually find that either
|
|
@kbd{V R} or @kbd{V M}, described below, is closer to what you want.
|
|
|
|
@menu
|
|
* Specifying Operators::
|
|
* Mapping::
|
|
* Reducing::
|
|
* Nesting and Fixed Points::
|
|
* Generalized Products::
|
|
@end menu
|
|
|
|
@node Specifying Operators, Mapping, Reducing and Mapping, Reducing and Mapping
|
|
@subsection Specifying Operators
|
|
|
|
@noindent
|
|
Commands in this section (like @kbd{V A}) prompt you to press the key
|
|
corresponding to the desired operator. Press @kbd{?} for a partial
|
|
list of the available operators. Generally, an operator is any key or
|
|
sequence of keys that would normally take one or more arguments from
|
|
the stack and replace them with a result. For example, @kbd{V A H C}
|
|
uses the hyperbolic cosine operator, @code{cosh}. (Since @code{cosh}
|
|
expects one argument, @kbd{V A H C} requires a vector with a single
|
|
element as its argument.)
|
|
|
|
You can press @kbd{x} at the operator prompt to select any algebraic
|
|
function by name to use as the operator. This includes functions you
|
|
have defined yourself using the @kbd{Z F} command. (@xref{Algebraic
|
|
Definitions}.) If you give a name for which no function has been
|
|
defined, the result is left in symbolic form, as in @samp{f(1, 2, 3)}.
|
|
Calc will prompt for the number of arguments the function takes if it
|
|
can't figure it out on its own (say, because you named a function that
|
|
is currently undefined). It is also possible to type a digit key before
|
|
the function name to specify the number of arguments, e.g.,
|
|
@kbd{V M 3 x f @key{RET}} calls @code{f} with three arguments even if it
|
|
looks like it ought to have only two. This technique may be necessary
|
|
if the function allows a variable number of arguments. For example,
|
|
the @kbd{v e} [@code{vexp}] function accepts two or three arguments;
|
|
if you want to map with the three-argument version, you will have to
|
|
type @kbd{V M 3 v e}.
|
|
|
|
It is also possible to apply any formula to a vector by treating that
|
|
formula as a function. When prompted for the operator to use, press
|
|
@kbd{'} (the apostrophe) and type your formula as an algebraic entry.
|
|
You will then be prompted for the argument list, which defaults to a
|
|
list of all variables that appear in the formula, sorted into alphabetic
|
|
order. For example, suppose you enter the formula @w{@samp{x + 2y^x}}.
|
|
The default argument list would be @samp{(x y)}, which means that if
|
|
this function is applied to the arguments @samp{[3, 10]} the result will
|
|
be @samp{3 + 2*10^3}. (If you plan to use a certain formula in this
|
|
way often, you might consider defining it as a function with @kbd{Z F}.)
|
|
|
|
Another way to specify the arguments to the formula you enter is with
|
|
@kbd{$}, @kbd{$$}, and so on. For example, @kbd{V A ' $$ + 2$^$$}
|
|
has the same effect as the previous example. The argument list is
|
|
automatically taken to be @samp{($$ $)}. (The order of the arguments
|
|
may seem backwards, but it is analogous to the way normal algebraic
|
|
entry interacts with the stack.)
|
|
|
|
If you press @kbd{$} at the operator prompt, the effect is similar to
|
|
the apostrophe except that the relevant formula is taken from top-of-stack
|
|
instead. The actual vector arguments of the @kbd{V A $} or related command
|
|
then start at the second-to-top stack position. You will still be
|
|
prompted for an argument list.
|
|
|
|
@cindex Nameless functions
|
|
@cindex Generic functions
|
|
A function can be written without a name using the notation @samp{<#1 - #2>},
|
|
which means ``a function of two arguments that computes the first
|
|
argument minus the second argument.'' The symbols @samp{#1} and @samp{#2}
|
|
are placeholders for the arguments. You can use any names for these
|
|
placeholders if you wish, by including an argument list followed by a
|
|
colon: @samp{<x, y : x - y>}. When you type @kbd{V A ' $$ + 2$^$$ @key{RET}},
|
|
Calc builds the nameless function @samp{<#1 + 2 #2^#1>} as the function
|
|
to map across the vectors. When you type @kbd{V A ' x + 2y^x @key{RET} @key{RET}},
|
|
Calc builds the nameless function @w{@samp{<x, y : x + 2 y^x>}}. In both
|
|
cases, Calc also writes the nameless function to the Trail so that you
|
|
can get it back later if you wish.
|
|
|
|
If there is only one argument, you can write @samp{#} in place of @samp{#1}.
|
|
(Note that @samp{< >} notation is also used for date forms. Calc tells
|
|
that @samp{<@var{stuff}>} is a nameless function by the presence of
|
|
@samp{#} signs inside @var{stuff}, or by the fact that @var{stuff}
|
|
begins with a list of variables followed by a colon.)
|
|
|
|
You can type a nameless function directly to @kbd{V A '}, or put one on
|
|
the stack and use it with @w{@kbd{V A $}}. Calc will not prompt for an
|
|
argument list in this case, since the nameless function specifies the
|
|
argument list as well as the function itself. In @kbd{V A '}, you can
|
|
omit the @samp{< >} marks if you use @samp{#} notation for the arguments,
|
|
so that @kbd{V A ' #1+#2 @key{RET}} is the same as @kbd{V A ' <#1+#2> @key{RET}},
|
|
which in turn is the same as @kbd{V A ' $$+$ @key{RET}}.
|
|
|
|
@cindex Lambda expressions
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex lambda
|
|
The internal format for @samp{<x, y : x + y>} is @samp{lambda(x, y, x + y)}.
|
|
(The word @code{lambda} derives from Lisp notation and the theory of
|
|
functions.) The internal format for @samp{<#1 + #2>} is @samp{lambda(ArgA,
|
|
ArgB, ArgA + ArgB)}. Note that there is no actual Calc function called
|
|
@code{lambda}; the whole point is that the @code{lambda} expression is
|
|
used in its symbolic form, not evaluated for an answer until it is applied
|
|
to specific arguments by a command like @kbd{V A} or @kbd{V M}.
|
|
|
|
(Actually, @code{lambda} does have one special property: Its arguments
|
|
are never evaluated; for example, putting @samp{<(2/3) #>} on the stack
|
|
will not simplify the @samp{2/3} until the nameless function is actually
|
|
called.)
|
|
|
|
@tindex add
|
|
@tindex sub
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@tindex mul
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex div
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex pow
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex neg
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex mod
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex vconcat
|
|
As usual, commands like @kbd{V A} have algebraic function name equivalents.
|
|
For example, @kbd{V A k g} with an argument of @samp{v} is equivalent to
|
|
@samp{apply(gcd, v)}. The first argument specifies the operator name,
|
|
and is either a variable whose name is the same as the function name,
|
|
or a nameless function like @samp{<#^3+1>}. Operators that are normally
|
|
written as algebraic symbols have the names @code{add}, @code{sub},
|
|
@code{mul}, @code{div}, @code{pow}, @code{neg}, @code{mod}, and
|
|
@code{vconcat}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex call
|
|
The @code{call} function builds a function call out of several arguments:
|
|
@samp{call(gcd, x, y)} is the same as @samp{apply(gcd, [x, y])}, which
|
|
in turn is the same as @samp{gcd(x, y)}. The first argument of @code{call},
|
|
like the other functions described here, may be either a variable naming a
|
|
function, or a nameless function (@samp{call(<#1+2#2>, x, y)} is the same
|
|
as @samp{x + 2y}).
|
|
|
|
(Experts will notice that it's not quite proper to use a variable to name
|
|
a function, since the name @code{gcd} corresponds to the Lisp variable
|
|
@code{var-gcd} but to the Lisp function @code{calcFunc-gcd}. Calc
|
|
automatically makes this translation, so you don't have to worry
|
|
about it.)
|
|
|
|
@node Mapping, Reducing, Specifying Operators, Reducing and Mapping
|
|
@subsection Mapping
|
|
|
|
@noindent
|
|
@kindex V M
|
|
@pindex calc-map
|
|
@tindex map
|
|
The @kbd{V M} (@code{calc-map}) [@code{map}] command applies a given
|
|
operator elementwise to one or more vectors. For example, mapping
|
|
@code{A} [@code{abs}] produces a vector of the absolute values of the
|
|
elements in the input vector. Mapping @code{+} pops two vectors from
|
|
the stack, which must be of equal length, and produces a vector of the
|
|
pairwise sums of the elements. If either argument is a non-vector, it
|
|
is duplicated for each element of the other vector. For example,
|
|
@kbd{[1,2,3] 2 V M ^} squares the elements of the specified vector.
|
|
With the 2 listed first, it would have computed a vector of powers of
|
|
two. Mapping a user-defined function pops as many arguments from the
|
|
stack as the function requires. If you give an undefined name, you will
|
|
be prompted for the number of arguments to use.
|
|
|
|
If any argument to @kbd{V M} is a matrix, the operator is normally mapped
|
|
across all elements of the matrix. For example, given the matrix
|
|
@expr{[[1, -2, 3], [-4, 5, -6]]}, @kbd{V M A} takes six absolute values to
|
|
produce another
|
|
@texline @math{3\times2}
|
|
@infoline 3x2
|
|
matrix, @expr{[[1, 2, 3], [4, 5, 6]]}.
|
|
|
|
@tindex mapr
|
|
The command @kbd{V M _} [@code{mapr}] (i.e., type an underscore at the
|
|
operator prompt) maps by rows instead. For example, @kbd{V M _ A} views
|
|
the above matrix as a vector of two 3-element row vectors. It produces
|
|
a new vector which contains the absolute values of those row vectors,
|
|
namely @expr{[3.74, 8.77]}. (Recall, the absolute value of a vector is
|
|
defined as the square root of the sum of the squares of the elements.)
|
|
Some operators accept vectors and return new vectors; for example,
|
|
@kbd{v v} reverses a vector, so @kbd{V M _ v v} would reverse each row
|
|
of the matrix to get a new matrix, @expr{[[3, -2, 1], [-6, 5, -4]]}.
|
|
|
|
Sometimes a vector of vectors (representing, say, strings, sets, or lists)
|
|
happens to look like a matrix. If so, remember to use @kbd{V M _} if you
|
|
want to map a function across the whole strings or sets rather than across
|
|
their individual elements.
|
|
|
|
@tindex mapc
|
|
The command @kbd{V M :} [@code{mapc}] maps by columns. Basically, it
|
|
transposes the input matrix, maps by rows, and then, if the result is a
|
|
matrix, transposes again. For example, @kbd{V M : A} takes the absolute
|
|
values of the three columns of the matrix, treating each as a 2-vector,
|
|
and @kbd{V M : v v} reverses the columns to get the matrix
|
|
@expr{[[-4, 5, -6], [1, -2, 3]]}.
|
|
|
|
(The symbols @kbd{_} and @kbd{:} were chosen because they had row-like
|
|
and column-like appearances, and were not already taken by useful
|
|
operators. Also, they appear shifted on most keyboards so they are easy
|
|
to type after @kbd{V M}.)
|
|
|
|
The @kbd{_} and @kbd{:} modifiers have no effect on arguments that are
|
|
not matrices (so if none of the arguments are matrices, they have no
|
|
effect at all). If some of the arguments are matrices and others are
|
|
plain numbers, the plain numbers are held constant for all rows of the
|
|
matrix (so that @kbd{2 V M _ ^} squares every row of a matrix; squaring
|
|
a vector takes a dot product of the vector with itself).
|
|
|
|
If some of the arguments are vectors with the same lengths as the
|
|
rows (for @kbd{V M _}) or columns (for @kbd{V M :}) of the matrix
|
|
arguments, those vectors are also held constant for every row or
|
|
column.
|
|
|
|
Sometimes it is useful to specify another mapping command as the operator
|
|
to use with @kbd{V M}. For example, @kbd{V M _ V A +} applies @kbd{V A +}
|
|
to each row of the input matrix, which in turn adds the two values on that
|
|
row. If you give another vector-operator command as the operator for
|
|
@kbd{V M}, it automatically uses map-by-rows mode if you don't specify
|
|
otherwise; thus @kbd{V M V A +} is equivalent to @kbd{V M _ V A +}. (If
|
|
you really want to map-by-elements another mapping command, you can use
|
|
a triple-nested mapping command: @kbd{V M V M V A +} means to map
|
|
@kbd{V M V A +} over the rows of the matrix; in turn, @kbd{V A +} is
|
|
mapped over the elements of each row.)
|
|
|
|
@tindex mapa
|
|
@tindex mapd
|
|
Previous versions of Calc had ``map across'' and ``map down'' modes
|
|
that are now considered obsolete; the old ``map across'' is now simply
|
|
@kbd{V M V A}, and ``map down'' is now @kbd{V M : V A}. The algebraic
|
|
functions @code{mapa} and @code{mapd} are still supported, though.
|
|
Note also that, while the old mapping modes were persistent (once you
|
|
set the mode, it would apply to later mapping commands until you reset
|
|
it), the new @kbd{:} and @kbd{_} modifiers apply only to the current
|
|
mapping command. The default @kbd{V M} always means map-by-elements.
|
|
|
|
@xref{Algebraic Manipulation}, for the @kbd{a M} command, which is like
|
|
@kbd{V M} but for equations and inequalities instead of vectors.
|
|
@xref{Storing Variables}, for the @kbd{s m} command which modifies a
|
|
variable's stored value using a @kbd{V M}-like operator.
|
|
|
|
@node Reducing, Nesting and Fixed Points, Mapping, Reducing and Mapping
|
|
@subsection Reducing
|
|
|
|
@noindent
|
|
@kindex V R
|
|
@pindex calc-reduce
|
|
@tindex reduce
|
|
The @kbd{V R} (@code{calc-reduce}) [@code{reduce}] command applies a given
|
|
binary operator across all the elements of a vector. A binary operator is
|
|
a function such as @code{+} or @code{max} which takes two arguments. For
|
|
example, reducing @code{+} over a vector computes the sum of the elements
|
|
of the vector. Reducing @code{-} computes the first element minus each of
|
|
the remaining elements. Reducing @code{max} computes the maximum element
|
|
and so on. In general, reducing @code{f} over the vector @samp{[a, b, c, d]}
|
|
produces @samp{f(f(f(a, b), c), d)}.
|
|
|
|
@kindex I V R
|
|
@tindex rreduce
|
|
The @kbd{I V R} [@code{rreduce}] command is similar to @kbd{V R} except
|
|
that works from right to left through the vector. For example, plain
|
|
@kbd{V R -} on the vector @samp{[a, b, c, d]} produces @samp{a - b - c - d}
|
|
but @kbd{I V R -} on the same vector produces @samp{a - (b - (c - d))},
|
|
or @samp{a - b + c - d}. This ``alternating sum'' occurs frequently
|
|
in power series expansions.
|
|
|
|
@kindex V U
|
|
@tindex accum
|
|
The @kbd{V U} (@code{calc-accumulate}) [@code{accum}] command does an
|
|
accumulation operation. Here Calc does the corresponding reduction
|
|
operation, but instead of producing only the final result, it produces
|
|
a vector of all the intermediate results. Accumulating @code{+} over
|
|
the vector @samp{[a, b, c, d]} produces the vector
|
|
@samp{[a, a + b, a + b + c, a + b + c + d]}.
|
|
|
|
@kindex I V U
|
|
@tindex raccum
|
|
The @kbd{I V U} [@code{raccum}] command does a right-to-left accumulation.
|
|
For example, @kbd{I V U -} on the vector @samp{[a, b, c, d]} produces the
|
|
vector @samp{[a - b + c - d, b - c + d, c - d, d]}.
|
|
|
|
@tindex reducea
|
|
@tindex rreducea
|
|
@tindex reduced
|
|
@tindex rreduced
|
|
As for @kbd{V M}, @kbd{V R} normally reduces a matrix elementwise. For
|
|
example, given the matrix @expr{[[a, b, c], [d, e, f]]}, @kbd{V R +} will
|
|
compute @expr{a + b + c + d + e + f}. You can type @kbd{V R _} or
|
|
@kbd{V R :} to modify this behavior. The @kbd{V R _} [@code{reducea}]
|
|
command reduces ``across'' the matrix; it reduces each row of the matrix
|
|
as a vector, then collects the results. Thus @kbd{V R _ +} of this
|
|
matrix would produce @expr{[a + b + c, d + e + f]}. Similarly, @kbd{V R :}
|
|
[@code{reduced}] reduces down; @kbd{V R : +} would produce @expr{[a + d,
|
|
b + e, c + f]}.
|
|
|
|
@tindex reducer
|
|
@tindex rreducer
|
|
There is a third ``by rows'' mode for reduction that is occasionally
|
|
useful; @kbd{V R =} [@code{reducer}] simply reduces the operator over
|
|
the rows of the matrix themselves. Thus @kbd{V R = +} on the above
|
|
matrix would get the same result as @kbd{V R : +}, since adding two
|
|
row vectors is equivalent to adding their elements. But @kbd{V R = *}
|
|
would multiply the two rows (to get a single number, their dot product),
|
|
while @kbd{V R : *} would produce a vector of the products of the columns.
|
|
|
|
These three matrix reduction modes work with @kbd{V R} and @kbd{I V R},
|
|
but they are not currently supported with @kbd{V U} or @kbd{I V U}.
|
|
|
|
@tindex reducec
|
|
@tindex rreducec
|
|
The obsolete reduce-by-columns function, @code{reducec}, is still
|
|
supported but there is no way to get it through the @kbd{V R} command.
|
|
|
|
The commands @kbd{C-x * :} and @kbd{C-x * _} are equivalent to typing
|
|
@kbd{C-x * r} to grab a rectangle of data into Calc, and then typing
|
|
@kbd{V R : +} or @kbd{V R _ +}, respectively, to sum the columns or
|
|
rows of the matrix. @xref{Grabbing From Buffers}.
|
|
|
|
@node Nesting and Fixed Points, Generalized Products, Reducing, Reducing and Mapping
|
|
@subsection Nesting and Fixed Points
|
|
|
|
@noindent
|
|
@kindex H V R
|
|
@tindex nest
|
|
The @kbd{H V R} [@code{nest}] command applies a function to a given
|
|
argument repeatedly. It takes two values, @samp{a} and @samp{n}, from
|
|
the stack, where @samp{n} must be an integer. It then applies the
|
|
function nested @samp{n} times; if the function is @samp{f} and @samp{n}
|
|
is 3, the result is @samp{f(f(f(a)))}. The number @samp{n} may be
|
|
negative if Calc knows an inverse for the function @samp{f}; for
|
|
example, @samp{nest(sin, a, -2)} returns @samp{arcsin(arcsin(a))}.
|
|
|
|
@kindex H V U
|
|
@tindex anest
|
|
The @kbd{H V U} [@code{anest}] command is an accumulating version of
|
|
@code{nest}: It returns a vector of @samp{n+1} values, e.g.,
|
|
@samp{[a, f(a), f(f(a)), f(f(f(a)))]}. If @samp{n} is negative and
|
|
@samp{F} is the inverse of @samp{f}, then the result is of the
|
|
form @samp{[a, F(a), F(F(a)), F(F(F(a)))]}.
|
|
|
|
@kindex H I V R
|
|
@tindex fixp
|
|
@cindex Fixed points
|
|
The @kbd{H I V R} [@code{fixp}] command is like @kbd{H V R}, except
|
|
that it takes only an @samp{a} value from the stack; the function is
|
|
applied until it reaches a ``fixed point,'' i.e., until the result
|
|
no longer changes.
|
|
|
|
@kindex H I V U
|
|
@tindex afixp
|
|
The @kbd{H I V U} [@code{afixp}] command is an accumulating @code{fixp}.
|
|
The first element of the return vector will be the initial value @samp{a};
|
|
the last element will be the final result that would have been returned
|
|
by @code{fixp}.
|
|
|
|
For example, 0.739085 is a fixed point of the cosine function (in radians):
|
|
@samp{cos(0.739085) = 0.739085}. You can find this value by putting, say,
|
|
1.0 on the stack and typing @kbd{H I V U C}. (We use the accumulating
|
|
version so we can see the intermediate results: @samp{[1, 0.540302, 0.857553,
|
|
0.65329, ...]}. With a precision of six, this command will take 36 steps
|
|
to converge to 0.739085.)
|
|
|
|
Newton's method for finding roots is a classic example of iteration
|
|
to a fixed point. To find the square root of five starting with an
|
|
initial guess, Newton's method would look for a fixed point of the
|
|
function @samp{(x + 5/x) / 2}. Putting a guess of 1 on the stack
|
|
and typing @kbd{H I V R ' ($ + 5/$)/2 @key{RET}} quickly yields the result
|
|
2.23607. This is equivalent to using the @kbd{a R} (@code{calc-find-root})
|
|
command to find a root of the equation @samp{x^2 = 5}.
|
|
|
|
These examples used numbers for @samp{a} values. Calc keeps applying
|
|
the function until two successive results are equal to within the
|
|
current precision. For complex numbers, both the real parts and the
|
|
imaginary parts must be equal to within the current precision. If
|
|
@samp{a} is a formula (say, a variable name), then the function is
|
|
applied until two successive results are exactly the same formula.
|
|
It is up to you to ensure that the function will eventually converge;
|
|
if it doesn't, you may have to press @kbd{C-g} to stop the Calculator.
|
|
|
|
The algebraic @code{fixp} function takes two optional arguments, @samp{n}
|
|
and @samp{tol}. The first is the maximum number of steps to be allowed,
|
|
and must be either an integer or the symbol @samp{inf} (infinity, the
|
|
default). The second is a convergence tolerance. If a tolerance is
|
|
specified, all results during the calculation must be numbers, not
|
|
formulas, and the iteration stops when the magnitude of the difference
|
|
between two successive results is less than or equal to the tolerance.
|
|
(This implies that a tolerance of zero iterates until the results are
|
|
exactly equal.)
|
|
|
|
Putting it all together, @samp{fixp(<(# + A/#)/2>, B, 20, 1e-10)}
|
|
computes the square root of @samp{A} given the initial guess @samp{B},
|
|
stopping when the result is correct within the specified tolerance, or
|
|
when 20 steps have been taken, whichever is sooner.
|
|
|
|
@node Generalized Products, , Nesting and Fixed Points, Reducing and Mapping
|
|
@subsection Generalized Products
|
|
|
|
@kindex V O
|
|
@pindex calc-outer-product
|
|
@tindex outer
|
|
The @kbd{V O} (@code{calc-outer-product}) [@code{outer}] command applies
|
|
a given binary operator to all possible pairs of elements from two
|
|
vectors, to produce a matrix. For example, @kbd{V O *} with @samp{[a, b]}
|
|
and @samp{[x, y, z]} on the stack produces a multiplication table:
|
|
@samp{[[a x, a y, a z], [b x, b y, b z]]}. Element @var{r},@var{c} of
|
|
the result matrix is obtained by applying the operator to element @var{r}
|
|
of the lefthand vector and element @var{c} of the righthand vector.
|
|
|
|
@kindex V I
|
|
@pindex calc-inner-product
|
|
@tindex inner
|
|
The @kbd{V I} (@code{calc-inner-product}) [@code{inner}] command computes
|
|
the generalized inner product of two vectors or matrices, given a
|
|
``multiplicative'' operator and an ``additive'' operator. These can each
|
|
actually be any binary operators; if they are @samp{*} and @samp{+},
|
|
respectively, the result is a standard matrix multiplication. Element
|
|
@var{r},@var{c} of the result matrix is obtained by mapping the
|
|
multiplicative operator across row @var{r} of the lefthand matrix and
|
|
column @var{c} of the righthand matrix, and then reducing with the additive
|
|
operator. Just as for the standard @kbd{*} command, this can also do a
|
|
vector-matrix or matrix-vector inner product, or a vector-vector
|
|
generalized dot product.
|
|
|
|
Since @kbd{V I} requires two operators, it prompts twice. In each case,
|
|
you can use any of the usual methods for entering the operator. If you
|
|
use @kbd{$} twice to take both operator formulas from the stack, the
|
|
first (multiplicative) operator is taken from the top of the stack
|
|
and the second (additive) operator is taken from second-to-top.
|
|
|
|
@node Vector and Matrix Formats, , Reducing and Mapping, Matrix Functions
|
|
@section Vector and Matrix Display Formats
|
|
|
|
@noindent
|
|
Commands for controlling vector and matrix display use the @kbd{v} prefix
|
|
instead of the usual @kbd{d} prefix. But they are display modes; in
|
|
particular, they are influenced by the @kbd{I} and @kbd{H} prefix keys
|
|
in the same way (@pxref{Display Modes}). Matrix display is also
|
|
influenced by the @kbd{d O} (@code{calc-flat-language}) mode;
|
|
@pxref{Normal Language Modes}.
|
|
|
|
@kindex V <
|
|
@pindex calc-matrix-left-justify
|
|
@kindex V =
|
|
@pindex calc-matrix-center-justify
|
|
@kindex V >
|
|
@pindex calc-matrix-right-justify
|
|
The commands @kbd{v <} (@code{calc-matrix-left-justify}), @kbd{v >}
|
|
(@code{calc-matrix-right-justify}), and @w{@kbd{v =}}
|
|
(@code{calc-matrix-center-justify}) control whether matrix elements
|
|
are justified to the left, right, or center of their columns.
|
|
|
|
@kindex V [
|
|
@pindex calc-vector-brackets
|
|
@kindex V @{
|
|
@pindex calc-vector-braces
|
|
@kindex V (
|
|
@pindex calc-vector-parens
|
|
The @kbd{v [} (@code{calc-vector-brackets}) command turns the square
|
|
brackets that surround vectors and matrices displayed in the stack on
|
|
and off. The @kbd{v @{} (@code{calc-vector-braces}) and @kbd{v (}
|
|
(@code{calc-vector-parens}) commands use curly braces or parentheses,
|
|
respectively, instead of square brackets. For example, @kbd{v @{} might
|
|
be used in preparation for yanking a matrix into a buffer running
|
|
Mathematica. (In fact, the Mathematica language mode uses this mode;
|
|
@pxref{Mathematica Language Mode}.) Note that, regardless of the
|
|
display mode, either brackets or braces may be used to enter vectors,
|
|
and parentheses may never be used for this purpose.
|
|
|
|
@kindex V ]
|
|
@pindex calc-matrix-brackets
|
|
The @kbd{v ]} (@code{calc-matrix-brackets}) command controls the
|
|
``big'' style display of matrices. It prompts for a string of code
|
|
letters; currently implemented letters are @code{R}, which enables
|
|
brackets on each row of the matrix; @code{O}, which enables outer
|
|
brackets in opposite corners of the matrix; and @code{C}, which
|
|
enables commas or semicolons at the ends of all rows but the last.
|
|
The default format is @samp{RO}. (Before Calc 2.00, the format
|
|
was fixed at @samp{ROC}.) Here are some example matrices:
|
|
|
|
@example
|
|
@group
|
|
[ [ 123, 0, 0 ] [ [ 123, 0, 0 ],
|
|
[ 0, 123, 0 ] [ 0, 123, 0 ],
|
|
[ 0, 0, 123 ] ] [ 0, 0, 123 ] ]
|
|
|
|
RO ROC
|
|
|
|
@end group
|
|
@end example
|
|
@noindent
|
|
@example
|
|
@group
|
|
[ 123, 0, 0 [ 123, 0, 0 ;
|
|
0, 123, 0 0, 123, 0 ;
|
|
0, 0, 123 ] 0, 0, 123 ]
|
|
|
|
O OC
|
|
|
|
@end group
|
|
@end example
|
|
@noindent
|
|
@example
|
|
@group
|
|
[ 123, 0, 0 ] 123, 0, 0
|
|
[ 0, 123, 0 ] 0, 123, 0
|
|
[ 0, 0, 123 ] 0, 0, 123
|
|
|
|
R @r{blank}
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
Note that of the formats shown here, @samp{RO}, @samp{ROC}, and
|
|
@samp{OC} are all recognized as matrices during reading, while
|
|
the others are useful for display only.
|
|
|
|
@kindex V ,
|
|
@pindex calc-vector-commas
|
|
The @kbd{v ,} (@code{calc-vector-commas}) command turns commas on and
|
|
off in vector and matrix display.
|
|
|
|
In vectors of length one, and in all vectors when commas have been
|
|
turned off, Calc adds extra parentheses around formulas that might
|
|
otherwise be ambiguous. For example, @samp{[a b]} could be a vector
|
|
of the one formula @samp{a b}, or it could be a vector of two
|
|
variables with commas turned off. Calc will display the former
|
|
case as @samp{[(a b)]}. You can disable these extra parentheses
|
|
(to make the output less cluttered at the expense of allowing some
|
|
ambiguity) by adding the letter @code{P} to the control string you
|
|
give to @kbd{v ]} (as described above).
|
|
|
|
@kindex V .
|
|
@pindex calc-full-vectors
|
|
The @kbd{v .} (@code{calc-full-vectors}) command turns abbreviated
|
|
display of long vectors on and off. In this mode, vectors of six
|
|
or more elements, or matrices of six or more rows or columns, will
|
|
be displayed in an abbreviated form that displays only the first
|
|
three elements and the last element: @samp{[a, b, c, ..., z]}.
|
|
When very large vectors are involved this will substantially
|
|
improve Calc's display speed.
|
|
|
|
@kindex t .
|
|
@pindex calc-full-trail-vectors
|
|
The @kbd{t .} (@code{calc-full-trail-vectors}) command controls a
|
|
similar mode for recording vectors in the Trail. If you turn on
|
|
this mode, vectors of six or more elements and matrices of six or
|
|
more rows or columns will be abbreviated when they are put in the
|
|
Trail. The @kbd{t y} (@code{calc-trail-yank}) command will be
|
|
unable to recover those vectors. If you are working with very
|
|
large vectors, this mode will improve the speed of all operations
|
|
that involve the trail.
|
|
|
|
@kindex V /
|
|
@pindex calc-break-vectors
|
|
The @kbd{v /} (@code{calc-break-vectors}) command turns multi-line
|
|
vector display on and off. Normally, matrices are displayed with one
|
|
row per line but all other types of vectors are displayed in a single
|
|
line. This mode causes all vectors, whether matrices or not, to be
|
|
displayed with a single element per line. Sub-vectors within the
|
|
vectors will still use the normal linear form.
|
|
|
|
@node Algebra, Units, Matrix Functions, Top
|
|
@chapter Algebra
|
|
|
|
@noindent
|
|
This section covers the Calc features that help you work with
|
|
algebraic formulas. First, the general sub-formula selection
|
|
mechanism is described; this works in conjunction with any Calc
|
|
commands. Then, commands for specific algebraic operations are
|
|
described. Finally, the flexible @dfn{rewrite rule} mechanism
|
|
is discussed.
|
|
|
|
The algebraic commands use the @kbd{a} key prefix; selection
|
|
commands use the @kbd{j} (for ``just a letter that wasn't used
|
|
for anything else'') prefix.
|
|
|
|
@xref{Editing Stack Entries}, to see how to manipulate formulas
|
|
using regular Emacs editing commands.
|
|
|
|
When doing algebraic work, you may find several of the Calculator's
|
|
modes to be helpful, including Algebraic Simplification mode (@kbd{m A})
|
|
or No-Simplification mode (@kbd{m O}),
|
|
Algebraic entry mode (@kbd{m a}), Fraction mode (@kbd{m f}), and
|
|
Symbolic mode (@kbd{m s}). @xref{Mode Settings}, for discussions
|
|
of these modes. You may also wish to select Big display mode (@kbd{d B}).
|
|
@xref{Normal Language Modes}.
|
|
|
|
@menu
|
|
* Selecting Subformulas::
|
|
* Algebraic Manipulation::
|
|
* Simplifying Formulas::
|
|
* Polynomials::
|
|
* Calculus::
|
|
* Solving Equations::
|
|
* Numerical Solutions::
|
|
* Curve Fitting::
|
|
* Summations::
|
|
* Logical Operations::
|
|
* Rewrite Rules::
|
|
@end menu
|
|
|
|
@node Selecting Subformulas, Algebraic Manipulation, Algebra, Algebra
|
|
@section Selecting Sub-Formulas
|
|
|
|
@noindent
|
|
@cindex Selections
|
|
@cindex Sub-formulas
|
|
@cindex Parts of formulas
|
|
When working with an algebraic formula it is often necessary to
|
|
manipulate a portion of the formula rather than the formula as a
|
|
whole. Calc allows you to ``select'' a portion of any formula on
|
|
the stack. Commands which would normally operate on that stack
|
|
entry will now operate only on the sub-formula, leaving the
|
|
surrounding part of the stack entry alone.
|
|
|
|
One common non-algebraic use for selection involves vectors. To work
|
|
on one element of a vector in-place, simply select that element as a
|
|
``sub-formula'' of the vector.
|
|
|
|
@menu
|
|
* Making Selections::
|
|
* Changing Selections::
|
|
* Displaying Selections::
|
|
* Operating on Selections::
|
|
* Rearranging with Selections::
|
|
@end menu
|
|
|
|
@node Making Selections, Changing Selections, Selecting Subformulas, Selecting Subformulas
|
|
@subsection Making Selections
|
|
|
|
@noindent
|
|
@kindex j s
|
|
@pindex calc-select-here
|
|
To select a sub-formula, move the Emacs cursor to any character in that
|
|
sub-formula, and press @w{@kbd{j s}} (@code{calc-select-here}). Calc will
|
|
highlight the smallest portion of the formula that contains that
|
|
character. By default the sub-formula is highlighted by blanking out
|
|
all of the rest of the formula with dots. Selection works in any
|
|
display mode but is perhaps easiest in Big mode (@kbd{d B}).
|
|
Suppose you enter the following formula:
|
|
|
|
@smallexample
|
|
@group
|
|
3 ___
|
|
(a + b) + V c
|
|
1: ---------------
|
|
2 x + 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
(by typing @kbd{' ((a+b)^3 + sqrt(c)) / (2x+1)}). If you move the
|
|
cursor to the letter @samp{b} and press @w{@kbd{j s}}, the display changes
|
|
to
|
|
|
|
@smallexample
|
|
@group
|
|
. ...
|
|
.. . b. . . .
|
|
1* ...............
|
|
. . . .
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Every character not part of the sub-formula @samp{b} has been changed
|
|
to a dot. The @samp{*} next to the line number is to remind you that
|
|
the formula has a portion of it selected. (In this case, it's very
|
|
obvious, but it might not always be. If Embedded mode is enabled,
|
|
the word @samp{Sel} also appears in the mode line because the stack
|
|
may not be visible. @pxref{Embedded Mode}.)
|
|
|
|
If you had instead placed the cursor on the parenthesis immediately to
|
|
the right of the @samp{b}, the selection would have been:
|
|
|
|
@smallexample
|
|
@group
|
|
. ...
|
|
(a + b) . . .
|
|
1* ...............
|
|
. . . .
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The portion selected is always large enough to be considered a complete
|
|
formula all by itself, so selecting the parenthesis selects the whole
|
|
formula that it encloses. Putting the cursor on the @samp{+} sign
|
|
would have had the same effect.
|
|
|
|
(Strictly speaking, the Emacs cursor is really the manifestation of
|
|
the Emacs ``point,'' which is a position @emph{between} two characters
|
|
in the buffer. So purists would say that Calc selects the smallest
|
|
sub-formula which contains the character to the right of ``point.'')
|
|
|
|
If you supply a numeric prefix argument @var{n}, the selection is
|
|
expanded to the @var{n}th enclosing sub-formula. Thus, positioning
|
|
the cursor on the @samp{b} and typing @kbd{C-u 1 j s} will select
|
|
@samp{a + b}; typing @kbd{C-u 2 j s} will select @samp{(a + b)^3},
|
|
and so on.
|
|
|
|
If the cursor is not on any part of the formula, or if you give a
|
|
numeric prefix that is too large, the entire formula is selected.
|
|
|
|
If the cursor is on the @samp{.} line that marks the top of the stack
|
|
(i.e., its normal ``rest position''), this command selects the entire
|
|
formula at stack level 1. Most selection commands similarly operate
|
|
on the formula at the top of the stack if you haven't positioned the
|
|
cursor on any stack entry.
|
|
|
|
@kindex j a
|
|
@pindex calc-select-additional
|
|
The @kbd{j a} (@code{calc-select-additional}) command enlarges the
|
|
current selection to encompass the cursor. To select the smallest
|
|
sub-formula defined by two different points, move to the first and
|
|
press @kbd{j s}, then move to the other and press @kbd{j a}. This
|
|
is roughly analogous to using @kbd{C-@@} (@code{set-mark-command}) to
|
|
select the two ends of a region of text during normal Emacs editing.
|
|
|
|
@kindex j o
|
|
@pindex calc-select-once
|
|
The @kbd{j o} (@code{calc-select-once}) command selects a formula in
|
|
exactly the same way as @kbd{j s}, except that the selection will
|
|
last only as long as the next command that uses it. For example,
|
|
@kbd{j o 1 +} is a handy way to add one to the sub-formula indicated
|
|
by the cursor.
|
|
|
|
(A somewhat more precise definition: The @kbd{j o} command sets a flag
|
|
such that the next command involving selected stack entries will clear
|
|
the selections on those stack entries afterwards. All other selection
|
|
commands except @kbd{j a} and @kbd{j O} clear this flag.)
|
|
|
|
@kindex j S
|
|
@kindex j O
|
|
@pindex calc-select-here-maybe
|
|
@pindex calc-select-once-maybe
|
|
The @kbd{j S} (@code{calc-select-here-maybe}) and @kbd{j O}
|
|
(@code{calc-select-once-maybe}) commands are equivalent to @kbd{j s}
|
|
and @kbd{j o}, respectively, except that if the formula already
|
|
has a selection they have no effect. This is analogous to the
|
|
behavior of some commands such as @kbd{j r} (@code{calc-rewrite-selection};
|
|
@pxref{Selections with Rewrite Rules}) and is mainly intended to be
|
|
used in keyboard macros that implement your own selection-oriented
|
|
commands.
|
|
|
|
Selection of sub-formulas normally treats associative terms like
|
|
@samp{a + b - c + d} and @samp{x * y * z} as single levels of the formula.
|
|
If you place the cursor anywhere inside @samp{a + b - c + d} except
|
|
on one of the variable names and use @kbd{j s}, you will select the
|
|
entire four-term sum.
|
|
|
|
@kindex j b
|
|
@pindex calc-break-selections
|
|
The @kbd{j b} (@code{calc-break-selections}) command controls a mode
|
|
in which the ``deep structure'' of these associative formulas shows
|
|
through. Calc actually stores the above formulas as @samp{((a + b) - c) + d}
|
|
and @samp{x * (y * z)}. (Note that for certain obscure reasons, Calc
|
|
treats multiplication as right-associative.) Once you have enabled
|
|
@kbd{j b} mode, selecting with the cursor on the @samp{-} sign would
|
|
only select the @samp{a + b - c} portion, which makes sense when the
|
|
deep structure of the sum is considered. There is no way to select
|
|
the @samp{b - c + d} portion; although this might initially look
|
|
like just as legitimate a sub-formula as @samp{a + b - c}, the deep
|
|
structure shows that it isn't. The @kbd{d U} command can be used
|
|
to view the deep structure of any formula (@pxref{Normal Language Modes}).
|
|
|
|
When @kbd{j b} mode has not been enabled, the deep structure is
|
|
generally hidden by the selection commands---what you see is what
|
|
you get.
|
|
|
|
@kindex j u
|
|
@pindex calc-unselect
|
|
The @kbd{j u} (@code{calc-unselect}) command unselects the formula
|
|
that the cursor is on. If there was no selection in the formula,
|
|
this command has no effect. With a numeric prefix argument, it
|
|
unselects the @var{n}th stack element rather than using the cursor
|
|
position.
|
|
|
|
@kindex j c
|
|
@pindex calc-clear-selections
|
|
The @kbd{j c} (@code{calc-clear-selections}) command unselects all
|
|
stack elements.
|
|
|
|
@node Changing Selections, Displaying Selections, Making Selections, Selecting Subformulas
|
|
@subsection Changing Selections
|
|
|
|
@noindent
|
|
@kindex j m
|
|
@pindex calc-select-more
|
|
Once you have selected a sub-formula, you can expand it using the
|
|
@w{@kbd{j m}} (@code{calc-select-more}) command. If @samp{a + b} is
|
|
selected, pressing @w{@kbd{j m}} repeatedly works as follows:
|
|
|
|
@smallexample
|
|
@group
|
|
3 ... 3 ___ 3 ___
|
|
(a + b) . . . (a + b) + V c (a + b) + V c
|
|
1* ............... 1* ............... 1* ---------------
|
|
. . . . . . . . 2 x + 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
In the last example, the entire formula is selected. This is roughly
|
|
the same as having no selection at all, but because there are subtle
|
|
differences the @samp{*} character is still there on the line number.
|
|
|
|
With a numeric prefix argument @var{n}, @kbd{j m} expands @var{n}
|
|
times (or until the entire formula is selected). Note that @kbd{j s}
|
|
with argument @var{n} is equivalent to plain @kbd{j s} followed by
|
|
@kbd{j m} with argument @var{n}. If @w{@kbd{j m}} is used when there
|
|
is no current selection, it is equivalent to @w{@kbd{j s}}.
|
|
|
|
Even though @kbd{j m} does not explicitly use the location of the
|
|
cursor within the formula, it nevertheless uses the cursor to determine
|
|
which stack element to operate on. As usual, @kbd{j m} when the cursor
|
|
is not on any stack element operates on the top stack element.
|
|
|
|
@kindex j l
|
|
@pindex calc-select-less
|
|
The @kbd{j l} (@code{calc-select-less}) command reduces the current
|
|
selection around the cursor position. That is, it selects the
|
|
immediate sub-formula of the current selection which contains the
|
|
cursor, the opposite of @kbd{j m}. If the cursor is not inside the
|
|
current selection, the command de-selects the formula.
|
|
|
|
@kindex j 1-9
|
|
@pindex calc-select-part
|
|
The @kbd{j 1} through @kbd{j 9} (@code{calc-select-part}) commands
|
|
select the @var{n}th sub-formula of the current selection. They are
|
|
like @kbd{j l} (@code{calc-select-less}) except they use counting
|
|
rather than the cursor position to decide which sub-formula to select.
|
|
For example, if the current selection is @kbd{a + b + c} or
|
|
@kbd{f(a, b, c)} or @kbd{[a, b, c]}, then @kbd{j 1} selects @samp{a},
|
|
@kbd{j 2} selects @samp{b}, and @kbd{j 3} selects @samp{c}; in each of
|
|
these cases, @kbd{j 4} through @kbd{j 9} would be errors.
|
|
|
|
If there is no current selection, @kbd{j 1} through @kbd{j 9} select
|
|
the @var{n}th top-level sub-formula. (In other words, they act as if
|
|
the entire stack entry were selected first.) To select the @var{n}th
|
|
sub-formula where @var{n} is greater than nine, you must instead invoke
|
|
@w{@kbd{j 1}} with @var{n} as a numeric prefix argument.
|
|
|
|
@kindex j n
|
|
@kindex j p
|
|
@pindex calc-select-next
|
|
@pindex calc-select-previous
|
|
The @kbd{j n} (@code{calc-select-next}) and @kbd{j p}
|
|
(@code{calc-select-previous}) commands change the current selection
|
|
to the next or previous sub-formula at the same level. For example,
|
|
if @samp{b} is selected in @w{@samp{2 + a*b*c + x}}, then @kbd{j n}
|
|
selects @samp{c}. Further @kbd{j n} commands would be in error because,
|
|
even though there is something to the right of @samp{c} (namely, @samp{x}),
|
|
it is not at the same level; in this case, it is not a term of the
|
|
same product as @samp{b} and @samp{c}. However, @kbd{j m} (to select
|
|
the whole product @samp{a*b*c} as a term of the sum) followed by
|
|
@w{@kbd{j n}} would successfully select the @samp{x}.
|
|
|
|
Similarly, @kbd{j p} moves the selection from the @samp{b} in this
|
|
sample formula to the @samp{a}. Both commands accept numeric prefix
|
|
arguments to move several steps at a time.
|
|
|
|
It is interesting to compare Calc's selection commands with the
|
|
Emacs Info system's commands for navigating through hierarchically
|
|
organized documentation. Calc's @kbd{j n} command is completely
|
|
analogous to Info's @kbd{n} command. Likewise, @kbd{j p} maps to
|
|
@kbd{p}, @kbd{j 2} maps to @kbd{2}, and Info's @kbd{u} is like @kbd{j m}.
|
|
(Note that @kbd{j u} stands for @code{calc-unselect}, not ``up''.)
|
|
The Info @kbd{m} command is somewhat similar to Calc's @kbd{j s} and
|
|
@kbd{j l}; in each case, you can jump directly to a sub-component
|
|
of the hierarchy simply by pointing to it with the cursor.
|
|
|
|
@node Displaying Selections, Operating on Selections, Changing Selections, Selecting Subformulas
|
|
@subsection Displaying Selections
|
|
|
|
@noindent
|
|
@kindex j d
|
|
@pindex calc-show-selections
|
|
The @kbd{j d} (@code{calc-show-selections}) command controls how
|
|
selected sub-formulas are displayed. One of the alternatives is
|
|
illustrated in the above examples; if we press @kbd{j d} we switch
|
|
to the other style in which the selected portion itself is obscured
|
|
by @samp{#} signs:
|
|
|
|
@smallexample
|
|
@group
|
|
3 ... # ___
|
|
(a + b) . . . ## # ## + V c
|
|
1* ............... 1* ---------------
|
|
. . . . 2 x + 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node Operating on Selections, Rearranging with Selections, Displaying Selections, Selecting Subformulas
|
|
@subsection Operating on Selections
|
|
|
|
@noindent
|
|
Once a selection is made, all Calc commands that manipulate items
|
|
on the stack will operate on the selected portions of the items
|
|
instead. (Note that several stack elements may have selections
|
|
at once, though there can be only one selection at a time in any
|
|
given stack element.)
|
|
|
|
@kindex j e
|
|
@pindex calc-enable-selections
|
|
The @kbd{j e} (@code{calc-enable-selections}) command disables the
|
|
effect that selections have on Calc commands. The current selections
|
|
still exist, but Calc commands operate on whole stack elements anyway.
|
|
This mode can be identified by the fact that the @samp{*} markers on
|
|
the line numbers are gone, even though selections are visible. To
|
|
reactivate the selections, press @kbd{j e} again.
|
|
|
|
To extract a sub-formula as a new formula, simply select the
|
|
sub-formula and press @key{RET}. This normally duplicates the top
|
|
stack element; here it duplicates only the selected portion of that
|
|
element.
|
|
|
|
To replace a sub-formula with something different, you can enter the
|
|
new value onto the stack and press @key{TAB}. This normally exchanges
|
|
the top two stack elements; here it swaps the value you entered into
|
|
the selected portion of the formula, returning the old selected
|
|
portion to the top of the stack.
|
|
|
|
@smallexample
|
|
@group
|
|
3 ... ... ___
|
|
(a + b) . . . 17 x y . . . 17 x y + V c
|
|
2* ............... 2* ............. 2: -------------
|
|
. . . . . . . . 2 x + 1
|
|
|
|
3 3
|
|
1: 17 x y 1: (a + b) 1: (a + b)
|
|
@end group
|
|
@end smallexample
|
|
|
|
In this example we select a sub-formula of our original example,
|
|
enter a new formula, @key{TAB} it into place, then deselect to see
|
|
the complete, edited formula.
|
|
|
|
If you want to swap whole formulas around even though they contain
|
|
selections, just use @kbd{j e} before and after.
|
|
|
|
@kindex j '
|
|
@pindex calc-enter-selection
|
|
The @kbd{j '} (@code{calc-enter-selection}) command is another way
|
|
to replace a selected sub-formula. This command does an algebraic
|
|
entry just like the regular @kbd{'} key. When you press @key{RET},
|
|
the formula you type replaces the original selection. You can use
|
|
the @samp{$} symbol in the formula to refer to the original
|
|
selection. If there is no selection in the formula under the cursor,
|
|
the cursor is used to make a temporary selection for the purposes of
|
|
the command. Thus, to change a term of a formula, all you have to
|
|
do is move the Emacs cursor to that term and press @kbd{j '}.
|
|
|
|
@kindex j `
|
|
@pindex calc-edit-selection
|
|
The @kbd{j `} (@code{calc-edit-selection}) command is a similar
|
|
analogue of the @kbd{`} (@code{calc-edit}) command. It edits the
|
|
selected sub-formula in a separate buffer. If there is no
|
|
selection, it edits the sub-formula indicated by the cursor.
|
|
|
|
To delete a sub-formula, press @key{DEL}. This generally replaces
|
|
the sub-formula with the constant zero, but in a few suitable contexts
|
|
it uses the constant one instead. The @key{DEL} key automatically
|
|
deselects and re-simplifies the entire formula afterwards. Thus:
|
|
|
|
@smallexample
|
|
@group
|
|
###
|
|
17 x y + # # 17 x y 17 # y 17 y
|
|
1* ------------- 1: ------- 1* ------- 1: -------
|
|
2 x + 1 2 x + 1 2 x + 1 2 x + 1
|
|
@end group
|
|
@end smallexample
|
|
|
|
In this example, we first delete the @samp{sqrt(c)} term; Calc
|
|
accomplishes this by replacing @samp{sqrt(c)} with zero and
|
|
resimplifying. We then delete the @kbd{x} in the numerator;
|
|
since this is part of a product, Calc replaces it with @samp{1}
|
|
and resimplifies.
|
|
|
|
If you select an element of a vector and press @key{DEL}, that
|
|
element is deleted from the vector. If you delete one side of
|
|
an equation or inequality, only the opposite side remains.
|
|
|
|
@kindex j @key{DEL}
|
|
@pindex calc-del-selection
|
|
The @kbd{j @key{DEL}} (@code{calc-del-selection}) command is like
|
|
@key{DEL} but with the auto-selecting behavior of @kbd{j '} and
|
|
@kbd{j `}. It deletes the selected portion of the formula
|
|
indicated by the cursor, or, in the absence of a selection, it
|
|
deletes the sub-formula indicated by the cursor position.
|
|
|
|
@kindex j @key{RET}
|
|
@pindex calc-grab-selection
|
|
(There is also an auto-selecting @kbd{j @key{RET}} (@code{calc-copy-selection})
|
|
command.)
|
|
|
|
Normal arithmetic operations also apply to sub-formulas. Here we
|
|
select the denominator, press @kbd{5 -} to subtract five from the
|
|
denominator, press @kbd{n} to negate the denominator, then
|
|
press @kbd{Q} to take the square root.
|
|
|
|
@smallexample
|
|
@group
|
|
.. . .. . .. . .. .
|
|
1* ....... 1* ....... 1* ....... 1* ..........
|
|
2 x + 1 2 x - 4 4 - 2 x _________
|
|
V 4 - 2 x
|
|
@end group
|
|
@end smallexample
|
|
|
|
Certain types of operations on selections are not allowed. For
|
|
example, for an arithmetic function like @kbd{-} no more than one of
|
|
the arguments may be a selected sub-formula. (As the above example
|
|
shows, the result of the subtraction is spliced back into the argument
|
|
which had the selection; if there were more than one selection involved,
|
|
this would not be well-defined.) If you try to subtract two selections,
|
|
the command will abort with an error message.
|
|
|
|
Operations on sub-formulas sometimes leave the formula as a whole
|
|
in an ``un-natural'' state. Consider negating the @samp{2 x} term
|
|
of our sample formula by selecting it and pressing @kbd{n}
|
|
(@code{calc-change-sign}).
|
|
|
|
@smallexample
|
|
@group
|
|
.. . .. .
|
|
1* .......... 1* ...........
|
|
......... ..........
|
|
. . . 2 x . . . -2 x
|
|
@end group
|
|
@end smallexample
|
|
|
|
Unselecting the sub-formula reveals that the minus sign, which would
|
|
normally have cancelled out with the subtraction automatically, has
|
|
not been able to do so because the subtraction was not part of the
|
|
selected portion. Pressing @kbd{=} (@code{calc-evaluate}) or doing
|
|
any other mathematical operation on the whole formula will cause it
|
|
to be simplified.
|
|
|
|
@smallexample
|
|
@group
|
|
17 y 17 y
|
|
1: ----------- 1: ----------
|
|
__________ _________
|
|
V 4 - -2 x V 4 + 2 x
|
|
@end group
|
|
@end smallexample
|
|
|
|
@node Rearranging with Selections, , Operating on Selections, Selecting Subformulas
|
|
@subsection Rearranging Formulas using Selections
|
|
|
|
@noindent
|
|
@kindex j R
|
|
@pindex calc-commute-right
|
|
The @kbd{j R} (@code{calc-commute-right}) command moves the selected
|
|
sub-formula to the right in its surrounding formula. Generally the
|
|
selection is one term of a sum or product; the sum or product is
|
|
rearranged according to the commutative laws of algebra.
|
|
|
|
As with @kbd{j '} and @kbd{j @key{DEL}}, the term under the cursor is used
|
|
if there is no selection in the current formula. All commands described
|
|
in this section share this property. In this example, we place the
|
|
cursor on the @samp{a} and type @kbd{j R}, then repeat.
|
|
|
|
@smallexample
|
|
1: a + b - c 1: b + a - c 1: b - c + a
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that in the final step above, the @samp{a} is switched with
|
|
the @samp{c} but the signs are adjusted accordingly. When moving
|
|
terms of sums and products, @kbd{j R} will never change the
|
|
mathematical meaning of the formula.
|
|
|
|
The selected term may also be an element of a vector or an argument
|
|
of a function. The term is exchanged with the one to its right.
|
|
In this case, the ``meaning'' of the vector or function may of
|
|
course be drastically changed.
|
|
|
|
@smallexample
|
|
1: [a, b, c] 1: [b, a, c] 1: [b, c, a]
|
|
|
|
1: f(a, b, c) 1: f(b, a, c) 1: f(b, c, a)
|
|
@end smallexample
|
|
|
|
@kindex j L
|
|
@pindex calc-commute-left
|
|
The @kbd{j L} (@code{calc-commute-left}) command is like @kbd{j R}
|
|
except that it swaps the selected term with the one to its left.
|
|
|
|
With numeric prefix arguments, these commands move the selected
|
|
term several steps at a time. It is an error to try to move a
|
|
term left or right past the end of its enclosing formula.
|
|
With numeric prefix arguments of zero, these commands move the
|
|
selected term as far as possible in the given direction.
|
|
|
|
@kindex j D
|
|
@pindex calc-sel-distribute
|
|
The @kbd{j D} (@code{calc-sel-distribute}) command mixes the selected
|
|
sum or product into the surrounding formula using the distributive
|
|
law. For example, in @samp{a * (b - c)} with the @samp{b - c}
|
|
selected, the result is @samp{a b - a c}. This also distributes
|
|
products or quotients into surrounding powers, and can also do
|
|
transformations like @samp{exp(a + b)} to @samp{exp(a) exp(b)},
|
|
where @samp{a + b} is the selected term, and @samp{ln(a ^ b)}
|
|
to @samp{ln(a) b}, where @samp{a ^ b} is the selected term.
|
|
|
|
For multiple-term sums or products, @kbd{j D} takes off one term
|
|
at a time: @samp{a * (b + c - d)} goes to @samp{a * (c - d) + a b}
|
|
with the @samp{c - d} selected so that you can type @kbd{j D}
|
|
repeatedly to expand completely. The @kbd{j D} command allows a
|
|
numeric prefix argument which specifies the maximum number of
|
|
times to expand at once; the default is one time only.
|
|
|
|
@vindex DistribRules
|
|
The @kbd{j D} command is implemented using rewrite rules.
|
|
@xref{Selections with Rewrite Rules}. The rules are stored in
|
|
the Calc variable @code{DistribRules}. A convenient way to view
|
|
these rules is to use @kbd{s e} (@code{calc-edit-variable}) which
|
|
displays and edits the stored value of a variable. Press @kbd{C-c C-c}
|
|
to return from editing mode; be careful not to make any actual changes
|
|
or else you will affect the behavior of future @kbd{j D} commands!
|
|
|
|
To extend @kbd{j D} to handle new cases, just edit @code{DistribRules}
|
|
as described above. You can then use the @kbd{s p} command to save
|
|
this variable's value permanently for future Calc sessions.
|
|
@xref{Operations on Variables}.
|
|
|
|
@kindex j M
|
|
@pindex calc-sel-merge
|
|
@vindex MergeRules
|
|
The @kbd{j M} (@code{calc-sel-merge}) command is the complement
|
|
of @kbd{j D}; given @samp{a b - a c} with either @samp{a b} or
|
|
@samp{a c} selected, the result is @samp{a * (b - c)}. Once
|
|
again, @kbd{j M} can also merge calls to functions like @code{exp}
|
|
and @code{ln}; examine the variable @code{MergeRules} to see all
|
|
the relevant rules.
|
|
|
|
@kindex j C
|
|
@pindex calc-sel-commute
|
|
@vindex CommuteRules
|
|
The @kbd{j C} (@code{calc-sel-commute}) command swaps the arguments
|
|
of the selected sum, product, or equation. It always behaves as
|
|
if @kbd{j b} mode were in effect, i.e., the sum @samp{a + b + c} is
|
|
treated as the nested sums @samp{(a + b) + c} by this command.
|
|
If you put the cursor on the first @samp{+}, the result is
|
|
@samp{(b + a) + c}; if you put the cursor on the second @samp{+}, the
|
|
result is @samp{c + (a + b)} (which the default simplifications
|
|
will rearrange to @samp{(c + a) + b}). The relevant rules are stored
|
|
in the variable @code{CommuteRules}.
|
|
|
|
You may need to turn default simplifications off (with the @kbd{m O}
|
|
command) in order to get the full benefit of @kbd{j C}. For example,
|
|
commuting @samp{a - b} produces @samp{-b + a}, but the default
|
|
simplifications will ``simplify'' this right back to @samp{a - b} if
|
|
you don't turn them off. The same is true of some of the other
|
|
manipulations described in this section.
|
|
|
|
@kindex j N
|
|
@pindex calc-sel-negate
|
|
@vindex NegateRules
|
|
The @kbd{j N} (@code{calc-sel-negate}) command replaces the selected
|
|
term with the negative of that term, then adjusts the surrounding
|
|
formula in order to preserve the meaning. For example, given
|
|
@samp{exp(a - b)} where @samp{a - b} is selected, the result is
|
|
@samp{1 / exp(b - a)}. By contrast, selecting a term and using the
|
|
regular @kbd{n} (@code{calc-change-sign}) command negates the
|
|
term without adjusting the surroundings, thus changing the meaning
|
|
of the formula as a whole. The rules variable is @code{NegateRules}.
|
|
|
|
@kindex j &
|
|
@pindex calc-sel-invert
|
|
@vindex InvertRules
|
|
The @kbd{j &} (@code{calc-sel-invert}) command is similar to @kbd{j N}
|
|
except it takes the reciprocal of the selected term. For example,
|
|
given @samp{a - ln(b)} with @samp{b} selected, the result is
|
|
@samp{a + ln(1/b)}. The rules variable is @code{InvertRules}.
|
|
|
|
@kindex j E
|
|
@pindex calc-sel-jump-equals
|
|
@vindex JumpRules
|
|
The @kbd{j E} (@code{calc-sel-jump-equals}) command moves the
|
|
selected term from one side of an equation to the other. Given
|
|
@samp{a + b = c + d} with @samp{c} selected, the result is
|
|
@samp{a + b - c = d}. This command also works if the selected
|
|
term is part of a @samp{*}, @samp{/}, or @samp{^} formula. The
|
|
relevant rules variable is @code{JumpRules}.
|
|
|
|
@kindex j I
|
|
@kindex H j I
|
|
@pindex calc-sel-isolate
|
|
The @kbd{j I} (@code{calc-sel-isolate}) command isolates the
|
|
selected term on its side of an equation. It uses the @kbd{a S}
|
|
(@code{calc-solve-for}) command to solve the equation, and the
|
|
Hyperbolic flag affects it in the same way. @xref{Solving Equations}.
|
|
When it applies, @kbd{j I} is often easier to use than @kbd{j E}.
|
|
It understands more rules of algebra, and works for inequalities
|
|
as well as equations.
|
|
|
|
@kindex j *
|
|
@kindex j /
|
|
@pindex calc-sel-mult-both-sides
|
|
@pindex calc-sel-div-both-sides
|
|
The @kbd{j *} (@code{calc-sel-mult-both-sides}) command prompts for a
|
|
formula using algebraic entry, then multiplies both sides of the
|
|
selected quotient or equation by that formula. It simplifies each
|
|
side with @kbd{a s} (@code{calc-simplify}) before re-forming the
|
|
quotient or equation. You can suppress this simplification by
|
|
providing any numeric prefix argument. There is also a @kbd{j /}
|
|
(@code{calc-sel-div-both-sides}) which is similar to @kbd{j *} but
|
|
dividing instead of multiplying by the factor you enter.
|
|
|
|
As a special feature, if the numerator of the quotient is 1, then
|
|
the denominator is expanded at the top level using the distributive
|
|
law (i.e., using the @kbd{C-u -1 a x} command). Suppose the
|
|
formula on the stack is @samp{1 / (sqrt(a) + 1)}, and you wish
|
|
to eliminate the square root in the denominator by multiplying both
|
|
sides by @samp{sqrt(a) - 1}. Calc's default simplifications would
|
|
change the result @samp{(sqrt(a) - 1) / (sqrt(a) - 1) (sqrt(a) + 1)}
|
|
right back to the original form by cancellation; Calc expands the
|
|
denominator to @samp{sqrt(a) (sqrt(a) - 1) + sqrt(a) - 1} to prevent
|
|
this. (You would now want to use an @kbd{a x} command to expand
|
|
the rest of the way, whereupon the denominator would cancel out to
|
|
the desired form, @samp{a - 1}.) When the numerator is not 1, this
|
|
initial expansion is not necessary because Calc's default
|
|
simplifications will not notice the potential cancellation.
|
|
|
|
If the selection is an inequality, @kbd{j *} and @kbd{j /} will
|
|
accept any factor, but will warn unless they can prove the factor
|
|
is either positive or negative. (In the latter case the direction
|
|
of the inequality will be switched appropriately.) @xref{Declarations},
|
|
for ways to inform Calc that a given variable is positive or
|
|
negative. If Calc can't tell for sure what the sign of the factor
|
|
will be, it will assume it is positive and display a warning
|
|
message.
|
|
|
|
For selections that are not quotients, equations, or inequalities,
|
|
these commands pull out a multiplicative factor: They divide (or
|
|
multiply) by the entered formula, simplify, then multiply (or divide)
|
|
back by the formula.
|
|
|
|
@kindex j +
|
|
@kindex j -
|
|
@pindex calc-sel-add-both-sides
|
|
@pindex calc-sel-sub-both-sides
|
|
The @kbd{j +} (@code{calc-sel-add-both-sides}) and @kbd{j -}
|
|
(@code{calc-sel-sub-both-sides}) commands analogously add to or
|
|
subtract from both sides of an equation or inequality. For other
|
|
types of selections, they extract an additive factor. A numeric
|
|
prefix argument suppresses simplification of the intermediate
|
|
results.
|
|
|
|
@kindex j U
|
|
@pindex calc-sel-unpack
|
|
The @kbd{j U} (@code{calc-sel-unpack}) command replaces the
|
|
selected function call with its argument. For example, given
|
|
@samp{a + sin(x^2)} with @samp{sin(x^2)} selected, the result
|
|
is @samp{a + x^2}. (The @samp{x^2} will remain selected; if you
|
|
wanted to change the @code{sin} to @code{cos}, just press @kbd{C}
|
|
now to take the cosine of the selected part.)
|
|
|
|
@kindex j v
|
|
@pindex calc-sel-evaluate
|
|
The @kbd{j v} (@code{calc-sel-evaluate}) command performs the
|
|
normal default simplifications on the selected sub-formula.
|
|
These are the simplifications that are normally done automatically
|
|
on all results, but which may have been partially inhibited by
|
|
previous selection-related operations, or turned off altogether
|
|
by the @kbd{m O} command. This command is just an auto-selecting
|
|
version of the @w{@kbd{a v}} command (@pxref{Algebraic Manipulation}).
|
|
|
|
With a numeric prefix argument of 2, @kbd{C-u 2 j v} applies
|
|
the @kbd{a s} (@code{calc-simplify}) command to the selected
|
|
sub-formula. With a prefix argument of 3 or more, e.g., @kbd{C-u j v}
|
|
applies the @kbd{a e} (@code{calc-simplify-extended}) command.
|
|
@xref{Simplifying Formulas}. With a negative prefix argument
|
|
it simplifies at the top level only, just as with @kbd{a v}.
|
|
Here the ``top'' level refers to the top level of the selected
|
|
sub-formula.
|
|
|
|
@kindex j "
|
|
@pindex calc-sel-expand-formula
|
|
The @kbd{j "} (@code{calc-sel-expand-formula}) command is to @kbd{a "}
|
|
(@pxref{Algebraic Manipulation}) what @kbd{j v} is to @kbd{a v}.
|
|
|
|
You can use the @kbd{j r} (@code{calc-rewrite-selection}) command
|
|
to define other algebraic operations on sub-formulas. @xref{Rewrite Rules}.
|
|
|
|
@node Algebraic Manipulation, Simplifying Formulas, Selecting Subformulas, Algebra
|
|
@section Algebraic Manipulation
|
|
|
|
@noindent
|
|
The commands in this section perform general-purpose algebraic
|
|
manipulations. They work on the whole formula at the top of the
|
|
stack (unless, of course, you have made a selection in that
|
|
formula).
|
|
|
|
Many algebra commands prompt for a variable name or formula. If you
|
|
answer the prompt with a blank line, the variable or formula is taken
|
|
from top-of-stack, and the normal argument for the command is taken
|
|
from the second-to-top stack level.
|
|
|
|
@kindex a v
|
|
@pindex calc-alg-evaluate
|
|
The @kbd{a v} (@code{calc-alg-evaluate}) command performs the normal
|
|
default simplifications on a formula; for example, @samp{a - -b} is
|
|
changed to @samp{a + b}. These simplifications are normally done
|
|
automatically on all Calc results, so this command is useful only if
|
|
you have turned default simplifications off with an @kbd{m O}
|
|
command. @xref{Simplification Modes}.
|
|
|
|
It is often more convenient to type @kbd{=}, which is like @kbd{a v}
|
|
but which also substitutes stored values for variables in the formula.
|
|
Use @kbd{a v} if you want the variables to ignore their stored values.
|
|
|
|
If you give a numeric prefix argument of 2 to @kbd{a v}, it simplifies
|
|
as if in Algebraic Simplification mode. This is equivalent to typing
|
|
@kbd{a s}; @pxref{Simplifying Formulas}. If you give a numeric prefix
|
|
of 3 or more, it uses Extended Simplification mode (@kbd{a e}).
|
|
|
|
If you give a negative prefix argument @mathit{-1}, @mathit{-2}, or @mathit{-3},
|
|
it simplifies in the corresponding mode but only works on the top-level
|
|
function call of the formula. For example, @samp{(2 + 3) * (2 + 3)} will
|
|
simplify to @samp{(2 + 3)^2}, without simplifying the sub-formulas
|
|
@samp{2 + 3}. As another example, typing @kbd{V R +} to sum the vector
|
|
@samp{[1, 2, 3, 4]} produces the formula @samp{reduce(add, [1, 2, 3, 4])}
|
|
in No-Simplify mode. Using @kbd{a v} will evaluate this all the way to
|
|
10; using @kbd{C-u - a v} will evaluate it only to @samp{1 + 2 + 3 + 4}.
|
|
(@xref{Reducing and Mapping}.)
|
|
|
|
@tindex evalv
|
|
@tindex evalvn
|
|
The @kbd{=} command corresponds to the @code{evalv} function, and
|
|
the related @kbd{N} command, which is like @kbd{=} but temporarily
|
|
disables Symbolic mode (@kbd{m s}) during the evaluation, corresponds
|
|
to the @code{evalvn} function. (These commands interpret their prefix
|
|
arguments differently than @kbd{a v}; @kbd{=} treats the prefix as
|
|
the number of stack elements to evaluate at once, and @kbd{N} treats
|
|
it as a temporary different working precision.)
|
|
|
|
The @code{evalvn} function can take an alternate working precision
|
|
as an optional second argument. This argument can be either an
|
|
integer, to set the precision absolutely, or a vector containing
|
|
a single integer, to adjust the precision relative to the current
|
|
precision. Note that @code{evalvn} with a larger than current
|
|
precision will do the calculation at this higher precision, but the
|
|
result will as usual be rounded back down to the current precision
|
|
afterward. For example, @samp{evalvn(pi - 3.1415)} at a precision
|
|
of 12 will return @samp{9.265359e-5}; @samp{evalvn(pi - 3.1415, 30)}
|
|
will return @samp{9.26535897932e-5} (computing a 25-digit result which
|
|
is then rounded down to 12); and @samp{evalvn(pi - 3.1415, [-2])}
|
|
will return @samp{9.2654e-5}.
|
|
|
|
@kindex a "
|
|
@pindex calc-expand-formula
|
|
The @kbd{a "} (@code{calc-expand-formula}) command expands functions
|
|
into their defining formulas wherever possible. For example,
|
|
@samp{deg(x^2)} is changed to @samp{180 x^2 / pi}. Most functions,
|
|
like @code{sin} and @code{gcd}, are not defined by simple formulas
|
|
and so are unaffected by this command. One important class of
|
|
functions which @emph{can} be expanded is the user-defined functions
|
|
created by the @kbd{Z F} command. @xref{Algebraic Definitions}.
|
|
Other functions which @kbd{a "} can expand include the probability
|
|
distribution functions, most of the financial functions, and the
|
|
hyperbolic and inverse hyperbolic functions. A numeric prefix argument
|
|
affects @kbd{a "} in the same way as it does @kbd{a v}: A positive
|
|
argument expands all functions in the formula and then simplifies in
|
|
various ways; a negative argument expands and simplifies only the
|
|
top-level function call.
|
|
|
|
@kindex a M
|
|
@pindex calc-map-equation
|
|
@tindex mapeq
|
|
The @kbd{a M} (@code{calc-map-equation}) [@code{mapeq}] command applies
|
|
a given function or operator to one or more equations. It is analogous
|
|
to @kbd{V M}, which operates on vectors instead of equations.
|
|
@pxref{Reducing and Mapping}. For example, @kbd{a M S} changes
|
|
@samp{x = y+1} to @samp{sin(x) = sin(y+1)}, and @kbd{a M +} with
|
|
@samp{x = y+1} and @expr{6} on the stack produces @samp{x+6 = y+7}.
|
|
With two equations on the stack, @kbd{a M +} would add the lefthand
|
|
sides together and the righthand sides together to get the two
|
|
respective sides of a new equation.
|
|
|
|
Mapping also works on inequalities. Mapping two similar inequalities
|
|
produces another inequality of the same type. Mapping an inequality
|
|
with an equation produces an inequality of the same type. Mapping a
|
|
@samp{<=} with a @samp{<} or @samp{!=} (not-equal) produces a @samp{<}.
|
|
If inequalities with opposite direction (e.g., @samp{<} and @samp{>})
|
|
are mapped, the direction of the second inequality is reversed to
|
|
match the first: Using @kbd{a M +} on @samp{a < b} and @samp{a > 2}
|
|
reverses the latter to get @samp{2 < a}, which then allows the
|
|
combination @samp{a + 2 < b + a}, which the @kbd{a s} command can
|
|
then simplify to get @samp{2 < b}.
|
|
|
|
Using @kbd{a M *}, @kbd{a M /}, @kbd{a M n}, or @kbd{a M &} to negate
|
|
or invert an inequality will reverse the direction of the inequality.
|
|
Other adjustments to inequalities are @emph{not} done automatically;
|
|
@kbd{a M S} will change @w{@samp{x < y}} to @samp{sin(x) < sin(y)} even
|
|
though this is not true for all values of the variables.
|
|
|
|
@kindex H a M
|
|
@tindex mapeqp
|
|
With the Hyperbolic flag, @kbd{H a M} [@code{mapeqp}] does a plain
|
|
mapping operation without reversing the direction of any inequalities.
|
|
Thus, @kbd{H a M &} would change @kbd{x > 2} to @kbd{1/x > 0.5}.
|
|
(This change is mathematically incorrect, but perhaps you were
|
|
fixing an inequality which was already incorrect.)
|
|
|
|
@kindex I a M
|
|
@tindex mapeqr
|
|
With the Inverse flag, @kbd{I a M} [@code{mapeqr}] always reverses
|
|
the direction of the inequality. You might use @kbd{I a M C} to
|
|
change @samp{x < y} to @samp{cos(x) > cos(y)} if you know you are
|
|
working with small positive angles.
|
|
|
|
@kindex a b
|
|
@pindex calc-substitute
|
|
@tindex subst
|
|
The @kbd{a b} (@code{calc-substitute}) [@code{subst}] command substitutes
|
|
all occurrences
|
|
of some variable or sub-expression of an expression with a new
|
|
sub-expression. For example, substituting @samp{sin(x)} with @samp{cos(y)}
|
|
in @samp{2 sin(x)^2 + x sin(x) + sin(2 x)} produces
|
|
@samp{2 cos(y)^2 + x cos(y) + @w{sin(2 x)}}.
|
|
Note that this is a purely structural substitution; the lone @samp{x} and
|
|
the @samp{sin(2 x)} stayed the same because they did not look like
|
|
@samp{sin(x)}. @xref{Rewrite Rules}, for a more general method for
|
|
doing substitutions.
|
|
|
|
The @kbd{a b} command normally prompts for two formulas, the old
|
|
one and the new one. If you enter a blank line for the first
|
|
prompt, all three arguments are taken from the stack (new, then old,
|
|
then target expression). If you type an old formula but then enter a
|
|
blank line for the new one, the new formula is taken from top-of-stack
|
|
and the target from second-to-top. If you answer both prompts, the
|
|
target is taken from top-of-stack as usual.
|
|
|
|
Note that @kbd{a b} has no understanding of commutativity or
|
|
associativity. The pattern @samp{x+y} will not match the formula
|
|
@samp{y+x}. Also, @samp{y+z} will not match inside the formula @samp{x+y+z}
|
|
because the @samp{+} operator is left-associative, so the ``deep
|
|
structure'' of that formula is @samp{(x+y) + z}. Use @kbd{d U}
|
|
(@code{calc-unformatted-language}) mode to see the true structure of
|
|
a formula. The rewrite rule mechanism, discussed later, does not have
|
|
these limitations.
|
|
|
|
As an algebraic function, @code{subst} takes three arguments:
|
|
Target expression, old, new. Note that @code{subst} is always
|
|
evaluated immediately, even if its arguments are variables, so if
|
|
you wish to put a call to @code{subst} onto the stack you must
|
|
turn the default simplifications off first (with @kbd{m O}).
|
|
|
|
@node Simplifying Formulas, Polynomials, Algebraic Manipulation, Algebra
|
|
@section Simplifying Formulas
|
|
|
|
@noindent
|
|
@kindex a s
|
|
@pindex calc-simplify
|
|
@tindex simplify
|
|
The @kbd{a s} (@code{calc-simplify}) [@code{simplify}] command applies
|
|
various algebraic rules to simplify a formula. This includes rules which
|
|
are not part of the default simplifications because they may be too slow
|
|
to apply all the time, or may not be desirable all of the time. For
|
|
example, non-adjacent terms of sums are combined, as in @samp{a + b + 2 a}
|
|
to @samp{b + 3 a}, and some formulas like @samp{sin(arcsin(x))} are
|
|
simplified to @samp{x}.
|
|
|
|
The sections below describe all the various kinds of algebraic
|
|
simplifications Calc provides in full detail. None of Calc's
|
|
simplification commands are designed to pull rabbits out of hats;
|
|
they simply apply certain specific rules to put formulas into
|
|
less redundant or more pleasing forms. Serious algebra in Calc
|
|
must be done manually, usually with a combination of selections
|
|
and rewrite rules. @xref{Rearranging with Selections}.
|
|
@xref{Rewrite Rules}.
|
|
|
|
@xref{Simplification Modes}, for commands to control what level of
|
|
simplification occurs automatically. Normally only the ``default
|
|
simplifications'' occur.
|
|
|
|
@menu
|
|
* Default Simplifications::
|
|
* Algebraic Simplifications::
|
|
* Unsafe Simplifications::
|
|
* Simplification of Units::
|
|
@end menu
|
|
|
|
@node Default Simplifications, Algebraic Simplifications, Simplifying Formulas, Simplifying Formulas
|
|
@subsection Default Simplifications
|
|
|
|
@noindent
|
|
@cindex Default simplifications
|
|
This section describes the ``default simplifications,'' those which are
|
|
normally applied to all results. For example, if you enter the variable
|
|
@expr{x} on the stack twice and push @kbd{+}, Calc's default
|
|
simplifications automatically change @expr{x + x} to @expr{2 x}.
|
|
|
|
The @kbd{m O} command turns off the default simplifications, so that
|
|
@expr{x + x} will remain in this form unless you give an explicit
|
|
``simplify'' command like @kbd{=} or @kbd{a v}. @xref{Algebraic
|
|
Manipulation}. The @kbd{m D} command turns the default simplifications
|
|
back on.
|
|
|
|
The most basic default simplification is the evaluation of functions.
|
|
For example, @expr{2 + 3} is evaluated to @expr{5}, and @expr{@tfn{sqrt}(9)}
|
|
is evaluated to @expr{3}. Evaluation does not occur if the arguments
|
|
to a function are somehow of the wrong type @expr{@tfn{tan}([2,3,4])}),
|
|
range (@expr{@tfn{tan}(90)}), or number (@expr{@tfn{tan}(3,5)}),
|
|
or if the function name is not recognized (@expr{@tfn{f}(5)}), or if
|
|
Symbolic mode (@pxref{Symbolic Mode}) prevents evaluation
|
|
(@expr{@tfn{sqrt}(2)}).
|
|
|
|
Calc simplifies (evaluates) the arguments to a function before it
|
|
simplifies the function itself. Thus @expr{@tfn{sqrt}(5+4)} is
|
|
simplified to @expr{@tfn{sqrt}(9)} before the @code{sqrt} function
|
|
itself is applied. There are very few exceptions to this rule:
|
|
@code{quote}, @code{lambda}, and @code{condition} (the @code{::}
|
|
operator) do not evaluate their arguments, @code{if} (the @code{? :}
|
|
operator) does not evaluate all of its arguments, and @code{evalto}
|
|
does not evaluate its lefthand argument.
|
|
|
|
Most commands apply the default simplifications to all arguments they
|
|
take from the stack, perform a particular operation, then simplify
|
|
the result before pushing it back on the stack. In the common special
|
|
case of regular arithmetic commands like @kbd{+} and @kbd{Q} [@code{sqrt}],
|
|
the arguments are simply popped from the stack and collected into a
|
|
suitable function call, which is then simplified (the arguments being
|
|
simplified first as part of the process, as described above).
|
|
|
|
The default simplifications are too numerous to describe completely
|
|
here, but this section will describe the ones that apply to the
|
|
major arithmetic operators. This list will be rather technical in
|
|
nature, and will probably be interesting to you only if you are
|
|
a serious user of Calc's algebra facilities.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
As well as the simplifications described here, if you have stored
|
|
any rewrite rules in the variable @code{EvalRules} then these rules
|
|
will also be applied before any built-in default simplifications.
|
|
@xref{Automatic Rewrites}, for details.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
And now, on with the default simplifications:
|
|
|
|
Arithmetic operators like @kbd{+} and @kbd{*} always take two
|
|
arguments in Calc's internal form. Sums and products of three or
|
|
more terms are arranged by the associative law of algebra into
|
|
a left-associative form for sums, @expr{((a + b) + c) + d}, and
|
|
a right-associative form for products, @expr{a * (b * (c * d))}.
|
|
Formulas like @expr{(a + b) + (c + d)} are rearranged to
|
|
left-associative form, though this rarely matters since Calc's
|
|
algebra commands are designed to hide the inner structure of
|
|
sums and products as much as possible. Sums and products in
|
|
their proper associative form will be written without parentheses
|
|
in the examples below.
|
|
|
|
Sums and products are @emph{not} rearranged according to the
|
|
commutative law (@expr{a + b} to @expr{b + a}) except in a few
|
|
special cases described below. Some algebra programs always
|
|
rearrange terms into a canonical order, which enables them to
|
|
see that @expr{a b + b a} can be simplified to @expr{2 a b}.
|
|
Calc assumes you have put the terms into the order you want
|
|
and generally leaves that order alone, with the consequence
|
|
that formulas like the above will only be simplified if you
|
|
explicitly give the @kbd{a s} command. @xref{Algebraic
|
|
Simplifications}.
|
|
|
|
Differences @expr{a - b} are treated like sums @expr{a + (-b)}
|
|
for purposes of simplification; one of the default simplifications
|
|
is to rewrite @expr{a + (-b)} or @expr{(-b) + a}, where @expr{-b}
|
|
represents a ``negative-looking'' term, into @expr{a - b} form.
|
|
``Negative-looking'' means negative numbers, negated formulas like
|
|
@expr{-x}, and products or quotients in which either term is
|
|
negative-looking.
|
|
|
|
Other simplifications involving negation are @expr{-(-x)} to @expr{x};
|
|
@expr{-(a b)} or @expr{-(a/b)} where either @expr{a} or @expr{b} is
|
|
negative-looking, simplified by negating that term, or else where
|
|
@expr{a} or @expr{b} is any number, by negating that number;
|
|
@expr{-(a + b)} to @expr{-a - b}, and @expr{-(b - a)} to @expr{a - b}.
|
|
(This, and rewriting @expr{(-b) + a} to @expr{a - b}, are the only
|
|
cases where the order of terms in a sum is changed by the default
|
|
simplifications.)
|
|
|
|
The distributive law is used to simplify sums in some cases:
|
|
@expr{a x + b x} to @expr{(a + b) x}, where @expr{a} represents
|
|
a number or an implicit 1 or @mathit{-1} (as in @expr{x} or @expr{-x})
|
|
and similarly for @expr{b}. Use the @kbd{a c}, @w{@kbd{a f}}, or
|
|
@kbd{j M} commands to merge sums with non-numeric coefficients
|
|
using the distributive law.
|
|
|
|
The distributive law is only used for sums of two terms, or
|
|
for adjacent terms in a larger sum. Thus @expr{a + b + b + c}
|
|
is simplified to @expr{a + 2 b + c}, but @expr{a + b + c + b}
|
|
is not simplified. The reason is that comparing all terms of a
|
|
sum with one another would require time proportional to the
|
|
square of the number of terms; Calc relegates potentially slow
|
|
operations like this to commands that have to be invoked
|
|
explicitly, like @kbd{a s}.
|
|
|
|
Finally, @expr{a + 0} and @expr{0 + a} are simplified to @expr{a}.
|
|
A consequence of the above rules is that @expr{0 - a} is simplified
|
|
to @expr{-a}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The products @expr{1 a} and @expr{a 1} are simplified to @expr{a};
|
|
@expr{(-1) a} and @expr{a (-1)} are simplified to @expr{-a};
|
|
@expr{0 a} and @expr{a 0} are simplified to @expr{0}, except that
|
|
in Matrix mode where @expr{a} is not provably scalar the result
|
|
is the generic zero matrix @samp{idn(0)}, and that if @expr{a} is
|
|
infinite the result is @samp{nan}.
|
|
|
|
Also, @expr{(-a) b} and @expr{a (-b)} are simplified to @expr{-(a b)},
|
|
where this occurs for negated formulas but not for regular negative
|
|
numbers.
|
|
|
|
Products are commuted only to move numbers to the front:
|
|
@expr{a b 2} is commuted to @expr{2 a b}.
|
|
|
|
The product @expr{a (b + c)} is distributed over the sum only if
|
|
@expr{a} and at least one of @expr{b} and @expr{c} are numbers:
|
|
@expr{2 (x + 3)} goes to @expr{2 x + 6}. The formula
|
|
@expr{(-a) (b - c)}, where @expr{-a} is a negative number, is
|
|
rewritten to @expr{a (c - b)}.
|
|
|
|
The distributive law of products and powers is used for adjacent
|
|
terms of the product: @expr{x^a x^b} goes to
|
|
@texline @math{x^{a+b}}
|
|
@infoline @expr{x^(a+b)}
|
|
where @expr{a} is a number, or an implicit 1 (as in @expr{x}),
|
|
or the implicit one-half of @expr{@tfn{sqrt}(x)}, and similarly for
|
|
@expr{b}. The result is written using @samp{sqrt} or @samp{1/sqrt}
|
|
if the sum of the powers is @expr{1/2} or @expr{-1/2}, respectively.
|
|
If the sum of the powers is zero, the product is simplified to
|
|
@expr{1} or to @samp{idn(1)} if Matrix mode is enabled.
|
|
|
|
The product of a negative power times anything but another negative
|
|
power is changed to use division:
|
|
@texline @math{x^{-2} y}
|
|
@infoline @expr{x^(-2) y}
|
|
goes to @expr{y / x^2} unless Matrix mode is
|
|
in effect and neither @expr{x} nor @expr{y} are scalar (in which
|
|
case it is considered unsafe to rearrange the order of the terms).
|
|
|
|
Finally, @expr{a (b/c)} is rewritten to @expr{(a b)/c}, and also
|
|
@expr{(a/b) c} is changed to @expr{(a c)/b} unless in Matrix mode.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Simplifications for quotients are analogous to those for products.
|
|
The quotient @expr{0 / x} is simplified to @expr{0}, with the same
|
|
exceptions that were noted for @expr{0 x}. Likewise, @expr{x / 1}
|
|
and @expr{x / (-1)} are simplified to @expr{x} and @expr{-x},
|
|
respectively.
|
|
|
|
The quotient @expr{x / 0} is left unsimplified or changed to an
|
|
infinite quantity, as directed by the current infinite mode.
|
|
@xref{Infinite Mode}.
|
|
|
|
The expression
|
|
@texline @math{a / b^{-c}}
|
|
@infoline @expr{a / b^(-c)}
|
|
is changed to @expr{a b^c}, where @expr{-c} is any negative-looking
|
|
power. Also, @expr{1 / b^c} is changed to
|
|
@texline @math{b^{-c}}
|
|
@infoline @expr{b^(-c)}
|
|
for any power @expr{c}.
|
|
|
|
Also, @expr{(-a) / b} and @expr{a / (-b)} go to @expr{-(a/b)};
|
|
@expr{(a/b) / c} goes to @expr{a / (b c)}; and @expr{a / (b/c)}
|
|
goes to @expr{(a c) / b} unless Matrix mode prevents this
|
|
rearrangement. Similarly, @expr{a / (b:c)} is simplified to
|
|
@expr{(c:b) a} for any fraction @expr{b:c}.
|
|
|
|
The distributive law is applied to @expr{(a + b) / c} only if
|
|
@expr{c} and at least one of @expr{a} and @expr{b} are numbers.
|
|
Quotients of powers and square roots are distributed just as
|
|
described for multiplication.
|
|
|
|
Quotients of products cancel only in the leading terms of the
|
|
numerator and denominator. In other words, @expr{a x b / a y b}
|
|
is cancelled to @expr{x b / y b} but not to @expr{x / y}. Once
|
|
again this is because full cancellation can be slow; use @kbd{a s}
|
|
to cancel all terms of the quotient.
|
|
|
|
Quotients of negative-looking values are simplified according
|
|
to @expr{(-a) / (-b)} to @expr{a / b}, @expr{(-a) / (b - c)}
|
|
to @expr{a / (c - b)}, and @expr{(a - b) / (-c)} to @expr{(b - a) / c}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The formula @expr{x^0} is simplified to @expr{1}, or to @samp{idn(1)}
|
|
in Matrix mode. The formula @expr{0^x} is simplified to @expr{0}
|
|
unless @expr{x} is a negative number, complex number or zero.
|
|
If @expr{x} is negative, complex or @expr{0.0}, @expr{0^x} is an
|
|
infinity or an unsimplified formula according to the current infinite
|
|
mode. The expression @expr{0^0} is simplified to @expr{1}.
|
|
|
|
Powers of products or quotients @expr{(a b)^c}, @expr{(a/b)^c}
|
|
are distributed to @expr{a^c b^c}, @expr{a^c / b^c} only if @expr{c}
|
|
is an integer, or if either @expr{a} or @expr{b} are nonnegative
|
|
real numbers. Powers of powers @expr{(a^b)^c} are simplified to
|
|
@texline @math{a^{b c}}
|
|
@infoline @expr{a^(b c)}
|
|
only when @expr{c} is an integer and @expr{b c} also
|
|
evaluates to an integer. Without these restrictions these simplifications
|
|
would not be safe because of problems with principal values.
|
|
(In other words,
|
|
@texline @math{((-3)^{1/2})^2}
|
|
@infoline @expr{((-3)^1:2)^2}
|
|
is safe to simplify, but
|
|
@texline @math{((-3)^2)^{1/2}}
|
|
@infoline @expr{((-3)^2)^1:2}
|
|
is not.) @xref{Declarations}, for ways to inform Calc that your
|
|
variables satisfy these requirements.
|
|
|
|
As a special case of this rule, @expr{@tfn{sqrt}(x)^n} is simplified to
|
|
@texline @math{x^{n/2}}
|
|
@infoline @expr{x^(n/2)}
|
|
only for even integers @expr{n}.
|
|
|
|
If @expr{a} is known to be real, @expr{b} is an even integer, and
|
|
@expr{c} is a half- or quarter-integer, then @expr{(a^b)^c} is
|
|
simplified to @expr{@tfn{abs}(a^(b c))}.
|
|
|
|
Also, @expr{(-a)^b} is simplified to @expr{a^b} if @expr{b} is an
|
|
even integer, or to @expr{-(a^b)} if @expr{b} is an odd integer,
|
|
for any negative-looking expression @expr{-a}.
|
|
|
|
Square roots @expr{@tfn{sqrt}(x)} generally act like one-half powers
|
|
@texline @math{x^{1:2}}
|
|
@infoline @expr{x^1:2}
|
|
for the purposes of the above-listed simplifications.
|
|
|
|
Also, note that
|
|
@texline @math{1 / x^{1:2}}
|
|
@infoline @expr{1 / x^1:2}
|
|
is changed to
|
|
@texline @math{x^{-1:2}},
|
|
@infoline @expr{x^(-1:2)},
|
|
but @expr{1 / @tfn{sqrt}(x)} is left alone.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Generic identity matrices (@pxref{Matrix Mode}) are simplified by the
|
|
following rules: @expr{@tfn{idn}(a) + b} to @expr{a + b} if @expr{b}
|
|
is provably scalar, or expanded out if @expr{b} is a matrix;
|
|
@expr{@tfn{idn}(a) + @tfn{idn}(b)} to @expr{@tfn{idn}(a + b)};
|
|
@expr{-@tfn{idn}(a)} to @expr{@tfn{idn}(-a)}; @expr{a @tfn{idn}(b)} to
|
|
@expr{@tfn{idn}(a b)} if @expr{a} is provably scalar, or to @expr{a b}
|
|
if @expr{a} is provably non-scalar; @expr{@tfn{idn}(a) @tfn{idn}(b)} to
|
|
@expr{@tfn{idn}(a b)}; analogous simplifications for quotients involving
|
|
@code{idn}; and @expr{@tfn{idn}(a)^n} to @expr{@tfn{idn}(a^n)} where
|
|
@expr{n} is an integer.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The @code{floor} function and other integer truncation functions
|
|
vanish if the argument is provably integer-valued, so that
|
|
@expr{@tfn{floor}(@tfn{round}(x))} simplifies to @expr{@tfn{round}(x)}.
|
|
Also, combinations of @code{float}, @code{floor} and its friends,
|
|
and @code{ffloor} and its friends, are simplified in appropriate
|
|
ways. @xref{Integer Truncation}.
|
|
|
|
The expression @expr{@tfn{abs}(-x)} changes to @expr{@tfn{abs}(x)}.
|
|
The expression @expr{@tfn{abs}(@tfn{abs}(x))} changes to
|
|
@expr{@tfn{abs}(x)}; in fact, @expr{@tfn{abs}(x)} changes to @expr{x} or
|
|
@expr{-x} if @expr{x} is provably nonnegative or nonpositive
|
|
(@pxref{Declarations}).
|
|
|
|
While most functions do not recognize the variable @code{i} as an
|
|
imaginary number, the @code{arg} function does handle the two cases
|
|
@expr{@tfn{arg}(@tfn{i})} and @expr{@tfn{arg}(-@tfn{i})} just for convenience.
|
|
|
|
The expression @expr{@tfn{conj}(@tfn{conj}(x))} simplifies to @expr{x}.
|
|
Various other expressions involving @code{conj}, @code{re}, and
|
|
@code{im} are simplified, especially if some of the arguments are
|
|
provably real or involve the constant @code{i}. For example,
|
|
@expr{@tfn{conj}(a + b i)} is changed to
|
|
@expr{@tfn{conj}(a) - @tfn{conj}(b) i}, or to @expr{a - b i} if @expr{a}
|
|
and @expr{b} are known to be real.
|
|
|
|
Functions like @code{sin} and @code{arctan} generally don't have
|
|
any default simplifications beyond simply evaluating the functions
|
|
for suitable numeric arguments and infinity. The @kbd{a s} command
|
|
described in the next section does provide some simplifications for
|
|
these functions, though.
|
|
|
|
One important simplification that does occur is that
|
|
@expr{@tfn{ln}(@tfn{e})} is simplified to 1, and @expr{@tfn{ln}(@tfn{e}^x)} is
|
|
simplified to @expr{x} for any @expr{x}. This occurs even if you have
|
|
stored a different value in the Calc variable @samp{e}; but this would
|
|
be a bad idea in any case if you were also using natural logarithms!
|
|
|
|
Among the logical functions, @tfn{!(@var{a} <= @var{b})} changes to
|
|
@tfn{@var{a} > @var{b}} and so on. Equations and inequalities where both sides
|
|
are either negative-looking or zero are simplified by negating both sides
|
|
and reversing the inequality. While it might seem reasonable to simplify
|
|
@expr{!!x} to @expr{x}, this would not be valid in general because
|
|
@expr{!!2} is 1, not 2.
|
|
|
|
Most other Calc functions have few if any default simplifications
|
|
defined, aside of course from evaluation when the arguments are
|
|
suitable numbers.
|
|
|
|
@node Algebraic Simplifications, Unsafe Simplifications, Default Simplifications, Simplifying Formulas
|
|
@subsection Algebraic Simplifications
|
|
|
|
@noindent
|
|
@cindex Algebraic simplifications
|
|
The @kbd{a s} command makes simplifications that may be too slow to
|
|
do all the time, or that may not be desirable all of the time.
|
|
If you find these simplifications are worthwhile, you can type
|
|
@kbd{m A} to have Calc apply them automatically.
|
|
|
|
This section describes all simplifications that are performed by
|
|
the @kbd{a s} command. Note that these occur in addition to the
|
|
default simplifications; even if the default simplifications have
|
|
been turned off by an @kbd{m O} command, @kbd{a s} will turn them
|
|
back on temporarily while it simplifies the formula.
|
|
|
|
There is a variable, @code{AlgSimpRules}, in which you can put rewrites
|
|
to be applied by @kbd{a s}. Its use is analogous to @code{EvalRules},
|
|
but without the special restrictions. Basically, the simplifier does
|
|
@samp{@w{a r} AlgSimpRules} with an infinite repeat count on the whole
|
|
expression being simplified, then it traverses the expression applying
|
|
the built-in rules described below. If the result is different from
|
|
the original expression, the process repeats with the default
|
|
simplifications (including @code{EvalRules}), then @code{AlgSimpRules},
|
|
then the built-in simplifications, and so on.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Sums are simplified in two ways. Constant terms are commuted to the
|
|
end of the sum, so that @expr{a + 2 + b} changes to @expr{a + b + 2}.
|
|
The only exception is that a constant will not be commuted away
|
|
from the first position of a difference, i.e., @expr{2 - x} is not
|
|
commuted to @expr{-x + 2}.
|
|
|
|
Also, terms of sums are combined by the distributive law, as in
|
|
@expr{x + y + 2 x} to @expr{y + 3 x}. This always occurs for
|
|
adjacent terms, but @kbd{a s} compares all pairs of terms including
|
|
non-adjacent ones.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Products are sorted into a canonical order using the commutative
|
|
law. For example, @expr{b c a} is commuted to @expr{a b c}.
|
|
This allows easier comparison of products; for example, the default
|
|
simplifications will not change @expr{x y + y x} to @expr{2 x y},
|
|
but @kbd{a s} will; it first rewrites the sum to @expr{x y + x y},
|
|
and then the default simplifications are able to recognize a sum
|
|
of identical terms.
|
|
|
|
The canonical ordering used to sort terms of products has the
|
|
property that real-valued numbers, interval forms and infinities
|
|
come first, and are sorted into increasing order. The @kbd{V S}
|
|
command uses the same ordering when sorting a vector.
|
|
|
|
Sorting of terms of products is inhibited when Matrix mode is
|
|
turned on; in this case, Calc will never exchange the order of
|
|
two terms unless it knows at least one of the terms is a scalar.
|
|
|
|
Products of powers are distributed by comparing all pairs of
|
|
terms, using the same method that the default simplifications
|
|
use for adjacent terms of products.
|
|
|
|
Even though sums are not sorted, the commutative law is still
|
|
taken into account when terms of a product are being compared.
|
|
Thus @expr{(x + y) (y + x)} will be simplified to @expr{(x + y)^2}.
|
|
A subtle point is that @expr{(x - y) (y - x)} will @emph{not}
|
|
be simplified to @expr{-(x - y)^2}; Calc does not notice that
|
|
one term can be written as a constant times the other, even if
|
|
that constant is @mathit{-1}.
|
|
|
|
A fraction times any expression, @expr{(a:b) x}, is changed to
|
|
a quotient involving integers: @expr{a x / b}. This is not
|
|
done for floating-point numbers like @expr{0.5}, however. This
|
|
is one reason why you may find it convenient to turn Fraction mode
|
|
on while doing algebra; @pxref{Fraction Mode}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Quotients are simplified by comparing all terms in the numerator
|
|
with all terms in the denominator for possible cancellation using
|
|
the distributive law. For example, @expr{a x^2 b / c x^3 d} will
|
|
cancel @expr{x^2} from the top and bottom to get @expr{a b / c x d}.
|
|
(The terms in the denominator will then be rearranged to @expr{c d x}
|
|
as described above.) If there is any common integer or fractional
|
|
factor in the numerator and denominator, it is cancelled out;
|
|
for example, @expr{(4 x + 6) / 8 x} simplifies to @expr{(2 x + 3) / 4 x}.
|
|
|
|
Non-constant common factors are not found even by @kbd{a s}. To
|
|
cancel the factor @expr{a} in @expr{(a x + a) / a^2} you could first
|
|
use @kbd{j M} on the product @expr{a x} to Merge the numerator to
|
|
@expr{a (1+x)}, which can then be simplified successfully.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Integer powers of the variable @code{i} are simplified according
|
|
to the identity @expr{i^2 = -1}. If you store a new value other
|
|
than the complex number @expr{(0,1)} in @code{i}, this simplification
|
|
will no longer occur. This is done by @kbd{a s} instead of by default
|
|
in case someone (unwisely) uses the name @code{i} for a variable
|
|
unrelated to complex numbers; it would be unfortunate if Calc
|
|
quietly and automatically changed this formula for reasons the
|
|
user might not have been thinking of.
|
|
|
|
Square roots of integer or rational arguments are simplified in
|
|
several ways. (Note that these will be left unevaluated only in
|
|
Symbolic mode.) First, square integer or rational factors are
|
|
pulled out so that @expr{@tfn{sqrt}(8)} is rewritten as
|
|
@texline @math{2\,@tfn{sqrt}(2)}.
|
|
@infoline @expr{2 sqrt(2)}.
|
|
Conceptually speaking this implies factoring the argument into primes
|
|
and moving pairs of primes out of the square root, but for reasons of
|
|
efficiency Calc only looks for primes up to 29.
|
|
|
|
Square roots in the denominator of a quotient are moved to the
|
|
numerator: @expr{1 / @tfn{sqrt}(3)} changes to @expr{@tfn{sqrt}(3) / 3}.
|
|
The same effect occurs for the square root of a fraction:
|
|
@expr{@tfn{sqrt}(2:3)} changes to @expr{@tfn{sqrt}(6) / 3}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The @code{%} (modulo) operator is simplified in several ways
|
|
when the modulus @expr{M} is a positive real number. First, if
|
|
the argument is of the form @expr{x + n} for some real number
|
|
@expr{n}, then @expr{n} is itself reduced modulo @expr{M}. For
|
|
example, @samp{(x - 23) % 10} is simplified to @samp{(x + 7) % 10}.
|
|
|
|
If the argument is multiplied by a constant, and this constant
|
|
has a common integer divisor with the modulus, then this factor is
|
|
cancelled out. For example, @samp{12 x % 15} is changed to
|
|
@samp{3 (4 x % 5)} by factoring out 3. Also, @samp{(12 x + 1) % 15}
|
|
is changed to @samp{3 ((4 x + 1:3) % 5)}. While these forms may
|
|
not seem ``simpler,'' they allow Calc to discover useful information
|
|
about modulo forms in the presence of declarations.
|
|
|
|
If the modulus is 1, then Calc can use @code{int} declarations to
|
|
evaluate the expression. For example, the idiom @samp{x % 2} is
|
|
often used to check whether a number is odd or even. As described
|
|
above, @w{@samp{2 n % 2}} and @samp{(2 n + 1) % 2} are simplified to
|
|
@samp{2 (n % 1)} and @samp{2 ((n + 1:2) % 1)}, respectively; Calc
|
|
can simplify these to 0 and 1 (respectively) if @code{n} has been
|
|
declared to be an integer.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Trigonometric functions are simplified in several ways. Whenever a
|
|
products of two trigonometric functions can be replaced by a single
|
|
function, the replacement is made; for example,
|
|
@expr{@tfn{tan}(x) @tfn{cos}(x)} is simplified to @expr{@tfn{sin}(x)}.
|
|
Reciprocals of trigonometric functions are replaced by their reciprocal
|
|
function; for example, @expr{1/@tfn{sec}(x)} is simplified to
|
|
@expr{@tfn{cos}(x)}. The corresponding simplifications for the
|
|
hyperbolic functions are also handled.
|
|
|
|
Trigonometric functions of their inverse functions are
|
|
simplified. The expression @expr{@tfn{sin}(@tfn{arcsin}(x))} is
|
|
simplified to @expr{x}, and similarly for @code{cos} and @code{tan}.
|
|
Trigonometric functions of inverses of different trigonometric
|
|
functions can also be simplified, as in @expr{@tfn{sin}(@tfn{arccos}(x))}
|
|
to @expr{@tfn{sqrt}(1 - x^2)}.
|
|
|
|
If the argument to @code{sin} is negative-looking, it is simplified to
|
|
@expr{-@tfn{sin}(x)}, and similarly for @code{cos} and @code{tan}.
|
|
Finally, certain special values of the argument are recognized;
|
|
@pxref{Trigonometric and Hyperbolic Functions}.
|
|
|
|
Hyperbolic functions of their inverses and of negative-looking
|
|
arguments are also handled, as are exponentials of inverse
|
|
hyperbolic functions.
|
|
|
|
No simplifications for inverse trigonometric and hyperbolic
|
|
functions are known, except for negative arguments of @code{arcsin},
|
|
@code{arctan}, @code{arcsinh}, and @code{arctanh}. Note that
|
|
@expr{@tfn{arcsin}(@tfn{sin}(x))} can @emph{not} safely change to
|
|
@expr{x}, since this only correct within an integer multiple of
|
|
@texline @math{2 \pi}
|
|
@infoline @expr{2 pi}
|
|
radians or 360 degrees. However, @expr{@tfn{arcsinh}(@tfn{sinh}(x))} is
|
|
simplified to @expr{x} if @expr{x} is known to be real.
|
|
|
|
Several simplifications that apply to logarithms and exponentials
|
|
are that @expr{@tfn{exp}(@tfn{ln}(x))},
|
|
@texline @tfn{e}@math{^{\ln(x)}},
|
|
@infoline @expr{e^@tfn{ln}(x)},
|
|
and
|
|
@texline @math{10^{{\rm log10}(x)}}
|
|
@infoline @expr{10^@tfn{log10}(x)}
|
|
all reduce to @expr{x}. Also, @expr{@tfn{ln}(@tfn{exp}(x))}, etc., can
|
|
reduce to @expr{x} if @expr{x} is provably real. The form
|
|
@expr{@tfn{exp}(x)^y} is simplified to @expr{@tfn{exp}(x y)}. If @expr{x}
|
|
is a suitable multiple of
|
|
@texline @math{\pi i}
|
|
@infoline @expr{pi i}
|
|
(as described above for the trigonometric functions), then
|
|
@expr{@tfn{exp}(x)} or @expr{e^x} will be expanded. Finally,
|
|
@expr{@tfn{ln}(x)} is simplified to a form involving @code{pi} and
|
|
@code{i} where @expr{x} is provably negative, positive imaginary, or
|
|
negative imaginary.
|
|
|
|
The error functions @code{erf} and @code{erfc} are simplified when
|
|
their arguments are negative-looking or are calls to the @code{conj}
|
|
function.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Equations and inequalities are simplified by cancelling factors
|
|
of products, quotients, or sums on both sides. Inequalities
|
|
change sign if a negative multiplicative factor is cancelled.
|
|
Non-constant multiplicative factors as in @expr{a b = a c} are
|
|
cancelled from equations only if they are provably nonzero (generally
|
|
because they were declared so; @pxref{Declarations}). Factors
|
|
are cancelled from inequalities only if they are nonzero and their
|
|
sign is known.
|
|
|
|
Simplification also replaces an equation or inequality with
|
|
1 or 0 (``true'' or ``false'') if it can through the use of
|
|
declarations. If @expr{x} is declared to be an integer greater
|
|
than 5, then @expr{x < 3}, @expr{x = 3}, and @expr{x = 7.5} are
|
|
all simplified to 0, but @expr{x > 3} is simplified to 1.
|
|
By a similar analysis, @expr{abs(x) >= 0} is simplified to 1,
|
|
as is @expr{x^2 >= 0} if @expr{x} is known to be real.
|
|
|
|
@node Unsafe Simplifications, Simplification of Units, Algebraic Simplifications, Simplifying Formulas
|
|
@subsection ``Unsafe'' Simplifications
|
|
|
|
@noindent
|
|
@cindex Unsafe simplifications
|
|
@cindex Extended simplification
|
|
@kindex a e
|
|
@pindex calc-simplify-extended
|
|
@ignore
|
|
@mindex esimpl@idots
|
|
@end ignore
|
|
@tindex esimplify
|
|
The @kbd{a e} (@code{calc-simplify-extended}) [@code{esimplify}] command
|
|
is like @kbd{a s}
|
|
except that it applies some additional simplifications which are not
|
|
``safe'' in all cases. Use this only if you know the values in your
|
|
formula lie in the restricted ranges for which these simplifications
|
|
are valid. The symbolic integrator uses @kbd{a e};
|
|
one effect of this is that the integrator's results must be used with
|
|
caution. Where an integral table will often attach conditions like
|
|
``for positive @expr{a} only,'' Calc (like most other symbolic
|
|
integration programs) will simply produce an unqualified result.
|
|
|
|
Because @kbd{a e}'s simplifications are unsafe, it is sometimes better
|
|
to type @kbd{C-u -3 a v}, which does extended simplification only
|
|
on the top level of the formula without affecting the sub-formulas.
|
|
In fact, @kbd{C-u -3 j v} allows you to target extended simplification
|
|
to any specific part of a formula.
|
|
|
|
The variable @code{ExtSimpRules} contains rewrites to be applied by
|
|
the @kbd{a e} command. These are applied in addition to
|
|
@code{EvalRules} and @code{AlgSimpRules}. (The @kbd{a r AlgSimpRules}
|
|
step described above is simply followed by an @kbd{a r ExtSimpRules} step.)
|
|
|
|
Following is a complete list of ``unsafe'' simplifications performed
|
|
by @kbd{a e}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Inverse trigonometric or hyperbolic functions, called with their
|
|
corresponding non-inverse functions as arguments, are simplified
|
|
by @kbd{a e}. For example, @expr{@tfn{arcsin}(@tfn{sin}(x))} changes
|
|
to @expr{x}. Also, @expr{@tfn{arcsin}(@tfn{cos}(x))} and
|
|
@expr{@tfn{arccos}(@tfn{sin}(x))} both change to @expr{@tfn{pi}/2 - x}.
|
|
These simplifications are unsafe because they are valid only for
|
|
values of @expr{x} in a certain range; outside that range, values
|
|
are folded down to the 360-degree range that the inverse trigonometric
|
|
functions always produce.
|
|
|
|
Powers of powers @expr{(x^a)^b} are simplified to
|
|
@texline @math{x^{a b}}
|
|
@infoline @expr{x^(a b)}
|
|
for all @expr{a} and @expr{b}. These results will be valid only
|
|
in a restricted range of @expr{x}; for example, in
|
|
@texline @math{(x^2)^{1:2}}
|
|
@infoline @expr{(x^2)^1:2}
|
|
the powers cancel to get @expr{x}, which is valid for positive values
|
|
of @expr{x} but not for negative or complex values.
|
|
|
|
Similarly, @expr{@tfn{sqrt}(x^a)} and @expr{@tfn{sqrt}(x)^a} are both
|
|
simplified (possibly unsafely) to
|
|
@texline @math{x^{a/2}}.
|
|
@infoline @expr{x^(a/2)}.
|
|
|
|
Forms like @expr{@tfn{sqrt}(1 - sin(x)^2)} are simplified to, e.g.,
|
|
@expr{@tfn{cos}(x)}. Calc has identities of this sort for @code{sin},
|
|
@code{cos}, @code{tan}, @code{sinh}, and @code{cosh}.
|
|
|
|
Arguments of square roots are partially factored to look for
|
|
squared terms that can be extracted. For example,
|
|
@expr{@tfn{sqrt}(a^2 b^3 + a^3 b^2)} simplifies to
|
|
@expr{a b @tfn{sqrt}(a+b)}.
|
|
|
|
The simplifications of @expr{@tfn{ln}(@tfn{exp}(x))},
|
|
@expr{@tfn{ln}(@tfn{e}^x)}, and @expr{@tfn{log10}(10^x)} to @expr{x} are also
|
|
unsafe because of problems with principal values (although these
|
|
simplifications are safe if @expr{x} is known to be real).
|
|
|
|
Common factors are cancelled from products on both sides of an
|
|
equation, even if those factors may be zero: @expr{a x / b x}
|
|
to @expr{a / b}. Such factors are never cancelled from
|
|
inequalities: Even @kbd{a e} is not bold enough to reduce
|
|
@expr{a x < b x} to @expr{a < b} (or @expr{a > b}, depending
|
|
on whether you believe @expr{x} is positive or negative).
|
|
The @kbd{a M /} command can be used to divide a factor out of
|
|
both sides of an inequality.
|
|
|
|
@node Simplification of Units, , Unsafe Simplifications, Simplifying Formulas
|
|
@subsection Simplification of Units
|
|
|
|
@noindent
|
|
The simplifications described in this section are applied by the
|
|
@kbd{u s} (@code{calc-simplify-units}) command. These are in addition
|
|
to the regular @kbd{a s} (but not @kbd{a e}) simplifications described
|
|
earlier. @xref{Basic Operations on Units}.
|
|
|
|
The variable @code{UnitSimpRules} contains rewrites to be applied by
|
|
the @kbd{u s} command. These are applied in addition to @code{EvalRules}
|
|
and @code{AlgSimpRules}.
|
|
|
|
Scalar mode is automatically put into effect when simplifying units.
|
|
@xref{Matrix Mode}.
|
|
|
|
Sums @expr{a + b} involving units are simplified by extracting the
|
|
units of @expr{a} as if by the @kbd{u x} command (call the result
|
|
@expr{u_a}), then simplifying the expression @expr{b / u_a}
|
|
using @kbd{u b} and @kbd{u s}. If the result has units then the sum
|
|
is inconsistent and is left alone. Otherwise, it is rewritten
|
|
in terms of the units @expr{u_a}.
|
|
|
|
If units auto-ranging mode is enabled, products or quotients in
|
|
which the first argument is a number which is out of range for the
|
|
leading unit are modified accordingly.
|
|
|
|
When cancelling and combining units in products and quotients,
|
|
Calc accounts for unit names that differ only in the prefix letter.
|
|
For example, @samp{2 km m} is simplified to @samp{2000 m^2}.
|
|
However, compatible but different units like @code{ft} and @code{in}
|
|
are not combined in this way.
|
|
|
|
Quotients @expr{a / b} are simplified in three additional ways. First,
|
|
if @expr{b} is a number or a product beginning with a number, Calc
|
|
computes the reciprocal of this number and moves it to the numerator.
|
|
|
|
Second, for each pair of unit names from the numerator and denominator
|
|
of a quotient, if the units are compatible (e.g., they are both
|
|
units of area) then they are replaced by the ratio between those
|
|
units. For example, in @samp{3 s in N / kg cm} the units
|
|
@samp{in / cm} will be replaced by @expr{2.54}.
|
|
|
|
Third, if the units in the quotient exactly cancel out, so that
|
|
a @kbd{u b} command on the quotient would produce a dimensionless
|
|
number for an answer, then the quotient simplifies to that number.
|
|
|
|
For powers and square roots, the ``unsafe'' simplifications
|
|
@expr{(a b)^c} to @expr{a^c b^c}, @expr{(a/b)^c} to @expr{a^c / b^c},
|
|
and @expr{(a^b)^c} to
|
|
@texline @math{a^{b c}}
|
|
@infoline @expr{a^(b c)}
|
|
are done if the powers are real numbers. (These are safe in the context
|
|
of units because all numbers involved can reasonably be assumed to be
|
|
real.)
|
|
|
|
Also, if a unit name is raised to a fractional power, and the
|
|
base units in that unit name all occur to powers which are a
|
|
multiple of the denominator of the power, then the unit name
|
|
is expanded out into its base units, which can then be simplified
|
|
according to the previous paragraph. For example, @samp{acre^1.5}
|
|
is simplified by noting that @expr{1.5 = 3:2}, that @samp{acre}
|
|
is defined in terms of @samp{m^2}, and that the 2 in the power of
|
|
@code{m} is a multiple of 2 in @expr{3:2}. Thus, @code{acre^1.5} is
|
|
replaced by approximately
|
|
@texline @math{(4046 m^2)^{1.5}}
|
|
@infoline @expr{(4046 m^2)^1.5},
|
|
which is then changed to
|
|
@texline @math{4046^{1.5} \, (m^2)^{1.5}},
|
|
@infoline @expr{4046^1.5 (m^2)^1.5},
|
|
then to @expr{257440 m^3}.
|
|
|
|
The functions @code{float}, @code{frac}, @code{clean}, @code{abs},
|
|
as well as @code{floor} and the other integer truncation functions,
|
|
applied to unit names or products or quotients involving units, are
|
|
simplified. For example, @samp{round(1.6 in)} is changed to
|
|
@samp{round(1.6) round(in)}; the lefthand term evaluates to 2,
|
|
and the righthand term simplifies to @code{in}.
|
|
|
|
The functions @code{sin}, @code{cos}, and @code{tan} with arguments
|
|
that have angular units like @code{rad} or @code{arcmin} are
|
|
simplified by converting to base units (radians), then evaluating
|
|
with the angular mode temporarily set to radians.
|
|
|
|
@node Polynomials, Calculus, Simplifying Formulas, Algebra
|
|
@section Polynomials
|
|
|
|
A @dfn{polynomial} is a sum of terms which are coefficients times
|
|
various powers of a ``base'' variable. For example, @expr{2 x^2 + 3 x - 4}
|
|
is a polynomial in @expr{x}. Some formulas can be considered
|
|
polynomials in several different variables: @expr{1 + 2 x + 3 y + 4 x y^2}
|
|
is a polynomial in both @expr{x} and @expr{y}. Polynomial coefficients
|
|
are often numbers, but they may in general be any formulas not
|
|
involving the base variable.
|
|
|
|
@kindex a f
|
|
@pindex calc-factor
|
|
@tindex factor
|
|
The @kbd{a f} (@code{calc-factor}) [@code{factor}] command factors a
|
|
polynomial into a product of terms. For example, the polynomial
|
|
@expr{x^3 + 2 x^2 + x} is factored into @samp{x*(x+1)^2}. As another
|
|
example, @expr{a c + b d + b c + a d} is factored into the product
|
|
@expr{(a + b) (c + d)}.
|
|
|
|
Calc currently has three algorithms for factoring. Formulas which are
|
|
linear in several variables, such as the second example above, are
|
|
merged according to the distributive law. Formulas which are
|
|
polynomials in a single variable, with constant integer or fractional
|
|
coefficients, are factored into irreducible linear and/or quadratic
|
|
terms. The first example above factors into three linear terms
|
|
(@expr{x}, @expr{x+1}, and @expr{x+1} again). Finally, formulas
|
|
which do not fit the above criteria are handled by the algebraic
|
|
rewrite mechanism.
|
|
|
|
Calc's polynomial factorization algorithm works by using the general
|
|
root-finding command (@w{@kbd{a P}}) to solve for the roots of the
|
|
polynomial. It then looks for roots which are rational numbers
|
|
or complex-conjugate pairs, and converts these into linear and
|
|
quadratic terms, respectively. Because it uses floating-point
|
|
arithmetic, it may be unable to find terms that involve large
|
|
integers (whose number of digits approaches the current precision).
|
|
Also, irreducible factors of degree higher than quadratic are not
|
|
found, and polynomials in more than one variable are not treated.
|
|
(A more robust factorization algorithm may be included in a future
|
|
version of Calc.)
|
|
|
|
@vindex FactorRules
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex thecoefs
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@tindex thefactors
|
|
The rewrite-based factorization method uses rules stored in the variable
|
|
@code{FactorRules}. @xref{Rewrite Rules}, for a discussion of the
|
|
operation of rewrite rules. The default @code{FactorRules} are able
|
|
to factor quadratic forms symbolically into two linear terms,
|
|
@expr{(a x + b) (c x + d)}. You can edit these rules to include other
|
|
cases if you wish. To use the rules, Calc builds the formula
|
|
@samp{thecoefs(x, [a, b, c, ...])} where @code{x} is the polynomial
|
|
base variable and @code{a}, @code{b}, etc., are polynomial coefficients
|
|
(which may be numbers or formulas). The constant term is written first,
|
|
i.e., in the @code{a} position. When the rules complete, they should have
|
|
changed the formula into the form @samp{thefactors(x, [f1, f2, f3, ...])}
|
|
where each @code{fi} should be a factored term, e.g., @samp{x - ai}.
|
|
Calc then multiplies these terms together to get the complete
|
|
factored form of the polynomial. If the rules do not change the
|
|
@code{thecoefs} call to a @code{thefactors} call, @kbd{a f} leaves the
|
|
polynomial alone on the assumption that it is unfactorable. (Note that
|
|
the function names @code{thecoefs} and @code{thefactors} are used only
|
|
as placeholders; there are no actual Calc functions by those names.)
|
|
|
|
@kindex H a f
|
|
@tindex factors
|
|
The @kbd{H a f} [@code{factors}] command also factors a polynomial,
|
|
but it returns a list of factors instead of an expression which is the
|
|
product of the factors. Each factor is represented by a sub-vector
|
|
of the factor, and the power with which it appears. For example,
|
|
@expr{x^5 + x^4 - 33 x^3 + 63 x^2} factors to @expr{(x + 7) x^2 (x - 3)^2}
|
|
in @kbd{a f}, or to @expr{[ [x, 2], [x+7, 1], [x-3, 2] ]} in @kbd{H a f}.
|
|
If there is an overall numeric factor, it always comes first in the list.
|
|
The functions @code{factor} and @code{factors} allow a second argument
|
|
when written in algebraic form; @samp{factor(x,v)} factors @expr{x} with
|
|
respect to the specific variable @expr{v}. The default is to factor with
|
|
respect to all the variables that appear in @expr{x}.
|
|
|
|
@kindex a c
|
|
@pindex calc-collect
|
|
@tindex collect
|
|
The @kbd{a c} (@code{calc-collect}) [@code{collect}] command rearranges a
|
|
formula as a
|
|
polynomial in a given variable, ordered in decreasing powers of that
|
|
variable. For example, given @expr{1 + 2 x + 3 y + 4 x y^2} on
|
|
the stack, @kbd{a c x} would produce @expr{(2 + 4 y^2) x + (1 + 3 y)},
|
|
and @kbd{a c y} would produce @expr{(4 x) y^2 + 3 y + (1 + 2 x)}.
|
|
The polynomial will be expanded out using the distributive law as
|
|
necessary: Collecting @expr{x} in @expr{(x - 1)^3} produces
|
|
@expr{x^3 - 3 x^2 + 3 x - 1}. Terms not involving @expr{x} will
|
|
not be expanded.
|
|
|
|
The ``variable'' you specify at the prompt can actually be any
|
|
expression: @kbd{a c ln(x+1)} will collect together all terms multiplied
|
|
by @samp{ln(x+1)} or integer powers thereof. If @samp{x} also appears
|
|
in the formula in a context other than @samp{ln(x+1)}, @kbd{a c} will
|
|
treat those occurrences as unrelated to @samp{ln(x+1)}, i.e., as constants.
|
|
|
|
@kindex a x
|
|
@pindex calc-expand
|
|
@tindex expand
|
|
The @kbd{a x} (@code{calc-expand}) [@code{expand}] command expands an
|
|
expression by applying the distributive law everywhere. It applies to
|
|
products, quotients, and powers involving sums. By default, it fully
|
|
distributes all parts of the expression. With a numeric prefix argument,
|
|
the distributive law is applied only the specified number of times, then
|
|
the partially expanded expression is left on the stack.
|
|
|
|
The @kbd{a x} and @kbd{j D} commands are somewhat redundant. Use
|
|
@kbd{a x} if you want to expand all products of sums in your formula.
|
|
Use @kbd{j D} if you want to expand a particular specified term of
|
|
the formula. There is an exactly analogous correspondence between
|
|
@kbd{a f} and @kbd{j M}. (The @kbd{j D} and @kbd{j M} commands
|
|
also know many other kinds of expansions, such as
|
|
@samp{exp(a + b) = exp(a) exp(b)}, which @kbd{a x} and @kbd{a f}
|
|
do not do.)
|
|
|
|
Calc's automatic simplifications will sometimes reverse a partial
|
|
expansion. For example, the first step in expanding @expr{(x+1)^3} is
|
|
to write @expr{(x+1) (x+1)^2}. If @kbd{a x} stops there and tries
|
|
to put this formula onto the stack, though, Calc will automatically
|
|
simplify it back to @expr{(x+1)^3} form. The solution is to turn
|
|
simplification off first (@pxref{Simplification Modes}), or to run
|
|
@kbd{a x} without a numeric prefix argument so that it expands all
|
|
the way in one step.
|
|
|
|
@kindex a a
|
|
@pindex calc-apart
|
|
@tindex apart
|
|
The @kbd{a a} (@code{calc-apart}) [@code{apart}] command expands a
|
|
rational function by partial fractions. A rational function is the
|
|
quotient of two polynomials; @code{apart} pulls this apart into a
|
|
sum of rational functions with simple denominators. In algebraic
|
|
notation, the @code{apart} function allows a second argument that
|
|
specifies which variable to use as the ``base''; by default, Calc
|
|
chooses the base variable automatically.
|
|
|
|
@kindex a n
|
|
@pindex calc-normalize-rat
|
|
@tindex nrat
|
|
The @kbd{a n} (@code{calc-normalize-rat}) [@code{nrat}] command
|
|
attempts to arrange a formula into a quotient of two polynomials.
|
|
For example, given @expr{1 + (a + b/c) / d}, the result would be
|
|
@expr{(b + a c + c d) / c d}. The quotient is reduced, so that
|
|
@kbd{a n} will simplify @expr{(x^2 + 2x + 1) / (x^2 - 1)} by dividing
|
|
out the common factor @expr{x + 1}, yielding @expr{(x + 1) / (x - 1)}.
|
|
|
|
@kindex a \
|
|
@pindex calc-poly-div
|
|
@tindex pdiv
|
|
The @kbd{a \} (@code{calc-poly-div}) [@code{pdiv}] command divides
|
|
two polynomials @expr{u} and @expr{v}, yielding a new polynomial
|
|
@expr{q}. If several variables occur in the inputs, the inputs are
|
|
considered multivariate polynomials. (Calc divides by the variable
|
|
with the largest power in @expr{u} first, or, in the case of equal
|
|
powers, chooses the variables in alphabetical order.) For example,
|
|
dividing @expr{x^2 + 3 x + 2} by @expr{x + 2} yields @expr{x + 1}.
|
|
The remainder from the division, if any, is reported at the bottom
|
|
of the screen and is also placed in the Trail along with the quotient.
|
|
|
|
Using @code{pdiv} in algebraic notation, you can specify the particular
|
|
variable to be used as the base: @code{pdiv(@var{a},@var{b},@var{x})}.
|
|
If @code{pdiv} is given only two arguments (as is always the case with
|
|
the @kbd{a \} command), then it does a multivariate division as outlined
|
|
above.
|
|
|
|
@kindex a %
|
|
@pindex calc-poly-rem
|
|
@tindex prem
|
|
The @kbd{a %} (@code{calc-poly-rem}) [@code{prem}] command divides
|
|
two polynomials and keeps the remainder @expr{r}. The quotient
|
|
@expr{q} is discarded. For any formulas @expr{a} and @expr{b}, the
|
|
results of @kbd{a \} and @kbd{a %} satisfy @expr{a = q b + r}.
|
|
(This is analogous to plain @kbd{\} and @kbd{%}, which compute the
|
|
integer quotient and remainder from dividing two numbers.)
|
|
|
|
@kindex a /
|
|
@kindex H a /
|
|
@pindex calc-poly-div-rem
|
|
@tindex pdivrem
|
|
@tindex pdivide
|
|
The @kbd{a /} (@code{calc-poly-div-rem}) [@code{pdivrem}] command
|
|
divides two polynomials and reports both the quotient and the
|
|
remainder as a vector @expr{[q, r]}. The @kbd{H a /} [@code{pdivide}]
|
|
command divides two polynomials and constructs the formula
|
|
@expr{q + r/b} on the stack. (Naturally if the remainder is zero,
|
|
this will immediately simplify to @expr{q}.)
|
|
|
|
@kindex a g
|
|
@pindex calc-poly-gcd
|
|
@tindex pgcd
|
|
The @kbd{a g} (@code{calc-poly-gcd}) [@code{pgcd}] command computes
|
|
the greatest common divisor of two polynomials. (The GCD actually
|
|
is unique only to within a constant multiplier; Calc attempts to
|
|
choose a GCD which will be unsurprising.) For example, the @kbd{a n}
|
|
command uses @kbd{a g} to take the GCD of the numerator and denominator
|
|
of a quotient, then divides each by the result using @kbd{a \}. (The
|
|
definition of GCD ensures that this division can take place without
|
|
leaving a remainder.)
|
|
|
|
While the polynomials used in operations like @kbd{a /} and @kbd{a g}
|
|
often have integer coefficients, this is not required. Calc can also
|
|
deal with polynomials over the rationals or floating-point reals.
|
|
Polynomials with modulo-form coefficients are also useful in many
|
|
applications; if you enter @samp{(x^2 + 3 x - 1) mod 5}, Calc
|
|
automatically transforms this into a polynomial over the field of
|
|
integers mod 5: @samp{(1 mod 5) x^2 + (3 mod 5) x + (4 mod 5)}.
|
|
|
|
Congratulations and thanks go to Ove Ewerlid
|
|
(@code{ewerlid@@mizar.DoCS.UU.SE}), who contributed many of the
|
|
polynomial routines used in the above commands.
|
|
|
|
@xref{Decomposing Polynomials}, for several useful functions for
|
|
extracting the individual coefficients of a polynomial.
|
|
|
|
@node Calculus, Solving Equations, Polynomials, Algebra
|
|
@section Calculus
|
|
|
|
@noindent
|
|
The following calculus commands do not automatically simplify their
|
|
inputs or outputs using @code{calc-simplify}. You may find it helps
|
|
to do this by hand by typing @kbd{a s} or @kbd{a e}. It may also help
|
|
to use @kbd{a x} and/or @kbd{a c} to arrange a result in the most
|
|
readable way.
|
|
|
|
@menu
|
|
* Differentiation::
|
|
* Integration::
|
|
* Customizing the Integrator::
|
|
* Numerical Integration::
|
|
* Taylor Series::
|
|
@end menu
|
|
|
|
@node Differentiation, Integration, Calculus, Calculus
|
|
@subsection Differentiation
|
|
|
|
@noindent
|
|
@kindex a d
|
|
@kindex H a d
|
|
@pindex calc-derivative
|
|
@tindex deriv
|
|
@tindex tderiv
|
|
The @kbd{a d} (@code{calc-derivative}) [@code{deriv}] command computes
|
|
the derivative of the expression on the top of the stack with respect to
|
|
some variable, which it will prompt you to enter. Normally, variables
|
|
in the formula other than the specified differentiation variable are
|
|
considered constant, i.e., @samp{deriv(y,x)} is reduced to zero. With
|
|
the Hyperbolic flag, the @code{tderiv} (total derivative) operation is used
|
|
instead, in which derivatives of variables are not reduced to zero
|
|
unless those variables are known to be ``constant,'' i.e., independent
|
|
of any other variables. (The built-in special variables like @code{pi}
|
|
are considered constant, as are variables that have been declared
|
|
@code{const}; @pxref{Declarations}.)
|
|
|
|
With a numeric prefix argument @var{n}, this command computes the
|
|
@var{n}th derivative.
|
|
|
|
When working with trigonometric functions, it is best to switch to
|
|
Radians mode first (with @w{@kbd{m r}}). The derivative of @samp{sin(x)}
|
|
in degrees is @samp{(pi/180) cos(x)}, probably not the expected
|
|
answer!
|
|
|
|
If you use the @code{deriv} function directly in an algebraic formula,
|
|
you can write @samp{deriv(f,x,x0)} which represents the derivative
|
|
of @expr{f} with respect to @expr{x}, evaluated at the point
|
|
@texline @math{x=x_0}.
|
|
@infoline @expr{x=x0}.
|
|
|
|
If the formula being differentiated contains functions which Calc does
|
|
not know, the derivatives of those functions are produced by adding
|
|
primes (apostrophe characters). For example, @samp{deriv(f(2x), x)}
|
|
produces @samp{2 f'(2 x)}, where the function @code{f'} represents the
|
|
derivative of @code{f}.
|
|
|
|
For functions you have defined with the @kbd{Z F} command, Calc expands
|
|
the functions according to their defining formulas unless you have
|
|
also defined @code{f'} suitably. For example, suppose we define
|
|
@samp{sinc(x) = sin(x)/x} using @kbd{Z F}. If we then differentiate
|
|
the formula @samp{sinc(2 x)}, the formula will be expanded to
|
|
@samp{sin(2 x) / (2 x)} and differentiated. However, if we also
|
|
define @samp{sinc'(x) = dsinc(x)}, say, then Calc will write the
|
|
result as @samp{2 dsinc(2 x)}. @xref{Algebraic Definitions}.
|
|
|
|
For multi-argument functions @samp{f(x,y,z)}, the derivative with respect
|
|
to the first argument is written @samp{f'(x,y,z)}; derivatives with
|
|
respect to the other arguments are @samp{f'2(x,y,z)} and @samp{f'3(x,y,z)}.
|
|
Various higher-order derivatives can be formed in the obvious way, e.g.,
|
|
@samp{f'@var{}'(x)} (the second derivative of @code{f}) or
|
|
@samp{f'@var{}'2'3(x,y,z)} (@code{f} differentiated with respect to each
|
|
argument once).
|
|
|
|
@node Integration, Customizing the Integrator, Differentiation, Calculus
|
|
@subsection Integration
|
|
|
|
@noindent
|
|
@kindex a i
|
|
@pindex calc-integral
|
|
@tindex integ
|
|
The @kbd{a i} (@code{calc-integral}) [@code{integ}] command computes the
|
|
indefinite integral of the expression on the top of the stack with
|
|
respect to a prompted-for variable. The integrator is not guaranteed to
|
|
work for all integrable functions, but it is able to integrate several
|
|
large classes of formulas. In particular, any polynomial or rational
|
|
function (a polynomial divided by a polynomial) is acceptable.
|
|
(Rational functions don't have to be in explicit quotient form, however;
|
|
@texline @math{x/(1+x^{-2})}
|
|
@infoline @expr{x/(1+x^-2)}
|
|
is not strictly a quotient of polynomials, but it is equivalent to
|
|
@expr{x^3/(x^2+1)}, which is.) Also, square roots of terms involving
|
|
@expr{x} and @expr{x^2} may appear in rational functions being
|
|
integrated. Finally, rational functions involving trigonometric or
|
|
hyperbolic functions can be integrated.
|
|
|
|
With an argument (@kbd{C-u a i}), this command will compute the definite
|
|
integral of the expression on top of the stack. In this case, the
|
|
command will again prompt for an integration variable, then prompt for a
|
|
lower limit and an upper limit.
|
|
|
|
@ifinfo
|
|
If you use the @code{integ} function directly in an algebraic formula,
|
|
you can also write @samp{integ(f,x,v)} which expresses the resulting
|
|
indefinite integral in terms of variable @code{v} instead of @code{x}.
|
|
With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
|
|
integral from @code{a} to @code{b}.
|
|
@end ifinfo
|
|
@tex
|
|
If you use the @code{integ} function directly in an algebraic formula,
|
|
you can also write @samp{integ(f,x,v)} which expresses the resulting
|
|
indefinite integral in terms of variable @code{v} instead of @code{x}.
|
|
With four arguments, @samp{integ(f(x),x,a,b)} represents a definite
|
|
integral $\int_a^b f(x) \, dx$.
|
|
@end tex
|
|
|
|
Please note that the current implementation of Calc's integrator sometimes
|
|
produces results that are significantly more complex than they need to
|
|
be. For example, the integral Calc finds for
|
|
@texline @math{1/(x+\sqrt{x^2+1})}
|
|
@infoline @expr{1/(x+sqrt(x^2+1))}
|
|
is several times more complicated than the answer Mathematica
|
|
returns for the same input, although the two forms are numerically
|
|
equivalent. Also, any indefinite integral should be considered to have
|
|
an arbitrary constant of integration added to it, although Calc does not
|
|
write an explicit constant of integration in its result. For example,
|
|
Calc's solution for
|
|
@texline @math{1/(1+\tan x)}
|
|
@infoline @expr{1/(1+tan(x))}
|
|
differs from the solution given in the @emph{CRC Math Tables} by a
|
|
constant factor of
|
|
@texline @math{\pi i / 2}
|
|
@infoline @expr{pi i / 2},
|
|
due to a different choice of constant of integration.
|
|
|
|
The Calculator remembers all the integrals it has done. If conditions
|
|
change in a way that would invalidate the old integrals, say, a switch
|
|
from Degrees to Radians mode, then they will be thrown out. If you
|
|
suspect this is not happening when it should, use the
|
|
@code{calc-flush-caches} command; @pxref{Caches}.
|
|
|
|
@vindex IntegLimit
|
|
Calc normally will pursue integration by substitution or integration by
|
|
parts up to 3 nested times before abandoning an approach as fruitless.
|
|
If the integrator is taking too long, you can lower this limit by storing
|
|
a number (like 2) in the variable @code{IntegLimit}. (The @kbd{s I}
|
|
command is a convenient way to edit @code{IntegLimit}.) If this variable
|
|
has no stored value or does not contain a nonnegative integer, a limit
|
|
of 3 is used. The lower this limit is, the greater the chance that Calc
|
|
will be unable to integrate a function it could otherwise handle. Raising
|
|
this limit allows the Calculator to solve more integrals, though the time
|
|
it takes may grow exponentially. You can monitor the integrator's actions
|
|
by creating an Emacs buffer called @code{*Trace*}. If such a buffer
|
|
exists, the @kbd{a i} command will write a log of its actions there.
|
|
|
|
If you want to manipulate integrals in a purely symbolic way, you can
|
|
set the integration nesting limit to 0 to prevent all but fast
|
|
table-lookup solutions of integrals. You might then wish to define
|
|
rewrite rules for integration by parts, various kinds of substitutions,
|
|
and so on. @xref{Rewrite Rules}.
|
|
|
|
@node Customizing the Integrator, Numerical Integration, Integration, Calculus
|
|
@subsection Customizing the Integrator
|
|
|
|
@noindent
|
|
@vindex IntegRules
|
|
Calc has two built-in rewrite rules called @code{IntegRules} and
|
|
@code{IntegAfterRules} which you can edit to define new integration
|
|
methods. @xref{Rewrite Rules}. At each step of the integration process,
|
|
Calc wraps the current integrand in a call to the fictitious function
|
|
@samp{integtry(@var{expr},@var{var})}, where @var{expr} is the
|
|
integrand and @var{var} is the integration variable. If your rules
|
|
rewrite this to be a plain formula (not a call to @code{integtry}), then
|
|
Calc will use this formula as the integral of @var{expr}. For example,
|
|
the rule @samp{integtry(mysin(x),x) := -mycos(x)} would define a rule to
|
|
integrate a function @code{mysin} that acts like the sine function.
|
|
Then, putting @samp{4 mysin(2y+1)} on the stack and typing @kbd{a i y}
|
|
will produce the integral @samp{-2 mycos(2y+1)}. Note that Calc has
|
|
automatically made various transformations on the integral to allow it
|
|
to use your rule; integral tables generally give rules for
|
|
@samp{mysin(a x + b)}, but you don't need to use this much generality
|
|
in your @code{IntegRules}.
|
|
|
|
@cindex Exponential integral Ei(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex Ei
|
|
As a more serious example, the expression @samp{exp(x)/x} cannot be
|
|
integrated in terms of the standard functions, so the ``exponential
|
|
integral'' function
|
|
@texline @math{{\rm Ei}(x)}
|
|
@infoline @expr{Ei(x)}
|
|
was invented to describe it.
|
|
We can get Calc to do this integral in terms of a made-up @code{Ei}
|
|
function by adding the rule @samp{[integtry(exp(x)/x, x) := Ei(x)]}
|
|
to @code{IntegRules}. Now entering @samp{exp(2x)/x} on the stack
|
|
and typing @kbd{a i x} yields @samp{Ei(2 x)}. This new rule will
|
|
work with Calc's various built-in integration methods (such as
|
|
integration by substitution) to solve a variety of other problems
|
|
involving @code{Ei}: For example, now Calc will also be able to
|
|
integrate @samp{exp(exp(x))} and @samp{ln(ln(x))} (to get @samp{Ei(exp(x))}
|
|
and @samp{x ln(ln(x)) - Ei(ln(x))}, respectively).
|
|
|
|
Your rule may do further integration by calling @code{integ}. For
|
|
example, @samp{integtry(twice(u),x) := twice(integ(u))} allows Calc
|
|
to integrate @samp{twice(sin(x))} to get @samp{twice(-cos(x))}.
|
|
Note that @code{integ} was called with only one argument. This notation
|
|
is allowed only within @code{IntegRules}; it means ``integrate this
|
|
with respect to the same integration variable.'' If Calc is unable
|
|
to integrate @code{u}, the integration that invoked @code{IntegRules}
|
|
also fails. Thus integrating @samp{twice(f(x))} fails, returning the
|
|
unevaluated integral @samp{integ(twice(f(x)), x)}. It is still valid
|
|
to call @code{integ} with two or more arguments, however; in this case,
|
|
if @code{u} is not integrable, @code{twice} itself will still be
|
|
integrated: If the above rule is changed to @samp{... := twice(integ(u,x))},
|
|
then integrating @samp{twice(f(x))} will yield @samp{twice(integ(f(x),x))}.
|
|
|
|
If a rule instead produces the formula @samp{integsubst(@var{sexpr},
|
|
@var{svar})}, either replacing the top-level @code{integtry} call or
|
|
nested anywhere inside the expression, then Calc will apply the
|
|
substitution @samp{@var{u} = @var{sexpr}(@var{svar})} to try to
|
|
integrate the original @var{expr}. For example, the rule
|
|
@samp{sqrt(a) := integsubst(sqrt(x),x)} says that if Calc ever finds
|
|
a square root in the integrand, it should attempt the substitution
|
|
@samp{u = sqrt(x)}. (This particular rule is unnecessary because
|
|
Calc always tries ``obvious'' substitutions where @var{sexpr} actually
|
|
appears in the integrand.) The variable @var{svar} may be the same
|
|
as the @var{var} that appeared in the call to @code{integtry}, but
|
|
it need not be.
|
|
|
|
When integrating according to an @code{integsubst}, Calc uses the
|
|
equation solver to find the inverse of @var{sexpr} (if the integrand
|
|
refers to @var{var} anywhere except in subexpressions that exactly
|
|
match @var{sexpr}). It uses the differentiator to find the derivative
|
|
of @var{sexpr} and/or its inverse (it has two methods that use one
|
|
derivative or the other). You can also specify these items by adding
|
|
extra arguments to the @code{integsubst} your rules construct; the
|
|
general form is @samp{integsubst(@var{sexpr}, @var{svar}, @var{sinv},
|
|
@var{sprime})}, where @var{sinv} is the inverse of @var{sexpr} (still
|
|
written as a function of @var{svar}), and @var{sprime} is the
|
|
derivative of @var{sexpr} with respect to @var{svar}. If you don't
|
|
specify these things, and Calc is not able to work them out on its
|
|
own with the information it knows, then your substitution rule will
|
|
work only in very specific, simple cases.
|
|
|
|
Calc applies @code{IntegRules} as if by @kbd{C-u 1 a r IntegRules};
|
|
in other words, Calc stops rewriting as soon as any rule in your rule
|
|
set succeeds. (If it weren't for this, the @samp{integsubst(sqrt(x),x)}
|
|
example above would keep on adding layers of @code{integsubst} calls
|
|
forever!)
|
|
|
|
@vindex IntegSimpRules
|
|
Another set of rules, stored in @code{IntegSimpRules}, are applied
|
|
every time the integrator uses @kbd{a s} to simplify an intermediate
|
|
result. For example, putting the rule @samp{twice(x) := 2 x} into
|
|
@code{IntegSimpRules} would tell Calc to convert the @code{twice}
|
|
function into a form it knows whenever integration is attempted.
|
|
|
|
One more way to influence the integrator is to define a function with
|
|
the @kbd{Z F} command (@pxref{Algebraic Definitions}). Calc's
|
|
integrator automatically expands such functions according to their
|
|
defining formulas, even if you originally asked for the function to
|
|
be left unevaluated for symbolic arguments. (Certain other Calc
|
|
systems, such as the differentiator and the equation solver, also
|
|
do this.)
|
|
|
|
@vindex IntegAfterRules
|
|
Sometimes Calc is able to find a solution to your integral, but it
|
|
expresses the result in a way that is unnecessarily complicated. If
|
|
this happens, you can either use @code{integsubst} as described
|
|
above to try to hint at a more direct path to the desired result, or
|
|
you can use @code{IntegAfterRules}. This is an extra rule set that
|
|
runs after the main integrator returns its result; basically, Calc does
|
|
an @kbd{a r IntegAfterRules} on the result before showing it to you.
|
|
(It also does an @kbd{a s}, without @code{IntegSimpRules}, after that
|
|
to further simplify the result.) For example, Calc's integrator
|
|
sometimes produces expressions of the form @samp{ln(1+x) - ln(1-x)};
|
|
the default @code{IntegAfterRules} rewrite this into the more readable
|
|
form @samp{2 arctanh(x)}. Note that, unlike @code{IntegRules},
|
|
@code{IntegSimpRules} and @code{IntegAfterRules} are applied any number
|
|
of times until no further changes are possible. Rewriting by
|
|
@code{IntegAfterRules} occurs only after the main integrator has
|
|
finished, not at every step as for @code{IntegRules} and
|
|
@code{IntegSimpRules}.
|
|
|
|
@node Numerical Integration, Taylor Series, Customizing the Integrator, Calculus
|
|
@subsection Numerical Integration
|
|
|
|
@noindent
|
|
@kindex a I
|
|
@pindex calc-num-integral
|
|
@tindex ninteg
|
|
If you want a purely numerical answer to an integration problem, you can
|
|
use the @kbd{a I} (@code{calc-num-integral}) [@code{ninteg}] command. This
|
|
command prompts for an integration variable, a lower limit, and an
|
|
upper limit. Except for the integration variable, all other variables
|
|
that appear in the integrand formula must have stored values. (A stored
|
|
value, if any, for the integration variable itself is ignored.)
|
|
|
|
Numerical integration works by evaluating your formula at many points in
|
|
the specified interval. Calc uses an ``open Romberg'' method; this means
|
|
that it does not evaluate the formula actually at the endpoints (so that
|
|
it is safe to integrate @samp{sin(x)/x} from zero, for example). Also,
|
|
the Romberg method works especially well when the function being
|
|
integrated is fairly smooth. If the function is not smooth, Calc will
|
|
have to evaluate it at quite a few points before it can accurately
|
|
determine the value of the integral.
|
|
|
|
Integration is much faster when the current precision is small. It is
|
|
best to set the precision to the smallest acceptable number of digits
|
|
before you use @kbd{a I}. If Calc appears to be taking too long, press
|
|
@kbd{C-g} to halt it and try a lower precision. If Calc still appears
|
|
to need hundreds of evaluations, check to make sure your function is
|
|
well-behaved in the specified interval.
|
|
|
|
It is possible for the lower integration limit to be @samp{-inf} (minus
|
|
infinity). Likewise, the upper limit may be plus infinity. Calc
|
|
internally transforms the integral into an equivalent one with finite
|
|
limits. However, integration to or across singularities is not supported:
|
|
The integral of @samp{1/sqrt(x)} from 0 to 1 exists (it can be found
|
|
by Calc's symbolic integrator, for example), but @kbd{a I} will fail
|
|
because the integrand goes to infinity at one of the endpoints.
|
|
|
|
@node Taylor Series, , Numerical Integration, Calculus
|
|
@subsection Taylor Series
|
|
|
|
@noindent
|
|
@kindex a t
|
|
@pindex calc-taylor
|
|
@tindex taylor
|
|
The @kbd{a t} (@code{calc-taylor}) [@code{taylor}] command computes a
|
|
power series expansion or Taylor series of a function. You specify the
|
|
variable and the desired number of terms. You may give an expression of
|
|
the form @samp{@var{var} = @var{a}} or @samp{@var{var} - @var{a}} instead
|
|
of just a variable to produce a Taylor expansion about the point @var{a}.
|
|
You may specify the number of terms with a numeric prefix argument;
|
|
otherwise the command will prompt you for the number of terms. Note that
|
|
many series expansions have coefficients of zero for some terms, so you
|
|
may appear to get fewer terms than you asked for.
|
|
|
|
If the @kbd{a i} command is unable to find a symbolic integral for a
|
|
function, you can get an approximation by integrating the function's
|
|
Taylor series.
|
|
|
|
@node Solving Equations, Numerical Solutions, Calculus, Algebra
|
|
@section Solving Equations
|
|
|
|
@noindent
|
|
@kindex a S
|
|
@pindex calc-solve-for
|
|
@tindex solve
|
|
@cindex Equations, solving
|
|
@cindex Solving equations
|
|
The @kbd{a S} (@code{calc-solve-for}) [@code{solve}] command rearranges
|
|
an equation to solve for a specific variable. An equation is an
|
|
expression of the form @expr{L = R}. For example, the command @kbd{a S x}
|
|
will rearrange @expr{y = 3x + 6} to the form, @expr{x = y/3 - 2}. If the
|
|
input is not an equation, it is treated like an equation of the
|
|
form @expr{X = 0}.
|
|
|
|
This command also works for inequalities, as in @expr{y < 3x + 6}.
|
|
Some inequalities cannot be solved where the analogous equation could
|
|
be; for example, solving
|
|
@texline @math{a < b \, c}
|
|
@infoline @expr{a < b c}
|
|
for @expr{b} is impossible
|
|
without knowing the sign of @expr{c}. In this case, @kbd{a S} will
|
|
produce the result
|
|
@texline @math{b \mathbin{\hbox{\code{!=}}} a/c}
|
|
@infoline @expr{b != a/c}
|
|
(using the not-equal-to operator) to signify that the direction of the
|
|
inequality is now unknown. The inequality
|
|
@texline @math{a \le b \, c}
|
|
@infoline @expr{a <= b c}
|
|
is not even partially solved. @xref{Declarations}, for a way to tell
|
|
Calc that the signs of the variables in a formula are in fact known.
|
|
|
|
Two useful commands for working with the result of @kbd{a S} are
|
|
@kbd{a .} (@pxref{Logical Operations}), which converts @expr{x = y/3 - 2}
|
|
to @expr{y/3 - 2}, and @kbd{s l} (@pxref{Let Command}) which evaluates
|
|
another formula with @expr{x} set equal to @expr{y/3 - 2}.
|
|
|
|
@menu
|
|
* Multiple Solutions::
|
|
* Solving Systems of Equations::
|
|
* Decomposing Polynomials::
|
|
@end menu
|
|
|
|
@node Multiple Solutions, Solving Systems of Equations, Solving Equations, Solving Equations
|
|
@subsection Multiple Solutions
|
|
|
|
@noindent
|
|
@kindex H a S
|
|
@tindex fsolve
|
|
Some equations have more than one solution. The Hyperbolic flag
|
|
(@code{H a S}) [@code{fsolve}] tells the solver to report the fully
|
|
general family of solutions. It will invent variables @code{n1},
|
|
@code{n2}, @dots{}, which represent independent arbitrary integers, and
|
|
@code{s1}, @code{s2}, @dots{}, which represent independent arbitrary
|
|
signs (either @mathit{+1} or @mathit{-1}). If you don't use the Hyperbolic
|
|
flag, Calc will use zero in place of all arbitrary integers, and plus
|
|
one in place of all arbitrary signs. Note that variables like @code{n1}
|
|
and @code{s1} are not given any special interpretation in Calc except by
|
|
the equation solver itself. As usual, you can use the @w{@kbd{s l}}
|
|
(@code{calc-let}) command to obtain solutions for various actual values
|
|
of these variables.
|
|
|
|
For example, @kbd{' x^2 = y @key{RET} H a S x @key{RET}} solves to
|
|
get @samp{x = s1 sqrt(y)}, indicating that the two solutions to the
|
|
equation are @samp{sqrt(y)} and @samp{-sqrt(y)}. Another way to
|
|
think about it is that the square-root operation is really a
|
|
two-valued function; since every Calc function must return a
|
|
single result, @code{sqrt} chooses to return the positive result.
|
|
Then @kbd{H a S} doctors this result using @code{s1} to indicate
|
|
the full set of possible values of the mathematical square-root.
|
|
|
|
There is a similar phenomenon going the other direction: Suppose
|
|
we solve @samp{sqrt(y) = x} for @code{y}. Calc squares both sides
|
|
to get @samp{y = x^2}. This is correct, except that it introduces
|
|
some dubious solutions. Consider solving @samp{sqrt(y) = -3}:
|
|
Calc will report @expr{y = 9} as a valid solution, which is true
|
|
in the mathematical sense of square-root, but false (there is no
|
|
solution) for the actual Calc positive-valued @code{sqrt}. This
|
|
happens for both @kbd{a S} and @kbd{H a S}.
|
|
|
|
@cindex @code{GenCount} variable
|
|
@vindex GenCount
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex an
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex as
|
|
If you store a positive integer in the Calc variable @code{GenCount},
|
|
then Calc will generate formulas of the form @samp{as(@var{n})} for
|
|
arbitrary signs, and @samp{an(@var{n})} for arbitrary integers,
|
|
where @var{n} represents successive values taken by incrementing
|
|
@code{GenCount} by one. While the normal arbitrary sign and
|
|
integer symbols start over at @code{s1} and @code{n1} with each
|
|
new Calc command, the @code{GenCount} approach will give each
|
|
arbitrary value a name that is unique throughout the entire Calc
|
|
session. Also, the arbitrary values are function calls instead
|
|
of variables, which is advantageous in some cases. For example,
|
|
you can make a rewrite rule that recognizes all arbitrary signs
|
|
using a pattern like @samp{as(n)}. The @kbd{s l} command only works
|
|
on variables, but you can use the @kbd{a b} (@code{calc-substitute})
|
|
command to substitute actual values for function calls like @samp{as(3)}.
|
|
|
|
The @kbd{s G} (@code{calc-edit-GenCount}) command is a convenient
|
|
way to create or edit this variable. Press @kbd{C-c C-c} to finish.
|
|
|
|
If you have not stored a value in @code{GenCount}, or if the value
|
|
in that variable is not a positive integer, the regular
|
|
@code{s1}/@code{n1} notation is used.
|
|
|
|
@kindex I a S
|
|
@kindex H I a S
|
|
@tindex finv
|
|
@tindex ffinv
|
|
With the Inverse flag, @kbd{I a S} [@code{finv}] treats the expression
|
|
on top of the stack as a function of the specified variable and solves
|
|
to find the inverse function, written in terms of the same variable.
|
|
For example, @kbd{I a S x} inverts @expr{2x + 6} to @expr{x/2 - 3}.
|
|
You can use both Inverse and Hyperbolic [@code{ffinv}] to obtain a
|
|
fully general inverse, as described above.
|
|
|
|
@kindex a P
|
|
@pindex calc-poly-roots
|
|
@tindex roots
|
|
Some equations, specifically polynomials, have a known, finite number
|
|
of solutions. The @kbd{a P} (@code{calc-poly-roots}) [@code{roots}]
|
|
command uses @kbd{H a S} to solve an equation in general form, then, for
|
|
all arbitrary-sign variables like @code{s1}, and all arbitrary-integer
|
|
variables like @code{n1} for which @code{n1} only usefully varies over
|
|
a finite range, it expands these variables out to all their possible
|
|
values. The results are collected into a vector, which is returned.
|
|
For example, @samp{roots(x^4 = 1, x)} returns the four solutions
|
|
@samp{[1, -1, (0, 1), (0, -1)]}. Generally an @var{n}th degree
|
|
polynomial will always have @var{n} roots on the complex plane.
|
|
(If you have given a @code{real} declaration for the solution
|
|
variable, then only the real-valued solutions, if any, will be
|
|
reported; @pxref{Declarations}.)
|
|
|
|
Note that because @kbd{a P} uses @kbd{H a S}, it is able to deliver
|
|
symbolic solutions if the polynomial has symbolic coefficients. Also
|
|
note that Calc's solver is not able to get exact symbolic solutions
|
|
to all polynomials. Polynomials containing powers up to @expr{x^4}
|
|
can always be solved exactly; polynomials of higher degree sometimes
|
|
can be: @expr{x^6 + x^3 + 1} is converted to @expr{(x^3)^2 + (x^3) + 1},
|
|
which can be solved for @expr{x^3} using the quadratic equation, and then
|
|
for @expr{x} by taking cube roots. But in many cases, like
|
|
@expr{x^6 + x + 1}, Calc does not know how to rewrite the polynomial
|
|
into a form it can solve. The @kbd{a P} command can still deliver a
|
|
list of numerical roots, however, provided that Symbolic mode (@kbd{m s})
|
|
is not turned on. (If you work with Symbolic mode on, recall that the
|
|
@kbd{N} (@code{calc-eval-num}) key is a handy way to reevaluate the
|
|
formula on the stack with Symbolic mode temporarily off.) Naturally,
|
|
@kbd{a P} can only provide numerical roots if the polynomial coefficients
|
|
are all numbers (real or complex).
|
|
|
|
@node Solving Systems of Equations, Decomposing Polynomials, Multiple Solutions, Solving Equations
|
|
@subsection Solving Systems of Equations
|
|
|
|
@noindent
|
|
@cindex Systems of equations, symbolic
|
|
You can also use the commands described above to solve systems of
|
|
simultaneous equations. Just create a vector of equations, then
|
|
specify a vector of variables for which to solve. (You can omit
|
|
the surrounding brackets when entering the vector of variables
|
|
at the prompt.)
|
|
|
|
For example, putting @samp{[x + y = a, x - y = b]} on the stack
|
|
and typing @kbd{a S x,y @key{RET}} produces the vector of solutions
|
|
@samp{[x = a - (a-b)/2, y = (a-b)/2]}. The result vector will
|
|
have the same length as the variables vector, and the variables
|
|
will be listed in the same order there. Note that the solutions
|
|
are not always simplified as far as possible; the solution for
|
|
@expr{x} here could be improved by an application of the @kbd{a n}
|
|
command.
|
|
|
|
Calc's algorithm works by trying to eliminate one variable at a
|
|
time by solving one of the equations for that variable and then
|
|
substituting into the other equations. Calc will try all the
|
|
possibilities, but you can speed things up by noting that Calc
|
|
first tries to eliminate the first variable with the first
|
|
equation, then the second variable with the second equation,
|
|
and so on. It also helps to put the simpler (e.g., more linear)
|
|
equations toward the front of the list. Calc's algorithm will
|
|
solve any system of linear equations, and also many kinds of
|
|
nonlinear systems.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex elim
|
|
Normally there will be as many variables as equations. If you
|
|
give fewer variables than equations (an ``over-determined'' system
|
|
of equations), Calc will find a partial solution. For example,
|
|
typing @kbd{a S y @key{RET}} with the above system of equations
|
|
would produce @samp{[y = a - x]}. There are now several ways to
|
|
express this solution in terms of the original variables; Calc uses
|
|
the first one that it finds. You can control the choice by adding
|
|
variable specifiers of the form @samp{elim(@var{v})} to the
|
|
variables list. This says that @var{v} should be eliminated from
|
|
the equations; the variable will not appear at all in the solution.
|
|
For example, typing @kbd{a S y,elim(x)} would yield
|
|
@samp{[y = a - (b+a)/2]}.
|
|
|
|
If the variables list contains only @code{elim} specifiers,
|
|
Calc simply eliminates those variables from the equations
|
|
and then returns the resulting set of equations. For example,
|
|
@kbd{a S elim(x)} produces @samp{[a - 2 y = b]}. Every variable
|
|
eliminated will reduce the number of equations in the system
|
|
by one.
|
|
|
|
Again, @kbd{a S} gives you one solution to the system of
|
|
equations. If there are several solutions, you can use @kbd{H a S}
|
|
to get a general family of solutions, or, if there is a finite
|
|
number of solutions, you can use @kbd{a P} to get a list. (In
|
|
the latter case, the result will take the form of a matrix where
|
|
the rows are different solutions and the columns correspond to the
|
|
variables you requested.)
|
|
|
|
Another way to deal with certain kinds of overdetermined systems of
|
|
equations is the @kbd{a F} command, which does least-squares fitting
|
|
to satisfy the equations. @xref{Curve Fitting}.
|
|
|
|
@node Decomposing Polynomials, , Solving Systems of Equations, Solving Equations
|
|
@subsection Decomposing Polynomials
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex poly
|
|
The @code{poly} function takes a polynomial and a variable as
|
|
arguments, and returns a vector of polynomial coefficients (constant
|
|
coefficient first). For example, @samp{poly(x^3 + 2 x, x)} returns
|
|
@expr{[0, 2, 0, 1]}. If the input is not a polynomial in @expr{x},
|
|
the call to @code{poly} is left in symbolic form. If the input does
|
|
not involve the variable @expr{x}, the input is returned in a list
|
|
of length one, representing a polynomial with only a constant
|
|
coefficient. The call @samp{poly(x, x)} returns the vector @expr{[0, 1]}.
|
|
The last element of the returned vector is guaranteed to be nonzero;
|
|
note that @samp{poly(0, x)} returns the empty vector @expr{[]}.
|
|
Note also that @expr{x} may actually be any formula; for example,
|
|
@samp{poly(sin(x)^2 - sin(x) + 3, sin(x))} returns @expr{[3, -1, 1]}.
|
|
|
|
@cindex Coefficients of polynomial
|
|
@cindex Degree of polynomial
|
|
To get the @expr{x^k} coefficient of polynomial @expr{p}, use
|
|
@samp{poly(p, x)_(k+1)}. To get the degree of polynomial @expr{p},
|
|
use @samp{vlen(poly(p, x)) - 1}. For example, @samp{poly((x+1)^4, x)}
|
|
returns @samp{[1, 4, 6, 4, 1]}, so @samp{poly((x+1)^4, x)_(2+1)}
|
|
gives the @expr{x^2} coefficient of this polynomial, 6.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex gpoly
|
|
One important feature of the solver is its ability to recognize
|
|
formulas which are ``essentially'' polynomials. This ability is
|
|
made available to the user through the @code{gpoly} function, which
|
|
is used just like @code{poly}: @samp{gpoly(@var{expr}, @var{var})}.
|
|
If @var{expr} is a polynomial in some term which includes @var{var}, then
|
|
this function will return a vector @samp{[@var{x}, @var{c}, @var{a}]}
|
|
where @var{x} is the term that depends on @var{var}, @var{c} is a
|
|
vector of polynomial coefficients (like the one returned by @code{poly}),
|
|
and @var{a} is a multiplier which is usually 1. Basically,
|
|
@samp{@var{expr} = @var{a}*(@var{c}_1 + @var{c}_2 @var{x} +
|
|
@var{c}_3 @var{x}^2 + ...)}. The last element of @var{c} is
|
|
guaranteed to be non-zero, and @var{c} will not equal @samp{[1]}
|
|
(i.e., the trivial decomposition @var{expr} = @var{x} is not
|
|
considered a polynomial). One side effect is that @samp{gpoly(x, x)}
|
|
and @samp{gpoly(6, x)}, both of which might be expected to recognize
|
|
their arguments as polynomials, will not because the decomposition
|
|
is considered trivial.
|
|
|
|
For example, @samp{gpoly((x-2)^2, x)} returns @samp{[x, [4, -4, 1], 1]},
|
|
since the expanded form of this polynomial is @expr{4 - 4 x + x^2}.
|
|
|
|
The term @var{x} may itself be a polynomial in @var{var}. This is
|
|
done to reduce the size of the @var{c} vector. For example,
|
|
@samp{gpoly(x^4 + x^2 - 1, x)} returns @samp{[x^2, [-1, 1, 1], 1]},
|
|
since a quadratic polynomial in @expr{x^2} is easier to solve than
|
|
a quartic polynomial in @expr{x}.
|
|
|
|
A few more examples of the kinds of polynomials @code{gpoly} can
|
|
discover:
|
|
|
|
@smallexample
|
|
sin(x) - 1 [sin(x), [-1, 1], 1]
|
|
x + 1/x - 1 [x, [1, -1, 1], 1/x]
|
|
x + 1/x [x^2, [1, 1], 1/x]
|
|
x^3 + 2 x [x^2, [2, 1], x]
|
|
x + x^2:3 + sqrt(x) [x^1:6, [1, 1, 0, 1], x^1:2]
|
|
x^(2a) + 2 x^a + 5 [x^a, [5, 2, 1], 1]
|
|
(exp(-x) + exp(x)) / 2 [e^(2 x), [0.5, 0.5], e^-x]
|
|
@end smallexample
|
|
|
|
The @code{poly} and @code{gpoly} functions accept a third integer argument
|
|
which specifies the largest degree of polynomial that is acceptable.
|
|
If this is @expr{n}, then only @var{c} vectors of length @expr{n+1}
|
|
or less will be returned. Otherwise, the @code{poly} or @code{gpoly}
|
|
call will remain in symbolic form. For example, the equation solver
|
|
can handle quartics and smaller polynomials, so it calls
|
|
@samp{gpoly(@var{expr}, @var{var}, 4)} to discover whether @var{expr}
|
|
can be treated by its linear, quadratic, cubic, or quartic formulas.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pdeg
|
|
The @code{pdeg} function computes the degree of a polynomial;
|
|
@samp{pdeg(p,x)} is the highest power of @code{x} that appears in
|
|
@code{p}. This is the same as @samp{vlen(poly(p,x))-1}, but is
|
|
much more efficient. If @code{p} is constant with respect to @code{x},
|
|
then @samp{pdeg(p,x) = 0}. If @code{p} is not a polynomial in @code{x}
|
|
(e.g., @samp{pdeg(2 cos(x), x)}, the function remains unevaluated.
|
|
It is possible to omit the second argument @code{x}, in which case
|
|
@samp{pdeg(p)} returns the highest total degree of any term of the
|
|
polynomial, counting all variables that appear in @code{p}. Note
|
|
that @code{pdeg(c) = pdeg(c,x) = 0} for any nonzero constant @code{c};
|
|
the degree of the constant zero is considered to be @code{-inf}
|
|
(minus infinity).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex plead
|
|
The @code{plead} function finds the leading term of a polynomial.
|
|
Thus @samp{plead(p,x)} is equivalent to @samp{poly(p,x)_vlen(poly(p,x))},
|
|
though again more efficient. In particular, @samp{plead((2x+1)^10, x)}
|
|
returns 1024 without expanding out the list of coefficients. The
|
|
value of @code{plead(p,x)} will be zero only if @expr{p = 0}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pcont
|
|
The @code{pcont} function finds the @dfn{content} of a polynomial. This
|
|
is the greatest common divisor of all the coefficients of the polynomial.
|
|
With two arguments, @code{pcont(p,x)} effectively uses @samp{poly(p,x)}
|
|
to get a list of coefficients, then uses @code{pgcd} (the polynomial
|
|
GCD function) to combine these into an answer. For example,
|
|
@samp{pcont(4 x y^2 + 6 x^2 y, x)} is @samp{2 y}. The content is
|
|
basically the ``biggest'' polynomial that can be divided into @code{p}
|
|
exactly. The sign of the content is the same as the sign of the leading
|
|
coefficient.
|
|
|
|
With only one argument, @samp{pcont(p)} computes the numerical
|
|
content of the polynomial, i.e., the @code{gcd} of the numerical
|
|
coefficients of all the terms in the formula. Note that @code{gcd}
|
|
is defined on rational numbers as well as integers; it computes
|
|
the @code{gcd} of the numerators and the @code{lcm} of the
|
|
denominators. Thus @samp{pcont(4:3 x y^2 + 6 x^2 y)} returns 2:3.
|
|
Dividing the polynomial by this number will clear all the
|
|
denominators, as well as dividing by any common content in the
|
|
numerators. The numerical content of a polynomial is negative only
|
|
if all the coefficients in the polynomial are negative.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pprim
|
|
The @code{pprim} function finds the @dfn{primitive part} of a
|
|
polynomial, which is simply the polynomial divided (using @code{pdiv}
|
|
if necessary) by its content. If the input polynomial has rational
|
|
coefficients, the result will have integer coefficients in simplest
|
|
terms.
|
|
|
|
@node Numerical Solutions, Curve Fitting, Solving Equations, Algebra
|
|
@section Numerical Solutions
|
|
|
|
@noindent
|
|
Not all equations can be solved symbolically. The commands in this
|
|
section use numerical algorithms that can find a solution to a specific
|
|
instance of an equation to any desired accuracy. Note that the
|
|
numerical commands are slower than their algebraic cousins; it is a
|
|
good idea to try @kbd{a S} before resorting to these commands.
|
|
|
|
(@xref{Curve Fitting}, for some other, more specialized, operations
|
|
on numerical data.)
|
|
|
|
@menu
|
|
* Root Finding::
|
|
* Minimization::
|
|
* Numerical Systems of Equations::
|
|
@end menu
|
|
|
|
@node Root Finding, Minimization, Numerical Solutions, Numerical Solutions
|
|
@subsection Root Finding
|
|
|
|
@noindent
|
|
@kindex a R
|
|
@pindex calc-find-root
|
|
@tindex root
|
|
@cindex Newton's method
|
|
@cindex Roots of equations
|
|
@cindex Numerical root-finding
|
|
The @kbd{a R} (@code{calc-find-root}) [@code{root}] command finds a
|
|
numerical solution (or @dfn{root}) of an equation. (This command treats
|
|
inequalities the same as equations. If the input is any other kind
|
|
of formula, it is interpreted as an equation of the form @expr{X = 0}.)
|
|
|
|
The @kbd{a R} command requires an initial guess on the top of the
|
|
stack, and a formula in the second-to-top position. It prompts for a
|
|
solution variable, which must appear in the formula. All other variables
|
|
that appear in the formula must have assigned values, i.e., when
|
|
a value is assigned to the solution variable and the formula is
|
|
evaluated with @kbd{=}, it should evaluate to a number. Any assigned
|
|
value for the solution variable itself is ignored and unaffected by
|
|
this command.
|
|
|
|
When the command completes, the initial guess is replaced on the stack
|
|
by a vector of two numbers: The value of the solution variable that
|
|
solves the equation, and the difference between the lefthand and
|
|
righthand sides of the equation at that value. Ordinarily, the second
|
|
number will be zero or very nearly zero. (Note that Calc uses a
|
|
slightly higher precision while finding the root, and thus the second
|
|
number may be slightly different from the value you would compute from
|
|
the equation yourself.)
|
|
|
|
The @kbd{v h} (@code{calc-head}) command is a handy way to extract
|
|
the first element of the result vector, discarding the error term.
|
|
|
|
The initial guess can be a real number, in which case Calc searches
|
|
for a real solution near that number, or a complex number, in which
|
|
case Calc searches the whole complex plane near that number for a
|
|
solution, or it can be an interval form which restricts the search
|
|
to real numbers inside that interval.
|
|
|
|
Calc tries to use @kbd{a d} to take the derivative of the equation.
|
|
If this succeeds, it uses Newton's method. If the equation is not
|
|
differentiable Calc uses a bisection method. (If Newton's method
|
|
appears to be going astray, Calc switches over to bisection if it
|
|
can, or otherwise gives up. In this case it may help to try again
|
|
with a slightly different initial guess.) If the initial guess is a
|
|
complex number, the function must be differentiable.
|
|
|
|
If the formula (or the difference between the sides of an equation)
|
|
is negative at one end of the interval you specify and positive at
|
|
the other end, the root finder is guaranteed to find a root.
|
|
Otherwise, Calc subdivides the interval into small parts looking for
|
|
positive and negative values to bracket the root. When your guess is
|
|
an interval, Calc will not look outside that interval for a root.
|
|
|
|
@kindex H a R
|
|
@tindex wroot
|
|
The @kbd{H a R} [@code{wroot}] command is similar to @kbd{a R}, except
|
|
that if the initial guess is an interval for which the function has
|
|
the same sign at both ends, then rather than subdividing the interval
|
|
Calc attempts to widen it to enclose a root. Use this mode if
|
|
you are not sure if the function has a root in your interval.
|
|
|
|
If the function is not differentiable, and you give a simple number
|
|
instead of an interval as your initial guess, Calc uses this widening
|
|
process even if you did not type the Hyperbolic flag. (If the function
|
|
@emph{is} differentiable, Calc uses Newton's method which does not
|
|
require a bounding interval in order to work.)
|
|
|
|
If Calc leaves the @code{root} or @code{wroot} function in symbolic
|
|
form on the stack, it will normally display an explanation for why
|
|
no root was found. If you miss this explanation, press @kbd{w}
|
|
(@code{calc-why}) to get it back.
|
|
|
|
@node Minimization, Numerical Systems of Equations, Root Finding, Numerical Solutions
|
|
@subsection Minimization
|
|
|
|
@noindent
|
|
@kindex a N
|
|
@kindex H a N
|
|
@kindex a X
|
|
@kindex H a X
|
|
@pindex calc-find-minimum
|
|
@pindex calc-find-maximum
|
|
@tindex minimize
|
|
@tindex maximize
|
|
@cindex Minimization, numerical
|
|
The @kbd{a N} (@code{calc-find-minimum}) [@code{minimize}] command
|
|
finds a minimum value for a formula. It is very similar in operation
|
|
to @kbd{a R} (@code{calc-find-root}): You give the formula and an initial
|
|
guess on the stack, and are prompted for the name of a variable. The guess
|
|
may be either a number near the desired minimum, or an interval enclosing
|
|
the desired minimum. The function returns a vector containing the
|
|
value of the variable which minimizes the formula's value, along
|
|
with the minimum value itself.
|
|
|
|
Note that this command looks for a @emph{local} minimum. Many functions
|
|
have more than one minimum; some, like
|
|
@texline @math{x \sin x},
|
|
@infoline @expr{x sin(x)},
|
|
have infinitely many. In fact, there is no easy way to define the
|
|
``global'' minimum of
|
|
@texline @math{x \sin x}
|
|
@infoline @expr{x sin(x)}
|
|
but Calc can still locate any particular local minimum
|
|
for you. Calc basically goes downhill from the initial guess until it
|
|
finds a point at which the function's value is greater both to the left
|
|
and to the right. Calc does not use derivatives when minimizing a function.
|
|
|
|
If your initial guess is an interval and it looks like the minimum
|
|
occurs at one or the other endpoint of the interval, Calc will return
|
|
that endpoint only if that endpoint is closed; thus, minimizing @expr{17 x}
|
|
over @expr{[2..3]} will return @expr{[2, 38]}, but minimizing over
|
|
@expr{(2..3]} would report no minimum found. In general, you should
|
|
use closed intervals to find literally the minimum value in that
|
|
range of @expr{x}, or open intervals to find the local minimum, if
|
|
any, that happens to lie in that range.
|
|
|
|
Most functions are smooth and flat near their minimum values. Because
|
|
of this flatness, if the current precision is, say, 12 digits, the
|
|
variable can only be determined meaningfully to about six digits. Thus
|
|
you should set the precision to twice as many digits as you need in your
|
|
answer.
|
|
|
|
@ignore
|
|
@mindex wmin@idots
|
|
@end ignore
|
|
@tindex wminimize
|
|
@ignore
|
|
@mindex wmax@idots
|
|
@end ignore
|
|
@tindex wmaximize
|
|
The @kbd{H a N} [@code{wminimize}] command, analogously to @kbd{H a R},
|
|
expands the guess interval to enclose a minimum rather than requiring
|
|
that the minimum lie inside the interval you supply.
|
|
|
|
The @kbd{a X} (@code{calc-find-maximum}) [@code{maximize}] and
|
|
@kbd{H a X} [@code{wmaximize}] commands effectively minimize the
|
|
negative of the formula you supply.
|
|
|
|
The formula must evaluate to a real number at all points inside the
|
|
interval (or near the initial guess if the guess is a number). If
|
|
the initial guess is a complex number the variable will be minimized
|
|
over the complex numbers; if it is real or an interval it will
|
|
be minimized over the reals.
|
|
|
|
@node Numerical Systems of Equations, , Minimization, Numerical Solutions
|
|
@subsection Systems of Equations
|
|
|
|
@noindent
|
|
@cindex Systems of equations, numerical
|
|
The @kbd{a R} command can also solve systems of equations. In this
|
|
case, the equation should instead be a vector of equations, the
|
|
guess should instead be a vector of numbers (intervals are not
|
|
supported), and the variable should be a vector of variables. You
|
|
can omit the brackets while entering the list of variables. Each
|
|
equation must be differentiable by each variable for this mode to
|
|
work. The result will be a vector of two vectors: The variable
|
|
values that solved the system of equations, and the differences
|
|
between the sides of the equations with those variable values.
|
|
There must be the same number of equations as variables. Since
|
|
only plain numbers are allowed as guesses, the Hyperbolic flag has
|
|
no effect when solving a system of equations.
|
|
|
|
It is also possible to minimize over many variables with @kbd{a N}
|
|
(or maximize with @kbd{a X}). Once again the variable name should
|
|
be replaced by a vector of variables, and the initial guess should
|
|
be an equal-sized vector of initial guesses. But, unlike the case of
|
|
multidimensional @kbd{a R}, the formula being minimized should
|
|
still be a single formula, @emph{not} a vector. Beware that
|
|
multidimensional minimization is currently @emph{very} slow.
|
|
|
|
@node Curve Fitting, Summations, Numerical Solutions, Algebra
|
|
@section Curve Fitting
|
|
|
|
@noindent
|
|
The @kbd{a F} command fits a set of data to a @dfn{model formula},
|
|
such as @expr{y = m x + b} where @expr{m} and @expr{b} are parameters
|
|
to be determined. For a typical set of measured data there will be
|
|
no single @expr{m} and @expr{b} that exactly fit the data; in this
|
|
case, Calc chooses values of the parameters that provide the closest
|
|
possible fit.
|
|
|
|
@menu
|
|
* Linear Fits::
|
|
* Polynomial and Multilinear Fits::
|
|
* Error Estimates for Fits::
|
|
* Standard Nonlinear Models::
|
|
* Curve Fitting Details::
|
|
* Interpolation::
|
|
@end menu
|
|
|
|
@node Linear Fits, Polynomial and Multilinear Fits, Curve Fitting, Curve Fitting
|
|
@subsection Linear Fits
|
|
|
|
@noindent
|
|
@kindex a F
|
|
@pindex calc-curve-fit
|
|
@tindex fit
|
|
@cindex Linear regression
|
|
@cindex Least-squares fits
|
|
The @kbd{a F} (@code{calc-curve-fit}) [@code{fit}] command attempts
|
|
to fit a set of data (@expr{x} and @expr{y} vectors of numbers) to a
|
|
straight line, polynomial, or other function of @expr{x}. For the
|
|
moment we will consider only the case of fitting to a line, and we
|
|
will ignore the issue of whether or not the model was in fact a good
|
|
fit for the data.
|
|
|
|
In a standard linear least-squares fit, we have a set of @expr{(x,y)}
|
|
data points that we wish to fit to the model @expr{y = m x + b}
|
|
by adjusting the parameters @expr{m} and @expr{b} to make the @expr{y}
|
|
values calculated from the formula be as close as possible to the actual
|
|
@expr{y} values in the data set. (In a polynomial fit, the model is
|
|
instead, say, @expr{y = a x^3 + b x^2 + c x + d}. In a multilinear fit,
|
|
we have data points of the form @expr{(x_1,x_2,x_3,y)} and our model is
|
|
@expr{y = a x_1 + b x_2 + c x_3 + d}. These will be discussed later.)
|
|
|
|
In the model formula, variables like @expr{x} and @expr{x_2} are called
|
|
the @dfn{independent variables}, and @expr{y} is the @dfn{dependent
|
|
variable}. Variables like @expr{m}, @expr{a}, and @expr{b} are called
|
|
the @dfn{parameters} of the model.
|
|
|
|
The @kbd{a F} command takes the data set to be fitted from the stack.
|
|
By default, it expects the data in the form of a matrix. For example,
|
|
for a linear or polynomial fit, this would be a
|
|
@texline @math{2\times N}
|
|
@infoline 2xN
|
|
matrix where the first row is a list of @expr{x} values and the second
|
|
row has the corresponding @expr{y} values. For the multilinear fit
|
|
shown above, the matrix would have four rows (@expr{x_1}, @expr{x_2},
|
|
@expr{x_3}, and @expr{y}, respectively).
|
|
|
|
If you happen to have an
|
|
@texline @math{N\times2}
|
|
@infoline Nx2
|
|
matrix instead of a
|
|
@texline @math{2\times N}
|
|
@infoline 2xN
|
|
matrix, just press @kbd{v t} first to transpose the matrix.
|
|
|
|
After you type @kbd{a F}, Calc prompts you to select a model. For a
|
|
linear fit, press the digit @kbd{1}.
|
|
|
|
Calc then prompts for you to name the variables. By default it chooses
|
|
high letters like @expr{x} and @expr{y} for independent variables and
|
|
low letters like @expr{a} and @expr{b} for parameters. (The dependent
|
|
variable doesn't need a name.) The two kinds of variables are separated
|
|
by a semicolon. Since you generally care more about the names of the
|
|
independent variables than of the parameters, Calc also allows you to
|
|
name only those and let the parameters use default names.
|
|
|
|
For example, suppose the data matrix
|
|
|
|
@ifinfo
|
|
@example
|
|
@group
|
|
[ [ 1, 2, 3, 4, 5 ]
|
|
[ 5, 7, 9, 11, 13 ] ]
|
|
@end group
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \pmatrix{ 1 & 2 & 3 & 4 & 5 \cr
|
|
5 & 7 & 9 & 11 & 13 }
|
|
$$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
is on the stack and we wish to do a simple linear fit. Type
|
|
@kbd{a F}, then @kbd{1} for the model, then @key{RET} to use
|
|
the default names. The result will be the formula @expr{3 + 2 x}
|
|
on the stack. Calc has created the model expression @kbd{a + b x},
|
|
then found the optimal values of @expr{a} and @expr{b} to fit the
|
|
data. (In this case, it was able to find an exact fit.) Calc then
|
|
substituted those values for @expr{a} and @expr{b} in the model
|
|
formula.
|
|
|
|
The @kbd{a F} command puts two entries in the trail. One is, as
|
|
always, a copy of the result that went to the stack; the other is
|
|
a vector of the actual parameter values, written as equations:
|
|
@expr{[a = 3, b = 2]}, in case you'd rather read them in a list
|
|
than pick them out of the formula. (You can type @kbd{t y}
|
|
to move this vector to the stack; see @ref{Trail Commands}.
|
|
|
|
Specifying a different independent variable name will affect the
|
|
resulting formula: @kbd{a F 1 k @key{RET}} produces @kbd{3 + 2 k}.
|
|
Changing the parameter names (say, @kbd{a F 1 k;b,m @key{RET}}) will affect
|
|
the equations that go into the trail.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
To see what happens when the fit is not exact, we could change
|
|
the number 13 in the data matrix to 14 and try the fit again.
|
|
The result is:
|
|
|
|
@example
|
|
2.6 + 2.2 x
|
|
@end example
|
|
|
|
Evaluating this formula, say with @kbd{v x 5 @key{RET} @key{TAB} V M $ @key{RET}}, shows
|
|
a reasonably close match to the y-values in the data.
|
|
|
|
@example
|
|
[4.8, 7., 9.2, 11.4, 13.6]
|
|
@end example
|
|
|
|
Since there is no line which passes through all the @var{n} data points,
|
|
Calc has chosen a line that best approximates the data points using
|
|
the method of least squares. The idea is to define the @dfn{chi-square}
|
|
error measure
|
|
|
|
@ifinfo
|
|
@example
|
|
chi^2 = sum((y_i - (a + b x_i))^2, i, 1, N)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \chi^2 = \sum_{i=1}^N (y_i - (a + b x_i))^2 $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
which is clearly zero if @expr{a + b x} exactly fits all data points,
|
|
and increases as various @expr{a + b x_i} values fail to match the
|
|
corresponding @expr{y_i} values. There are several reasons why the
|
|
summand is squared, one of them being to ensure that
|
|
@texline @math{\chi^2 \ge 0}.
|
|
@infoline @expr{chi^2 >= 0}.
|
|
Least-squares fitting simply chooses the values of @expr{a} and @expr{b}
|
|
for which the error
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
is as small as possible.
|
|
|
|
Other kinds of models do the same thing but with a different model
|
|
formula in place of @expr{a + b x_i}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
A numeric prefix argument causes the @kbd{a F} command to take the
|
|
data in some other form than one big matrix. A positive argument @var{n}
|
|
will take @var{N} items from the stack, corresponding to the @var{n} rows
|
|
of a data matrix. In the linear case, @var{n} must be 2 since there
|
|
is always one independent variable and one dependent variable.
|
|
|
|
A prefix of zero or plain @kbd{C-u} is a compromise; Calc takes two
|
|
items from the stack, an @var{n}-row matrix of @expr{x} values, and a
|
|
vector of @expr{y} values. If there is only one independent variable,
|
|
the @expr{x} values can be either a one-row matrix or a plain vector,
|
|
in which case the @kbd{C-u} prefix is the same as a @w{@kbd{C-u 2}} prefix.
|
|
|
|
@node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
|
|
@subsection Polynomial and Multilinear Fits
|
|
|
|
@noindent
|
|
To fit the data to higher-order polynomials, just type one of the
|
|
digits @kbd{2} through @kbd{9} when prompted for a model. For example,
|
|
we could fit the original data matrix from the previous section
|
|
(with 13, not 14) to a parabola instead of a line by typing
|
|
@kbd{a F 2 @key{RET}}.
|
|
|
|
@example
|
|
2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
|
|
@end example
|
|
|
|
Note that since the constant and linear terms are enough to fit the
|
|
data exactly, it's no surprise that Calc chose a tiny contribution
|
|
for @expr{x^2}. (The fact that it's not exactly zero is due only
|
|
to roundoff error. Since our data are exact integers, we could get
|
|
an exact answer by typing @kbd{m f} first to get Fraction mode.
|
|
Then the @expr{x^2} term would vanish altogether. Usually, though,
|
|
the data being fitted will be approximate floats so Fraction mode
|
|
won't help.)
|
|
|
|
Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
|
|
gives a much larger @expr{x^2} contribution, as Calc bends the
|
|
line slightly to improve the fit.
|
|
|
|
@example
|
|
0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
|
|
@end example
|
|
|
|
An important result from the theory of polynomial fitting is that it
|
|
is always possible to fit @var{n} data points exactly using a polynomial
|
|
of degree @mathit{@var{n}-1}, sometimes called an @dfn{interpolating polynomial}.
|
|
Using the modified (14) data matrix, a model number of 4 gives
|
|
a polynomial that exactly matches all five data points:
|
|
|
|
@example
|
|
0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
|
|
@end example
|
|
|
|
The actual coefficients we get with a precision of 12, like
|
|
@expr{0.0416666663588}, clearly suffer from loss of precision.
|
|
It is a good idea to increase the working precision to several
|
|
digits beyond what you need when you do a fitting operation.
|
|
Or, if your data are exact, use Fraction mode to get exact
|
|
results.
|
|
|
|
You can type @kbd{i} instead of a digit at the model prompt to fit
|
|
the data exactly to a polynomial. This just counts the number of
|
|
columns of the data matrix to choose the degree of the polynomial
|
|
automatically.
|
|
|
|
Fitting data ``exactly'' to high-degree polynomials is not always
|
|
a good idea, though. High-degree polynomials have a tendency to
|
|
wiggle uncontrollably in between the fitting data points. Also,
|
|
if the exact-fit polynomial is going to be used to interpolate or
|
|
extrapolate the data, it is numerically better to use the @kbd{a p}
|
|
command described below. @xref{Interpolation}.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Another generalization of the linear model is to assume the
|
|
@expr{y} values are a sum of linear contributions from several
|
|
@expr{x} values. This is a @dfn{multilinear} fit, and it is also
|
|
selected by the @kbd{1} digit key. (Calc decides whether the fit
|
|
is linear or multilinear by counting the rows in the data matrix.)
|
|
|
|
Given the data matrix,
|
|
|
|
@example
|
|
@group
|
|
[ [ 1, 2, 3, 4, 5 ]
|
|
[ 7, 2, 3, 5, 2 ]
|
|
[ 14.5, 15, 18.5, 22.5, 24 ] ]
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
the command @kbd{a F 1 @key{RET}} will call the first row @expr{x} and the
|
|
second row @expr{y}, and will fit the values in the third row to the
|
|
model @expr{a + b x + c y}.
|
|
|
|
@example
|
|
8. + 3. x + 0.5 y
|
|
@end example
|
|
|
|
Calc can do multilinear fits with any number of independent variables
|
|
(i.e., with any number of data rows).
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Yet another variation is @dfn{homogeneous} linear models, in which
|
|
the constant term is known to be zero. In the linear case, this
|
|
means the model formula is simply @expr{a x}; in the multilinear
|
|
case, the model might be @expr{a x + b y + c z}; and in the polynomial
|
|
case, the model could be @expr{a x + b x^2 + c x^3}. You can get
|
|
a homogeneous linear or multilinear model by pressing the letter
|
|
@kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
|
|
|
|
It is certainly possible to have other constrained linear models,
|
|
like @expr{2.3 + a x} or @expr{a - 4 x}. While there is no single
|
|
key to select models like these, a later section shows how to enter
|
|
any desired model by hand. In the first case, for example, you
|
|
would enter @kbd{a F ' 2.3 + a x}.
|
|
|
|
Another class of models that will work but must be entered by hand
|
|
are multinomial fits, e.g., @expr{a + b x + c y + d x^2 + e y^2 + f x y}.
|
|
|
|
@node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
|
|
@subsection Error Estimates for Fits
|
|
|
|
@noindent
|
|
@kindex H a F
|
|
@tindex efit
|
|
With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
|
|
fitting operation as @kbd{a F}, but reports the coefficients as error
|
|
forms instead of plain numbers. Fitting our two data matrices (first
|
|
with 13, then with 14) to a line with @kbd{H a F} gives the results,
|
|
|
|
@example
|
|
3. + 2. x
|
|
2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
|
|
@end example
|
|
|
|
In the first case the estimated errors are zero because the linear
|
|
fit is perfect. In the second case, the errors are nonzero but
|
|
moderately small, because the data are still very close to linear.
|
|
|
|
It is also possible for the @emph{input} to a fitting operation to
|
|
contain error forms. The data values must either all include errors
|
|
or all be plain numbers. Error forms can go anywhere but generally
|
|
go on the numbers in the last row of the data matrix. If the last
|
|
row contains error forms
|
|
@texline `@var{y_i}@w{ @tfn{+/-} }@math{\sigma_i}',
|
|
@infoline `@var{y_i}@w{ @tfn{+/-} }@var{sigma_i}',
|
|
then the
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
statistic is now,
|
|
|
|
@ifinfo
|
|
@example
|
|
chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
|
|
@end example
|
|
@end ifinfo
|
|
@tex
|
|
\turnoffactive
|
|
\beforedisplay
|
|
$$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
|
|
\afterdisplay
|
|
@end tex
|
|
|
|
@noindent
|
|
so that data points with larger error estimates contribute less to
|
|
the fitting operation.
|
|
|
|
If there are error forms on other rows of the data matrix, all the
|
|
errors for a given data point are combined; the square root of the
|
|
sum of the squares of the errors forms the
|
|
@texline @math{\sigma_i}
|
|
@infoline @expr{sigma_i}
|
|
used for the data point.
|
|
|
|
Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
|
|
matrix, although if you are concerned about error analysis you will
|
|
probably use @kbd{H a F} so that the output also contains error
|
|
estimates.
|
|
|
|
If the input contains error forms but all the
|
|
@texline @math{\sigma_i}
|
|
@infoline @expr{sigma_i}
|
|
values are the same, it is easy to see that the resulting fitted model
|
|
will be the same as if the input did not have error forms at all
|
|
@texline (@math{\chi^2}
|
|
@infoline (@expr{chi^2}
|
|
is simply scaled uniformly by
|
|
@texline @math{1 / \sigma^2},
|
|
@infoline @expr{1 / sigma^2},
|
|
which doesn't affect where it has a minimum). But there @emph{will} be
|
|
a difference in the estimated errors of the coefficients reported by
|
|
@kbd{H a F}.
|
|
|
|
Consult any text on statistical modeling of data for a discussion
|
|
of where these error estimates come from and how they should be
|
|
interpreted.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
@kindex I a F
|
|
@tindex xfit
|
|
With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
|
|
information. The result is a vector of six items:
|
|
|
|
@enumerate
|
|
@item
|
|
The model formula with error forms for its coefficients or
|
|
parameters. This is the result that @kbd{H a F} would have
|
|
produced.
|
|
|
|
@item
|
|
A vector of ``raw'' parameter values for the model. These are the
|
|
polynomial coefficients or other parameters as plain numbers, in the
|
|
same order as the parameters appeared in the final prompt of the
|
|
@kbd{I a F} command. For polynomials of degree @expr{d}, this vector
|
|
will have length @expr{M = d+1} with the constant term first.
|
|
|
|
@item
|
|
The covariance matrix @expr{C} computed from the fit. This is
|
|
an @var{m}x@var{m} symmetric matrix; the diagonal elements
|
|
@texline @math{C_{jj}}
|
|
@infoline @expr{C_j_j}
|
|
are the variances
|
|
@texline @math{\sigma_j^2}
|
|
@infoline @expr{sigma_j^2}
|
|
of the parameters. The other elements are covariances
|
|
@texline @math{\sigma_{ij}^2}
|
|
@infoline @expr{sigma_i_j^2}
|
|
that describe the correlation between pairs of parameters. (A related
|
|
set of numbers, the @dfn{linear correlation coefficients}
|
|
@texline @math{r_{ij}},
|
|
@infoline @expr{r_i_j},
|
|
are defined as
|
|
@texline @math{\sigma_{ij}^2 / \sigma_i \, \sigma_j}.)
|
|
@infoline @expr{sigma_i_j^2 / sigma_i sigma_j}.)
|
|
|
|
@item
|
|
A vector of @expr{M} ``parameter filter'' functions whose
|
|
meanings are described below. If no filters are necessary this
|
|
will instead be an empty vector; this is always the case for the
|
|
polynomial and multilinear fits described so far.
|
|
|
|
@item
|
|
The value of
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
for the fit, calculated by the formulas shown above. This gives a
|
|
measure of the quality of the fit; statisticians consider
|
|
@texline @math{\chi^2 \approx N - M}
|
|
@infoline @expr{chi^2 = N - M}
|
|
to indicate a moderately good fit (where again @expr{N} is the number of
|
|
data points and @expr{M} is the number of parameters).
|
|
|
|
@item
|
|
A measure of goodness of fit expressed as a probability @expr{Q}.
|
|
This is computed from the @code{utpc} probability distribution
|
|
function using
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
with @expr{N - M} degrees of freedom. A
|
|
value of 0.5 implies a good fit; some texts recommend that often
|
|
@expr{Q = 0.1} or even 0.001 can signify an acceptable fit. In
|
|
particular,
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
statistics assume the errors in your inputs
|
|
follow a normal (Gaussian) distribution; if they don't, you may
|
|
have to accept smaller values of @expr{Q}.
|
|
|
|
The @expr{Q} value is computed only if the input included error
|
|
estimates. Otherwise, Calc will report the symbol @code{nan}
|
|
for @expr{Q}. The reason is that in this case the
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
value has effectively been used to estimate the original errors
|
|
in the input, and thus there is no redundant information left
|
|
over to use for a confidence test.
|
|
@end enumerate
|
|
|
|
@node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
|
|
@subsection Standard Nonlinear Models
|
|
|
|
@noindent
|
|
The @kbd{a F} command also accepts other kinds of models besides
|
|
lines and polynomials. Some common models have quick single-key
|
|
abbreviations; others must be entered by hand as algebraic formulas.
|
|
|
|
Here is a complete list of the standard models recognized by @kbd{a F}:
|
|
|
|
@table @kbd
|
|
@item 1
|
|
Linear or multilinear. @mathit{a + b x + c y + d z}.
|
|
@item 2-9
|
|
Polynomials. @mathit{a + b x + c x^2 + d x^3}.
|
|
@item e
|
|
Exponential. @mathit{a} @tfn{exp}@mathit{(b x)} @tfn{exp}@mathit{(c y)}.
|
|
@item E
|
|
Base-10 exponential. @mathit{a} @tfn{10^}@mathit{(b x)} @tfn{10^}@mathit{(c y)}.
|
|
@item x
|
|
Exponential (alternate notation). @tfn{exp}@mathit{(a + b x + c y)}.
|
|
@item X
|
|
Base-10 exponential (alternate). @tfn{10^}@mathit{(a + b x + c y)}.
|
|
@item l
|
|
Logarithmic. @mathit{a + b} @tfn{ln}@mathit{(x) + c} @tfn{ln}@mathit{(y)}.
|
|
@item L
|
|
Base-10 logarithmic. @mathit{a + b} @tfn{log10}@mathit{(x) + c} @tfn{log10}@mathit{(y)}.
|
|
@item ^
|
|
General exponential. @mathit{a b^x c^y}.
|
|
@item p
|
|
Power law. @mathit{a x^b y^c}.
|
|
@item q
|
|
Quadratic. @mathit{a + b (x-c)^2 + d (x-e)^2}.
|
|
@item g
|
|
Gaussian.
|
|
@texline @math{{a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)}.
|
|
@infoline @mathit{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
|
|
@end table
|
|
|
|
All of these models are used in the usual way; just press the appropriate
|
|
letter at the model prompt, and choose variable names if you wish. The
|
|
result will be a formula as shown in the above table, with the best-fit
|
|
values of the parameters substituted. (You may find it easier to read
|
|
the parameter values from the vector that is placed in the trail.)
|
|
|
|
All models except Gaussian and polynomials can generalize as shown to any
|
|
number of independent variables. Also, all the built-in models have an
|
|
additive or multiplicative parameter shown as @expr{a} in the above table
|
|
which can be replaced by zero or one, as appropriate, by typing @kbd{h}
|
|
before the model key.
|
|
|
|
Note that many of these models are essentially equivalent, but express
|
|
the parameters slightly differently. For example, @expr{a b^x} and
|
|
the other two exponential models are all algebraic rearrangements of
|
|
each other. Also, the ``quadratic'' model is just a degree-2 polynomial
|
|
with the parameters expressed differently. Use whichever form best
|
|
matches the problem.
|
|
|
|
The HP-28/48 calculators support four different models for curve
|
|
fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
|
|
These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
|
|
@samp{a exp(b x)}, and @samp{a x^b}, respectively. In each case,
|
|
@expr{a} is what the HP-48 identifies as the ``intercept,'' and
|
|
@expr{b} is what it calls the ``slope.''
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
If the model you want doesn't appear on this list, press @kbd{'}
|
|
(the apostrophe key) at the model prompt to enter any algebraic
|
|
formula, such as @kbd{m x - b}, as the model. (Not all models
|
|
will work, though---see the next section for details.)
|
|
|
|
The model can also be an equation like @expr{y = m x + b}.
|
|
In this case, Calc thinks of all the rows of the data matrix on
|
|
equal terms; this model effectively has two parameters
|
|
(@expr{m} and @expr{b}) and two independent variables (@expr{x}
|
|
and @expr{y}), with no ``dependent'' variables. Model equations
|
|
do not need to take this @expr{y =} form. For example, the
|
|
implicit line equation @expr{a x + b y = 1} works fine as a
|
|
model.
|
|
|
|
When you enter a model, Calc makes an alphabetical list of all
|
|
the variables that appear in the model. These are used for the
|
|
default parameters, independent variables, and dependent variable
|
|
(in that order). If you enter a plain formula (not an equation),
|
|
Calc assumes the dependent variable does not appear in the formula
|
|
and thus does not need a name.
|
|
|
|
For example, if the model formula has the variables @expr{a,mu,sigma,t,x},
|
|
and the data matrix has three rows (meaning two independent variables),
|
|
Calc will use @expr{a,mu,sigma} as the default parameters, and the
|
|
data rows will be named @expr{t} and @expr{x}, respectively. If you
|
|
enter an equation instead of a plain formula, Calc will use @expr{a,mu}
|
|
as the parameters, and @expr{sigma,t,x} as the three independent
|
|
variables.
|
|
|
|
You can, of course, override these choices by entering something
|
|
different at the prompt. If you leave some variables out of the list,
|
|
those variables must have stored values and those stored values will
|
|
be used as constants in the model. (Stored values for the parameters
|
|
and independent variables are ignored by the @kbd{a F} command.)
|
|
If you list only independent variables, all the remaining variables
|
|
in the model formula will become parameters.
|
|
|
|
If there are @kbd{$} signs in the model you type, they will stand
|
|
for parameters and all other variables (in alphabetical order)
|
|
will be independent. Use @kbd{$} for one parameter, @kbd{$$} for
|
|
another, and so on. Thus @kbd{$ x + $$} is another way to describe
|
|
a linear model.
|
|
|
|
If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
|
|
Calc will take the model formula from the stack. (The data must then
|
|
appear at the second stack level.) The same conventions are used to
|
|
choose which variables in the formula are independent by default and
|
|
which are parameters.
|
|
|
|
Models taken from the stack can also be expressed as vectors of
|
|
two or three elements, @expr{[@var{model}, @var{vars}]} or
|
|
@expr{[@var{model}, @var{vars}, @var{params}]}. Each of @var{vars}
|
|
and @var{params} may be either a variable or a vector of variables.
|
|
(If @var{params} is omitted, all variables in @var{model} except
|
|
those listed as @var{vars} are parameters.)
|
|
|
|
When you enter a model manually with @kbd{'}, Calc puts a 3-vector
|
|
describing the model in the trail so you can get it back if you wish.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
@vindex Model1
|
|
@vindex Model2
|
|
Finally, you can store a model in one of the Calc variables
|
|
@code{Model1} or @code{Model2}, then use this model by typing
|
|
@kbd{a F u} or @kbd{a F U} (respectively). The value stored in
|
|
the variable can be any of the formats that @kbd{a F $} would
|
|
accept for a model on the stack.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Calc uses the principal values of inverse functions like @code{ln}
|
|
and @code{arcsin} when doing fits. For example, when you enter
|
|
the model @samp{y = sin(a t + b)} Calc actually uses the easier
|
|
form @samp{arcsin(y) = a t + b}. The @code{arcsin} function always
|
|
returns results in the range from @mathit{-90} to 90 degrees (or the
|
|
equivalent range in radians). Suppose you had data that you
|
|
believed to represent roughly three oscillations of a sine wave,
|
|
so that the argument of the sine might go from zero to
|
|
@texline @math{3\times360}
|
|
@infoline @mathit{3*360}
|
|
degrees.
|
|
The above model would appear to be a good way to determine the
|
|
true frequency and phase of the sine wave, but in practice it
|
|
would fail utterly. The righthand side of the actual model
|
|
@samp{arcsin(y) = a t + b} will grow smoothly with @expr{t}, but
|
|
the lefthand side will bounce back and forth between @mathit{-90} and 90.
|
|
No values of @expr{a} and @expr{b} can make the two sides match,
|
|
even approximately.
|
|
|
|
There is no good solution to this problem at present. You could
|
|
restrict your data to small enough ranges so that the above problem
|
|
doesn't occur (i.e., not straddling any peaks in the sine wave).
|
|
Or, in this case, you could use a totally different method such as
|
|
Fourier analysis, which is beyond the scope of the @kbd{a F} command.
|
|
(Unfortunately, Calc does not currently have any facilities for
|
|
taking Fourier and related transforms.)
|
|
|
|
@node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
|
|
@subsection Curve Fitting Details
|
|
|
|
@noindent
|
|
Calc's internal least-squares fitter can only handle multilinear
|
|
models. More precisely, it can handle any model of the form
|
|
@expr{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @expr{a,b,c}
|
|
are the parameters and @expr{x,y,z} are the independent variables
|
|
(of course there can be any number of each, not just three).
|
|
|
|
In a simple multilinear or polynomial fit, it is easy to see how
|
|
to convert the model into this form. For example, if the model
|
|
is @expr{a + b x + c x^2}, then @expr{f(x) = 1}, @expr{g(x) = x},
|
|
and @expr{h(x) = x^2} are suitable functions.
|
|
|
|
For other models, Calc uses a variety of algebraic manipulations
|
|
to try to put the problem into the form
|
|
|
|
@smallexample
|
|
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)
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where @expr{Y,A,B,C,F,G,H} are arbitrary functions. It computes
|
|
@expr{Y}, @expr{F}, @expr{G}, and @expr{H} for all the data points,
|
|
does a standard linear fit to find the values of @expr{A}, @expr{B},
|
|
and @expr{C}, then uses the equation solver to solve for @expr{a,b,c}
|
|
in terms of @expr{A,B,C}.
|
|
|
|
A remarkable number of models can be cast into this general form.
|
|
We'll look at two examples here to see how it works. The power-law
|
|
model @expr{y = a x^b} with two independent variables and two parameters
|
|
can be rewritten as follows:
|
|
|
|
@example
|
|
y = a x^b
|
|
y = a exp(b ln(x))
|
|
y = exp(ln(a) + b ln(x))
|
|
ln(y) = ln(a) + b ln(x)
|
|
@end example
|
|
|
|
@noindent
|
|
which matches the desired form with
|
|
@texline @math{Y = \ln(y)},
|
|
@infoline @expr{Y = ln(y)},
|
|
@texline @math{A = \ln(a)},
|
|
@infoline @expr{A = ln(a)},
|
|
@expr{F = 1}, @expr{B = b}, and
|
|
@texline @math{G = \ln(x)}.
|
|
@infoline @expr{G = ln(x)}.
|
|
Calc thus computes the logarithms of your @expr{y} and @expr{x} values,
|
|
does a linear fit for @expr{A} and @expr{B}, then solves to get
|
|
@texline @math{a = \exp(A)}
|
|
@infoline @expr{a = exp(A)}
|
|
and @expr{b = B}.
|
|
|
|
Another interesting example is the ``quadratic'' model, which can
|
|
be handled by expanding according to the distributive law.
|
|
|
|
@example
|
|
y = a + b*(x - c)^2
|
|
y = a + b c^2 - 2 b c x + b x^2
|
|
@end example
|
|
|
|
@noindent
|
|
which matches with @expr{Y = y}, @expr{A = a + b c^2}, @expr{F = 1},
|
|
@expr{B = -2 b c}, @expr{G = x} (the @mathit{-2} factor could just as easily
|
|
have been put into @expr{G} instead of @expr{B}), @expr{C = b}, and
|
|
@expr{H = x^2}.
|
|
|
|
The Gaussian model looks quite complicated, but a closer examination
|
|
shows that it's actually similar to the quadratic model but with an
|
|
exponential that can be brought to the top and moved into @expr{Y}.
|
|
|
|
An example of a model that cannot be put into general linear
|
|
form is a Gaussian with a constant background added on, i.e.,
|
|
@expr{d} + the regular Gaussian formula. If you have a model like
|
|
this, your best bet is to replace enough of your parameters with
|
|
constants to make the model linearizable, then adjust the constants
|
|
manually by doing a series of fits. You can compare the fits by
|
|
graphing them, by examining the goodness-of-fit measures returned by
|
|
@kbd{I a F}, or by some other method suitable to your application.
|
|
Note that some models can be linearized in several ways. The
|
|
Gaussian-plus-@var{d} model can be linearized by setting @expr{d}
|
|
(the background) to a constant, or by setting @expr{b} (the standard
|
|
deviation) and @expr{c} (the mean) to constants.
|
|
|
|
To fit a model with constants substituted for some parameters, just
|
|
store suitable values in those parameter variables, then omit them
|
|
from the list of parameters when you answer the variables prompt.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
A last desperate step would be to use the general-purpose
|
|
@code{minimize} function rather than @code{fit}. After all, both
|
|
functions solve the problem of minimizing an expression (the
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
sum) by adjusting certain parameters in the expression. The @kbd{a F}
|
|
command is able to use a vastly more efficient algorithm due to its
|
|
special knowledge about linear chi-square sums, but the @kbd{a N}
|
|
command can do the same thing by brute force.
|
|
|
|
A compromise would be to pick out a few parameters without which the
|
|
fit is linearizable, and use @code{minimize} on a call to @code{fit}
|
|
which efficiently takes care of the rest of the parameters. The thing
|
|
to be minimized would be the value of
|
|
@texline @math{\chi^2}
|
|
@infoline @expr{chi^2}
|
|
returned as the fifth result of the @code{xfit} function:
|
|
|
|
@smallexample
|
|
minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where @code{gaus} represents the Gaussian model with background,
|
|
@code{data} represents the data matrix, and @code{guess} represents
|
|
the initial guess for @expr{d} that @code{minimize} requires.
|
|
This operation will only be, shall we say, extraordinarily slow
|
|
rather than astronomically slow (as would be the case if @code{minimize}
|
|
were used by itself to solve the problem).
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
|
|
nonlinear models are used. The second item in the result is the
|
|
vector of ``raw'' parameters @expr{A}, @expr{B}, @expr{C}. The
|
|
covariance matrix is written in terms of those raw parameters.
|
|
The fifth item is a vector of @dfn{filter} expressions. This
|
|
is the empty vector @samp{[]} if the raw parameters were the same
|
|
as the requested parameters, i.e., if @expr{A = a}, @expr{B = b},
|
|
and so on (which is always true if the model is already linear
|
|
in the parameters as written, e.g., for polynomial fits). If the
|
|
parameters had to be rearranged, the fifth item is instead a vector
|
|
of one formula per parameter in the original model. The raw
|
|
parameters are expressed in these ``filter'' formulas as
|
|
@samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)} for @expr{B},
|
|
and so on.
|
|
|
|
When Calc needs to modify the model to return the result, it replaces
|
|
@samp{fitdummy(1)} in all the filters with the first item in the raw
|
|
parameters list, and so on for the other raw parameters, then
|
|
evaluates the resulting filter formulas to get the actual parameter
|
|
values to be substituted into the original model. In the case of
|
|
@kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
|
|
Calc uses the square roots of the diagonal entries of the covariance
|
|
matrix as error values for the raw parameters, then lets Calc's
|
|
standard error-form arithmetic take it from there.
|
|
|
|
If you use @kbd{I a F} with a nonlinear model, be sure to remember
|
|
that the covariance matrix is in terms of the raw parameters,
|
|
@emph{not} the actual requested parameters. It's up to you to
|
|
figure out how to interpret the covariances in the presence of
|
|
nontrivial filter functions.
|
|
|
|
Things are also complicated when the input contains error forms.
|
|
Suppose there are three independent and dependent variables, @expr{x},
|
|
@expr{y}, and @expr{z}, one or more of which are error forms in the
|
|
data. Calc combines all the error values by taking the square root
|
|
of the sum of the squares of the errors. It then changes @expr{x}
|
|
and @expr{y} to be plain numbers, and makes @expr{z} into an error
|
|
form with this combined error. The @expr{Y(x,y,z)} part of the
|
|
linearized model is evaluated, and the result should be an error
|
|
form. The error part of that result is used for
|
|
@texline @math{\sigma_i}
|
|
@infoline @expr{sigma_i}
|
|
for the data point. If for some reason @expr{Y(x,y,z)} does not return
|
|
an error form, the combined error from @expr{z} is used directly for
|
|
@texline @math{\sigma_i}.
|
|
@infoline @expr{sigma_i}.
|
|
Finally, @expr{z} is also stripped of its error
|
|
for use in computing @expr{F(x,y,z)}, @expr{G(x,y,z)} and so on;
|
|
the righthand side of the linearized model is computed in regular
|
|
arithmetic with no error forms.
|
|
|
|
(While these rules may seem complicated, they are designed to do
|
|
the most reasonable thing in the typical case that @expr{Y(x,y,z)}
|
|
depends only on the dependent variable @expr{z}, and in fact is
|
|
often simply equal to @expr{z}. For common cases like polynomials
|
|
and multilinear models, the combined error is simply used as the
|
|
@texline @math{\sigma}
|
|
@infoline @expr{sigma}
|
|
for the data point with no further ado.)
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
@vindex FitRules
|
|
It may be the case that the model you wish to use is linearizable,
|
|
but Calc's built-in rules are unable to figure it out. Calc uses
|
|
its algebraic rewrite mechanism to linearize a model. The rewrite
|
|
rules are kept in the variable @code{FitRules}. You can edit this
|
|
variable using the @kbd{s e FitRules} command; in fact, there is
|
|
a special @kbd{s F} command just for editing @code{FitRules}.
|
|
@xref{Operations on Variables}.
|
|
|
|
@xref{Rewrite Rules}, for a discussion of rewrite rules.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex fitvar
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@tindex fitparam
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex fitmodel
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex fitsystem
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex fitdummy
|
|
Calc uses @code{FitRules} as follows. First, it converts the model
|
|
to an equation if necessary and encloses the model equation in a
|
|
call to the function @code{fitmodel} (which is not actually a defined
|
|
function in Calc; it is only used as a placeholder by the rewrite rules).
|
|
Parameter variables are renamed to function calls @samp{fitparam(1)},
|
|
@samp{fitparam(2)}, and so on, and independent variables are renamed
|
|
to @samp{fitvar(1)}, @samp{fitvar(2)}, etc. The dependent variable
|
|
is the highest-numbered @code{fitvar}. For example, the power law
|
|
model @expr{a x^b} is converted to @expr{y = a x^b}, then to
|
|
|
|
@smallexample
|
|
@group
|
|
fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
|
|
@end group
|
|
@end smallexample
|
|
|
|
Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
|
|
(The zero prefix means that rewriting should continue until no further
|
|
changes are possible.)
|
|
|
|
When rewriting is complete, the @code{fitmodel} call should have
|
|
been replaced by a @code{fitsystem} call that looks like this:
|
|
|
|
@example
|
|
fitsystem(@var{Y}, @var{FGH}, @var{abc})
|
|
@end example
|
|
|
|
@noindent
|
|
where @var{Y} is a formula that describes the function @expr{Y(x,y,z)},
|
|
@var{FGH} is the vector of formulas @expr{[F(x,y,z), G(x,y,z), H(x,y,z)]},
|
|
and @var{abc} is the vector of parameter filters which refer to the
|
|
raw parameters as @samp{fitdummy(1)} for @expr{A}, @samp{fitdummy(2)}
|
|
for @expr{B}, etc. While the number of raw parameters (the length of
|
|
the @var{FGH} vector) is usually the same as the number of original
|
|
parameters (the length of the @var{abc} vector), this is not required.
|
|
|
|
The power law model eventually boils down to
|
|
|
|
@smallexample
|
|
@group
|
|
fitsystem(ln(fitvar(2)),
|
|
[1, ln(fitvar(1))],
|
|
[exp(fitdummy(1)), fitdummy(2)])
|
|
@end group
|
|
@end smallexample
|
|
|
|
The actual implementation of @code{FitRules} is complicated; it
|
|
proceeds in four phases. First, common rearrangements are done
|
|
to try to bring linear terms together and to isolate functions like
|
|
@code{exp} and @code{ln} either all the way ``out'' (so that they
|
|
can be put into @var{Y}) or all the way ``in'' (so that they can
|
|
be put into @var{abc} or @var{FGH}). In particular, all
|
|
non-constant powers are converted to logs-and-exponentials form,
|
|
and the distributive law is used to expand products of sums.
|
|
Quotients are rewritten to use the @samp{fitinv} function, where
|
|
@samp{fitinv(x)} represents @expr{1/x} while the @code{FitRules}
|
|
are operating. (The use of @code{fitinv} makes recognition of
|
|
linear-looking forms easier.) If you modify @code{FitRules}, you
|
|
will probably only need to modify the rules for this phase.
|
|
|
|
Phase two, whose rules can actually also apply during phases one
|
|
and three, first rewrites @code{fitmodel} to a two-argument
|
|
form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
|
|
initially zero and @var{model} has been changed from @expr{a=b}
|
|
to @expr{a-b} form. It then tries to peel off invertible functions
|
|
from the outside of @var{model} and put them into @var{Y} instead,
|
|
calling the equation solver to invert the functions. Finally, when
|
|
this is no longer possible, the @code{fitmodel} is changed to a
|
|
four-argument @code{fitsystem}, where the fourth argument is
|
|
@var{model} and the @var{FGH} and @var{abc} vectors are initially
|
|
empty. (The last vector is really @var{ABC}, corresponding to
|
|
raw parameters, for now.)
|
|
|
|
Phase three converts a sum of items in the @var{model} to a sum
|
|
of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
|
|
terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
|
|
is all factors that do not involve any variables, @var{b} is all
|
|
factors that involve only parameters, and @var{c} is the factors
|
|
that involve only independent variables. (If this decomposition
|
|
is not possible, the rule set will not complete and Calc will
|
|
complain that the model is too complex.) Then @code{fitpart}s
|
|
with equal @var{b} or @var{c} components are merged back together
|
|
using the distributive law in order to minimize the number of
|
|
raw parameters needed.
|
|
|
|
Phase four moves the @code{fitpart} terms into the @var{FGH} and
|
|
@var{ABC} vectors. Also, some of the algebraic expansions that
|
|
were done in phase 1 are undone now to make the formulas more
|
|
computationally efficient. Finally, it calls the solver one more
|
|
time to convert the @var{ABC} vector to an @var{abc} vector, and
|
|
removes the fourth @var{model} argument (which by now will be zero)
|
|
to obtain the three-argument @code{fitsystem} that the linear
|
|
least-squares solver wants to see.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex hasfit@idots
|
|
@end ignore
|
|
@tindex hasfitparams
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex hasfitvars
|
|
Two functions which are useful in connection with @code{FitRules}
|
|
are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
|
|
whether @expr{x} refers to any parameters or independent variables,
|
|
respectively. Specifically, these functions return ``true'' if the
|
|
argument contains any @code{fitparam} (or @code{fitvar}) function
|
|
calls, and ``false'' otherwise. (Recall that ``true'' means a
|
|
nonzero number, and ``false'' means zero. The actual nonzero number
|
|
returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
|
|
or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The @code{fit} function in algebraic notation normally takes four
|
|
arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
|
|
where @var{model} is the model formula as it would be typed after
|
|
@kbd{a F '}, @var{vars} is the independent variable or a vector of
|
|
independent variables, @var{params} likewise gives the parameter(s),
|
|
and @var{data} is the data matrix. Note that the length of @var{vars}
|
|
must be equal to the number of rows in @var{data} if @var{model} is
|
|
an equation, or one less than the number of rows if @var{model} is
|
|
a plain formula. (Actually, a name for the dependent variable is
|
|
allowed but will be ignored in the plain-formula case.)
|
|
|
|
If @var{params} is omitted, the parameters are all variables in
|
|
@var{model} except those that appear in @var{vars}. If @var{vars}
|
|
is also omitted, Calc sorts all the variables that appear in
|
|
@var{model} alphabetically and uses the higher ones for @var{vars}
|
|
and the lower ones for @var{params}.
|
|
|
|
Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
|
|
where @var{modelvec} is a 2- or 3-vector describing the model
|
|
and variables, as discussed previously.
|
|
|
|
If Calc is unable to do the fit, the @code{fit} function is left
|
|
in symbolic form, ordinarily with an explanatory message. The
|
|
message will be ``Model expression is too complex'' if the
|
|
linearizer was unable to put the model into the required form.
|
|
|
|
The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
|
|
(for @kbd{I a F}) functions are completely analogous.
|
|
|
|
@node Interpolation, , Curve Fitting Details, Curve Fitting
|
|
@subsection Polynomial Interpolation
|
|
|
|
@kindex a p
|
|
@pindex calc-poly-interp
|
|
@tindex polint
|
|
The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
|
|
a polynomial interpolation at a particular @expr{x} value. It takes
|
|
two arguments from the stack: A data matrix of the sort used by
|
|
@kbd{a F}, and a single number which represents the desired @expr{x}
|
|
value. Calc effectively does an exact polynomial fit as if by @kbd{a F i},
|
|
then substitutes the @expr{x} value into the result in order to get an
|
|
approximate @expr{y} value based on the fit. (Calc does not actually
|
|
use @kbd{a F i}, however; it uses a direct method which is both more
|
|
efficient and more numerically stable.)
|
|
|
|
The result of @kbd{a p} is actually a vector of two values: The @expr{y}
|
|
value approximation, and an error measure @expr{dy} that reflects Calc's
|
|
estimation of the probable error of the approximation at that value of
|
|
@expr{x}. If the input @expr{x} is equal to any of the @expr{x} values
|
|
in the data matrix, the output @expr{y} will be the corresponding @expr{y}
|
|
value from the matrix, and the output @expr{dy} will be exactly zero.
|
|
|
|
A prefix argument of 2 causes @kbd{a p} to take separate x- and
|
|
y-vectors from the stack instead of one data matrix.
|
|
|
|
If @expr{x} is a vector of numbers, @kbd{a p} will return a matrix of
|
|
interpolated results for each of those @expr{x} values. (The matrix will
|
|
have two columns, the @expr{y} values and the @expr{dy} values.)
|
|
If @expr{x} is a formula instead of a number, the @code{polint} function
|
|
remains in symbolic form; use the @kbd{a "} command to expand it out to
|
|
a formula that describes the fit in symbolic terms.
|
|
|
|
In all cases, the @kbd{a p} command leaves the data vectors or matrix
|
|
on the stack. Only the @expr{x} value is replaced by the result.
|
|
|
|
@kindex H a p
|
|
@tindex ratint
|
|
The @kbd{H a p} [@code{ratint}] command does a rational function
|
|
interpolation. It is used exactly like @kbd{a p}, except that it
|
|
uses as its model the quotient of two polynomials. If there are
|
|
@expr{N} data points, the numerator and denominator polynomials will
|
|
each have degree @expr{N/2} (if @expr{N} is odd, the denominator will
|
|
have degree one higher than the numerator).
|
|
|
|
Rational approximations have the advantage that they can accurately
|
|
describe functions that have poles (points at which the function's value
|
|
goes to infinity, so that the denominator polynomial of the approximation
|
|
goes to zero). If @expr{x} corresponds to a pole of the fitted rational
|
|
function, then the result will be a division by zero. If Infinite mode
|
|
is enabled, the result will be @samp{[uinf, uinf]}.
|
|
|
|
There is no way to get the actual coefficients of the rational function
|
|
used by @kbd{H a p}. (The algorithm never generates these coefficients
|
|
explicitly, and quotients of polynomials are beyond @w{@kbd{a F}}'s
|
|
capabilities to fit.)
|
|
|
|
@node Summations, Logical Operations, Curve Fitting, Algebra
|
|
@section Summations
|
|
|
|
@noindent
|
|
@cindex Summation of a series
|
|
@kindex a +
|
|
@pindex calc-summation
|
|
@tindex sum
|
|
The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
|
|
the sum of a formula over a certain range of index values. The formula
|
|
is taken from the top of the stack; the command prompts for the
|
|
name of the summation index variable, the lower limit of the
|
|
sum (any formula), and the upper limit of the sum. If you
|
|
enter a blank line at any of these prompts, that prompt and
|
|
any later ones are answered by reading additional elements from
|
|
the stack. Thus, @kbd{' k^2 @key{RET} ' k @key{RET} 1 @key{RET} 5 @key{RET} a + @key{RET}}
|
|
produces the result 55.
|
|
@tex
|
|
\turnoffactive
|
|
$$ \sum_{k=1}^5 k^2 = 55 $$
|
|
@end tex
|
|
|
|
The choice of index variable is arbitrary, but it's best not to
|
|
use a variable with a stored value. In particular, while
|
|
@code{i} is often a favorite index variable, it should be avoided
|
|
in Calc because @code{i} has the imaginary constant @expr{(0, 1)}
|
|
as a value. If you pressed @kbd{=} on a sum over @code{i}, it would
|
|
be changed to a nonsensical sum over the ``variable'' @expr{(0, 1)}!
|
|
If you really want to use @code{i} as an index variable, use
|
|
@w{@kbd{s u i @key{RET}}} first to ``unstore'' this variable.
|
|
(@xref{Storing Variables}.)
|
|
|
|
A numeric prefix argument steps the index by that amount rather
|
|
than by one. Thus @kbd{' a_k @key{RET} C-u -2 a + k @key{RET} 10 @key{RET} 0 @key{RET}}
|
|
yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}. A prefix
|
|
argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
|
|
step value, in which case you can enter any formula or enter
|
|
a blank line to take the step value from the stack. With the
|
|
@kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
|
|
the stack: The formula, the variable, the lower limit, the
|
|
upper limit, and (at the top of the stack), the step value.
|
|
|
|
Calc knows how to do certain sums in closed form. For example,
|
|
@samp{sum(6 k^2, k, 1, n) = @w{2 n^3} + 3 n^2 + n}. In particular,
|
|
this is possible if the formula being summed is polynomial or
|
|
exponential in the index variable. Sums of logarithms are
|
|
transformed into logarithms of products. Sums of trigonometric
|
|
and hyperbolic functions are transformed to sums of exponentials
|
|
and then done in closed form. Also, of course, sums in which the
|
|
lower and upper limits are both numbers can always be evaluated
|
|
just by grinding them out, although Calc will use closed forms
|
|
whenever it can for the sake of efficiency.
|
|
|
|
The notation for sums in algebraic formulas is
|
|
@samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
|
|
If @var{step} is omitted, it defaults to one. If @var{high} is
|
|
omitted, @var{low} is actually the upper limit and the lower limit
|
|
is one. If @var{low} is also omitted, the limits are @samp{-inf}
|
|
and @samp{inf}, respectively.
|
|
|
|
Infinite sums can sometimes be evaluated: @samp{sum(.5^k, k, 1, inf)}
|
|
returns @expr{1}. This is done by evaluating the sum in closed
|
|
form (to @samp{1. - 0.5^n} in this case), then evaluating this
|
|
formula with @code{n} set to @code{inf}. Calc's usual rules
|
|
for ``infinite'' arithmetic can find the answer from there. If
|
|
infinite arithmetic yields a @samp{nan}, or if the sum cannot be
|
|
solved in closed form, Calc leaves the @code{sum} function in
|
|
symbolic form. @xref{Infinities}.
|
|
|
|
As a special feature, if the limits are infinite (or omitted, as
|
|
described above) but the formula includes vectors subscripted by
|
|
expressions that involve the iteration variable, Calc narrows
|
|
the limits to include only the range of integers which result in
|
|
valid subscripts for the vector. For example, the sum
|
|
@samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
|
|
|
|
The limits of a sum do not need to be integers. For example,
|
|
@samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
|
|
Calc computes the number of iterations using the formula
|
|
@samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
|
|
after simplification as if by @kbd{a s}, evaluate to an integer.
|
|
|
|
If the number of iterations according to the above formula does
|
|
not come out to an integer, the sum is invalid and will be left
|
|
in symbolic form. However, closed forms are still supplied, and
|
|
you are on your honor not to misuse the resulting formulas by
|
|
substituting mismatched bounds into them. For example,
|
|
@samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
|
|
evaluate the closed form solution for the limits 1 and 10 to get
|
|
the rather dubious answer, 29.25.
|
|
|
|
If the lower limit is greater than the upper limit (assuming a
|
|
positive step size), the result is generally zero. However,
|
|
Calc only guarantees a zero result when the upper limit is
|
|
exactly one step less than the lower limit, i.e., if the number
|
|
of iterations is @mathit{-1}. Thus @samp{sum(f(k), k, n, n-1)} is zero
|
|
but the sum from @samp{n} to @samp{n-2} may report a nonzero value
|
|
if Calc used a closed form solution.
|
|
|
|
Calc's logical predicates like @expr{a < b} return 1 for ``true''
|
|
and 0 for ``false.'' @xref{Logical Operations}. This can be
|
|
used to advantage for building conditional sums. For example,
|
|
@samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
|
|
prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
|
|
its argument is prime and 0 otherwise. You can read this expression
|
|
as ``the sum of @expr{k^2}, where @expr{k} is prime.'' Indeed,
|
|
@samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
|
|
squared, since the limits default to plus and minus infinity, but
|
|
there are no such sums that Calc's built-in rules can do in
|
|
closed form.
|
|
|
|
As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
|
|
sum of @expr{f(k)} for all @expr{k} from 1 to @expr{n}, excluding
|
|
one value @expr{k_0}. Slightly more tricky is the summand
|
|
@samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
|
|
the sum of all @expr{1/(k-k_0)} except at @expr{k = k_0}, where
|
|
this would be a division by zero. But at @expr{k = k_0}, this
|
|
formula works out to the indeterminate form @expr{0 / 0}, which
|
|
Calc will not assume is zero. Better would be to use
|
|
@samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
|
|
an ``if-then-else'' test: This expression says, ``if
|
|
@texline @math{k \ne k_0},
|
|
@infoline @expr{k != k_0},
|
|
then @expr{1/(k-k_0)}, else zero.'' Now the formula @expr{1/(k-k_0)}
|
|
will not even be evaluated by Calc when @expr{k = k_0}.
|
|
|
|
@cindex Alternating sums
|
|
@kindex a -
|
|
@pindex calc-alt-summation
|
|
@tindex asum
|
|
The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
|
|
computes an alternating sum. Successive terms of the sequence
|
|
are given alternating signs, with the first term (corresponding
|
|
to the lower index value) being positive. Alternating sums
|
|
are converted to normal sums with an extra term of the form
|
|
@samp{(-1)^(k-@var{low})}. This formula is adjusted appropriately
|
|
if the step value is other than one. For example, the Taylor
|
|
series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
|
|
(Calc cannot evaluate this infinite series, but it can approximate
|
|
it if you replace @code{inf} with any particular odd number.)
|
|
Calc converts this series to a regular sum with a step of one,
|
|
namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
|
|
|
|
@cindex Product of a sequence
|
|
@kindex a *
|
|
@pindex calc-product
|
|
@tindex prod
|
|
The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
|
|
the analogous way to take a product of many terms. Calc also knows
|
|
some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
|
|
Conditional products can be written @samp{prod(k^prime(k), k, 1, n)}
|
|
or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
|
|
|
|
@kindex a T
|
|
@pindex calc-tabulate
|
|
@tindex table
|
|
The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
|
|
evaluates a formula at a series of iterated index values, just
|
|
like @code{sum} and @code{prod}, but its result is simply a
|
|
vector of the results. For example, @samp{table(a_i, i, 1, 7, 2)}
|
|
produces @samp{[a_1, a_3, a_5, a_7]}.
|
|
|
|
@node Logical Operations, Rewrite Rules, Summations, Algebra
|
|
@section Logical Operations
|
|
|
|
@noindent
|
|
The following commands and algebraic functions return true/false values,
|
|
where 1 represents ``true'' and 0 represents ``false.'' In cases where
|
|
a truth value is required (such as for the condition part of a rewrite
|
|
rule, or as the condition for a @w{@kbd{Z [ Z ]}} control structure), any
|
|
nonzero value is accepted to mean ``true.'' (Specifically, anything
|
|
for which @code{dnonzero} returns 1 is ``true,'' and anything for
|
|
which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
|
|
Note that this means that @w{@kbd{Z [ Z ]}} will execute the ``then''
|
|
portion if its condition is provably true, but it will execute the
|
|
``else'' portion for any condition like @expr{a = b} that is not
|
|
provably true, even if it might be true. Algebraic functions that
|
|
have conditions as arguments, like @code{? :} and @code{&&}, remain
|
|
unevaluated if the condition is neither provably true nor provably
|
|
false. @xref{Declarations}.)
|
|
|
|
@kindex a =
|
|
@pindex calc-equal-to
|
|
@tindex eq
|
|
@tindex =
|
|
@tindex ==
|
|
The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
|
|
(which can also be written @samp{a = b} or @samp{a == b} in an algebraic
|
|
formula) is true if @expr{a} and @expr{b} are equal, either because they
|
|
are identical expressions, or because they are numbers which are
|
|
numerically equal. (Thus the integer 1 is considered equal to the float
|
|
1.0.) If the equality of @expr{a} and @expr{b} cannot be determined,
|
|
the comparison is left in symbolic form. Note that as a command, this
|
|
operation pops two values from the stack and pushes back either a 1 or
|
|
a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
|
|
|
|
Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
|
|
For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
|
|
an equation to solve for a given variable. The @kbd{a M}
|
|
(@code{calc-map-equation}) command can be used to apply any
|
|
function to both sides of an equation; for example, @kbd{2 a M *}
|
|
multiplies both sides of the equation by two. Note that just
|
|
@kbd{2 *} would not do the same thing; it would produce the formula
|
|
@samp{2 (a = b)} which represents 2 if the equality is true or
|
|
zero if not.
|
|
|
|
The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
|
|
or @samp{a = b = c}) tests if all of its arguments are equal. In
|
|
algebraic notation, the @samp{=} operator is unusual in that it is
|
|
neither left- nor right-associative: @samp{a = b = c} is not the
|
|
same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
|
|
one variable with the 1 or 0 that results from comparing two other
|
|
variables).
|
|
|
|
@kindex a #
|
|
@pindex calc-not-equal-to
|
|
@tindex neq
|
|
@tindex !=
|
|
The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
|
|
@samp{a != b} function, is true if @expr{a} and @expr{b} are not equal.
|
|
This also works with more than two arguments; @samp{a != b != c != d}
|
|
tests that all four of @expr{a}, @expr{b}, @expr{c}, and @expr{d} are
|
|
distinct numbers.
|
|
|
|
@kindex a <
|
|
@tindex lt
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex a >
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex a [
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex a ]
|
|
@pindex calc-less-than
|
|
@pindex calc-greater-than
|
|
@pindex calc-less-equal
|
|
@pindex calc-greater-equal
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex gt
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex leq
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex geq
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex <
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex >
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex <=
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex >=
|
|
The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
|
|
operation is true if @expr{a} is less than @expr{b}. Similar functions
|
|
are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
|
|
@kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
|
|
@kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
|
|
|
|
While the inequality functions like @code{lt} do not accept more
|
|
than two arguments, the syntax @w{@samp{a <= b < c}} is translated to an
|
|
equivalent expression involving intervals: @samp{b in [a .. c)}.
|
|
(See the description of @code{in} below.) All four combinations
|
|
of @samp{<} and @samp{<=} are allowed, or any of the four combinations
|
|
of @samp{>} and @samp{>=}. Four-argument constructions like
|
|
@samp{a < b < c < d}, and mixtures like @w{@samp{a < b = c}} that
|
|
involve both equalities and inequalities, are not allowed.
|
|
|
|
@kindex a .
|
|
@pindex calc-remove-equal
|
|
@tindex rmeq
|
|
The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
|
|
the righthand side of the equation or inequality on the top of the
|
|
stack. It also works elementwise on vectors. For example, if
|
|
@samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
|
|
@samp{[2.34, z / 2]}. As a special case, if the righthand side is a
|
|
variable and the lefthand side is a number (as in @samp{2.34 = x}), then
|
|
Calc keeps the lefthand side instead. Finally, this command works with
|
|
assignments @samp{x := 2.34} as well as equations, always taking the
|
|
righthand side, and for @samp{=>} (evaluates-to) operators, always
|
|
taking the lefthand side.
|
|
|
|
@kindex a &
|
|
@pindex calc-logical-and
|
|
@tindex land
|
|
@tindex &&
|
|
The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
|
|
function is true if both of its arguments are true, i.e., are
|
|
non-zero numbers. In this case, the result will be either @expr{a} or
|
|
@expr{b}, chosen arbitrarily. If either argument is zero, the result is
|
|
zero. Otherwise, the formula is left in symbolic form.
|
|
|
|
@kindex a |
|
|
@pindex calc-logical-or
|
|
@tindex lor
|
|
@tindex ||
|
|
The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
|
|
function is true if either or both of its arguments are true (nonzero).
|
|
The result is whichever argument was nonzero, choosing arbitrarily if both
|
|
are nonzero. If both @expr{a} and @expr{b} are zero, the result is
|
|
zero.
|
|
|
|
@kindex a !
|
|
@pindex calc-logical-not
|
|
@tindex lnot
|
|
@tindex !
|
|
The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
|
|
function is true if @expr{a} is false (zero), or false if @expr{a} is
|
|
true (nonzero). It is left in symbolic form if @expr{a} is not a
|
|
number.
|
|
|
|
@kindex a :
|
|
@pindex calc-logical-if
|
|
@tindex if
|
|
@ignore
|
|
@mindex ? :
|
|
@end ignore
|
|
@tindex ?
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@tindex :
|
|
@cindex Arguments, not evaluated
|
|
The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
|
|
function is equal to either @expr{b} or @expr{c} if @expr{a} is a nonzero
|
|
number or zero, respectively. If @expr{a} is not a number, the test is
|
|
left in symbolic form and neither @expr{b} nor @expr{c} is evaluated in
|
|
any way. In algebraic formulas, this is one of the few Calc functions
|
|
whose arguments are not automatically evaluated when the function itself
|
|
is evaluated. The others are @code{lambda}, @code{quote}, and
|
|
@code{condition}.
|
|
|
|
One minor surprise to watch out for is that the formula @samp{a?3:4}
|
|
will not work because the @samp{3:4} is parsed as a fraction instead of
|
|
as three separate symbols. Type something like @samp{a ? 3 : 4} or
|
|
@samp{a?(3):4} instead.
|
|
|
|
As a special case, if @expr{a} evaluates to a vector, then both @expr{b}
|
|
and @expr{c} are evaluated; the result is a vector of the same length
|
|
as @expr{a} whose elements are chosen from corresponding elements of
|
|
@expr{b} and @expr{c} according to whether each element of @expr{a}
|
|
is zero or nonzero. Each of @expr{b} and @expr{c} must be either a
|
|
vector of the same length as @expr{a}, or a non-vector which is matched
|
|
with all elements of @expr{a}.
|
|
|
|
@kindex a @{
|
|
@pindex calc-in-set
|
|
@tindex in
|
|
The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
|
|
the number @expr{a} is in the set of numbers represented by @expr{b}.
|
|
If @expr{b} is an interval form, @expr{a} must be one of the values
|
|
encompassed by the interval. If @expr{b} is a vector, @expr{a} must be
|
|
equal to one of the elements of the vector. (If any vector elements are
|
|
intervals, @expr{a} must be in any of the intervals.) If @expr{b} is a
|
|
plain number, @expr{a} must be numerically equal to @expr{b}.
|
|
@xref{Set Operations}, for a group of commands that manipulate sets
|
|
of this sort.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex typeof
|
|
The @samp{typeof(a)} function produces an integer or variable which
|
|
characterizes @expr{a}. If @expr{a} is a number, vector, or variable,
|
|
the result will be one of the following numbers:
|
|
|
|
@example
|
|
1 Integer
|
|
2 Fraction
|
|
3 Floating-point number
|
|
4 HMS form
|
|
5 Rectangular complex number
|
|
6 Polar complex number
|
|
7 Error form
|
|
8 Interval form
|
|
9 Modulo form
|
|
10 Date-only form
|
|
11 Date/time form
|
|
12 Infinity (inf, uinf, or nan)
|
|
100 Variable
|
|
101 Vector (but not a matrix)
|
|
102 Matrix
|
|
@end example
|
|
|
|
Otherwise, @expr{a} is a formula, and the result is a variable which
|
|
represents the name of the top-level function call.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex integer
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex real
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex constant
|
|
The @samp{integer(a)} function returns true if @expr{a} is an integer.
|
|
The @samp{real(a)} function
|
|
is true if @expr{a} is a real number, either integer, fraction, or
|
|
float. The @samp{constant(a)} function returns true if @expr{a} is
|
|
any of the objects for which @code{typeof} would produce an integer
|
|
code result except for variables, and provided that the components of
|
|
an object like a vector or error form are themselves constant.
|
|
Note that infinities do not satisfy any of these tests, nor do
|
|
special constants like @code{pi} and @code{e}.
|
|
|
|
@xref{Declarations}, for a set of similar functions that recognize
|
|
formulas as well as actual numbers. For example, @samp{dint(floor(x))}
|
|
is true because @samp{floor(x)} is provably integer-valued, but
|
|
@samp{integer(floor(x))} does not because @samp{floor(x)} is not
|
|
literally an integer constant.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex refers
|
|
The @samp{refers(a,b)} function is true if the variable (or sub-expression)
|
|
@expr{b} appears in @expr{a}, or false otherwise. Unlike the other
|
|
tests described here, this function returns a definite ``no'' answer
|
|
even if its arguments are still in symbolic form. The only case where
|
|
@code{refers} will be left unevaluated is if @expr{a} is a plain
|
|
variable (different from @expr{b}).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex negative
|
|
The @samp{negative(a)} function returns true if @expr{a} ``looks'' negative,
|
|
because it is a negative number, because it is of the form @expr{-x},
|
|
or because it is a product or quotient with a term that looks negative.
|
|
This is most useful in rewrite rules. Beware that @samp{negative(a)}
|
|
evaluates to 1 or 0 for @emph{any} argument @expr{a}, so it can only
|
|
be stored in a formula if the default simplifications are turned off
|
|
first with @kbd{m O} (or if it appears in an unevaluated context such
|
|
as a rewrite rule condition).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex variable
|
|
The @samp{variable(a)} function is true if @expr{a} is a variable,
|
|
or false if not. If @expr{a} is a function call, this test is left
|
|
in symbolic form. Built-in variables like @code{pi} and @code{inf}
|
|
are considered variables like any others by this test.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex nonvar
|
|
The @samp{nonvar(a)} function is true if @expr{a} is a non-variable.
|
|
If its argument is a variable it is left unsimplified; it never
|
|
actually returns zero. However, since Calc's condition-testing
|
|
commands consider ``false'' anything not provably true, this is
|
|
often good enough.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex lin
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex linnt
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex islin
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex islinnt
|
|
@cindex Linearity testing
|
|
The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
|
|
check if an expression is ``linear,'' i.e., can be written in the form
|
|
@expr{a + b x} for some constants @expr{a} and @expr{b}, and some
|
|
variable or subformula @expr{x}. The function @samp{islin(f,x)} checks
|
|
if formula @expr{f} is linear in @expr{x}, returning 1 if so. For
|
|
example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
|
|
@samp{islin(x y / 3 - 2, x)} all return 1. The @samp{lin(f,x)} function
|
|
is similar, except that instead of returning 1 it returns the vector
|
|
@expr{[a, b, x]}. For the above examples, this vector would be
|
|
@expr{[0, 1, x]}, @expr{[0, -1, x]}, @expr{[3, 0, x]}, and
|
|
@expr{[-2, y/3, x]}, respectively. Both @code{lin} and @code{islin}
|
|
generally remain unevaluated for expressions which are not linear,
|
|
e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}. The second
|
|
argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
|
|
returns true.
|
|
|
|
The @code{linnt} and @code{islinnt} functions perform a similar check,
|
|
but require a ``non-trivial'' linear form, which means that the
|
|
@expr{b} coefficient must be non-zero. For example, @samp{lin(2,x)}
|
|
returns @expr{[2, 0, x]} and @samp{lin(y,x)} returns @expr{[y, 0, x]},
|
|
but @samp{linnt(2,x)} and @samp{linnt(y,x)} are left unevaluated
|
|
(in other words, these formulas are considered to be only ``trivially''
|
|
linear in @expr{x}).
|
|
|
|
All four linearity-testing functions allow you to omit the second
|
|
argument, in which case the input may be linear in any non-constant
|
|
formula. Here, the @expr{a=0}, @expr{b=1} case is also considered
|
|
trivial, and only constant values for @expr{a} and @expr{b} are
|
|
recognized. Thus, @samp{lin(2 x y)} returns @expr{[0, 2, x y]},
|
|
@samp{lin(2 - x y)} returns @expr{[2, -1, x y]}, and @samp{lin(x y)}
|
|
returns @expr{[0, 1, x y]}. The @code{linnt} function would allow the
|
|
first two cases but not the third. Also, neither @code{lin} nor
|
|
@code{linnt} accept plain constants as linear in the one-argument
|
|
case: @samp{islin(2,x)} is true, but @samp{islin(2)} is false.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex istrue
|
|
The @samp{istrue(a)} function returns 1 if @expr{a} is a nonzero
|
|
number or provably nonzero formula, or 0 if @expr{a} is anything else.
|
|
Calls to @code{istrue} can only be manipulated if @kbd{m O} mode is
|
|
used to make sure they are not evaluated prematurely. (Note that
|
|
declarations are used when deciding whether a formula is true;
|
|
@code{istrue} returns 1 when @code{dnonzero} would return 1, and
|
|
it returns 0 when @code{dnonzero} would return 0 or leave itself
|
|
in symbolic form.)
|
|
|
|
@node Rewrite Rules, , Logical Operations, Algebra
|
|
@section Rewrite Rules
|
|
|
|
@noindent
|
|
@cindex Rewrite rules
|
|
@cindex Transformations
|
|
@cindex Pattern matching
|
|
@kindex a r
|
|
@pindex calc-rewrite
|
|
@tindex rewrite
|
|
The @kbd{a r} (@code{calc-rewrite}) [@code{rewrite}] command makes
|
|
substitutions in a formula according to a specified pattern or patterns
|
|
known as @dfn{rewrite rules}. Whereas @kbd{a b} (@code{calc-substitute})
|
|
matches literally, so that substituting @samp{sin(x)} with @samp{cos(x)}
|
|
matches only the @code{sin} function applied to the variable @code{x},
|
|
rewrite rules match general kinds of formulas; rewriting using the rule
|
|
@samp{sin(x) := cos(x)} matches @code{sin} of any argument and replaces
|
|
it with @code{cos} of that same argument. The only significance of the
|
|
name @code{x} is that the same name is used on both sides of the rule.
|
|
|
|
Rewrite rules rearrange formulas already in Calc's memory.
|
|
@xref{Syntax Tables}, to read about @dfn{syntax rules}, which are
|
|
similar to algebraic rewrite rules but operate when new algebraic
|
|
entries are being parsed, converting strings of characters into
|
|
Calc formulas.
|
|
|
|
@menu
|
|
* Entering Rewrite Rules::
|
|
* Basic Rewrite Rules::
|
|
* Conditional Rewrite Rules::
|
|
* Algebraic Properties of Rewrite Rules::
|
|
* Other Features of Rewrite Rules::
|
|
* Composing Patterns in Rewrite Rules::
|
|
* Nested Formulas with Rewrite Rules::
|
|
* Multi-Phase Rewrite Rules::
|
|
* Selections with Rewrite Rules::
|
|
* Matching Commands::
|
|
* Automatic Rewrites::
|
|
* Debugging Rewrites::
|
|
* Examples of Rewrite Rules::
|
|
@end menu
|
|
|
|
@node Entering Rewrite Rules, Basic Rewrite Rules, Rewrite Rules, Rewrite Rules
|
|
@subsection Entering Rewrite Rules
|
|
|
|
@noindent
|
|
Rewrite rules normally use the ``assignment'' operator
|
|
@samp{@var{old} := @var{new}}.
|
|
This operator is equivalent to the function call @samp{assign(old, new)}.
|
|
The @code{assign} function is undefined by itself in Calc, so an
|
|
assignment formula such as a rewrite rule will be left alone by ordinary
|
|
Calc commands. But certain commands, like the rewrite system, interpret
|
|
assignments in special ways.
|
|
|
|
For example, the rule @samp{sin(x)^2 := 1-cos(x)^2} says to replace
|
|
every occurrence of the sine of something, squared, with one minus the
|
|
square of the cosine of that same thing. All by itself as a formula
|
|
on the stack it does nothing, but when given to the @kbd{a r} command
|
|
it turns that command into a sine-squared-to-cosine-squared converter.
|
|
|
|
To specify a set of rules to be applied all at once, make a vector of
|
|
rules.
|
|
|
|
When @kbd{a r} prompts you to enter the rewrite rules, you can answer
|
|
in several ways:
|
|
|
|
@enumerate
|
|
@item
|
|
With a rule: @kbd{f(x) := g(x) @key{RET}}.
|
|
@item
|
|
With a vector of rules: @kbd{[f1(x) := g1(x), f2(x) := g2(x)] @key{RET}}.
|
|
(You can omit the enclosing square brackets if you wish.)
|
|
@item
|
|
With the name of a variable that contains the rule or rules vector:
|
|
@kbd{myrules @key{RET}}.
|
|
@item
|
|
With any formula except a rule, a vector, or a variable name; this
|
|
will be interpreted as the @var{old} half of a rewrite rule,
|
|
and you will be prompted a second time for the @var{new} half:
|
|
@kbd{f(x) @key{RET} g(x) @key{RET}}.
|
|
@item
|
|
With a blank line, in which case the rule, rules vector, or variable
|
|
will be taken from the top of the stack (and the formula to be
|
|
rewritten will come from the second-to-top position).
|
|
@end enumerate
|
|
|
|
If you enter the rules directly (as opposed to using rules stored
|
|
in a variable), those rules will be put into the Trail so that you
|
|
can retrieve them later. @xref{Trail Commands}.
|
|
|
|
It is most convenient to store rules you use often in a variable and
|
|
invoke them by giving the variable name. The @kbd{s e}
|
|
(@code{calc-edit-variable}) command is an easy way to create or edit a
|
|
rule set stored in a variable. You may also wish to use @kbd{s p}
|
|
(@code{calc-permanent-variable}) to save your rules permanently;
|
|
@pxref{Operations on Variables}.
|
|
|
|
Rewrite rules are compiled into a special internal form for faster
|
|
matching. If you enter a rule set directly it must be recompiled
|
|
every time. If you store the rules in a variable and refer to them
|
|
through that variable, they will be compiled once and saved away
|
|
along with the variable for later reference. This is another good
|
|
reason to store your rules in a variable.
|
|
|
|
Calc also accepts an obsolete notation for rules, as vectors
|
|
@samp{[@var{old}, @var{new}]}. But because it is easily confused with a
|
|
vector of two rules, the use of this notation is no longer recommended.
|
|
|
|
@node Basic Rewrite Rules, Conditional Rewrite Rules, Entering Rewrite Rules, Rewrite Rules
|
|
@subsection Basic Rewrite Rules
|
|
|
|
@noindent
|
|
To match a particular formula @expr{x} with a particular rewrite rule
|
|
@samp{@var{old} := @var{new}}, Calc compares the structure of @expr{x} with
|
|
the structure of @var{old}. Variables that appear in @var{old} are
|
|
treated as @dfn{meta-variables}; the corresponding positions in @expr{x}
|
|
may contain any sub-formulas. For example, the pattern @samp{f(x,y)}
|
|
would match the expression @samp{f(12, a+1)} with the meta-variable
|
|
@samp{x} corresponding to 12 and with @samp{y} corresponding to
|
|
@samp{a+1}. However, this pattern would not match @samp{f(12)} or
|
|
@samp{g(12, a+1)}, since there is no assignment of the meta-variables
|
|
that will make the pattern match these expressions. Notice that if
|
|
the pattern is a single meta-variable, it will match any expression.
|
|
|
|
If a given meta-variable appears more than once in @var{old}, the
|
|
corresponding sub-formulas of @expr{x} must be identical. Thus
|
|
the pattern @samp{f(x,x)} would match @samp{f(12, 12)} and
|
|
@samp{f(a+1, a+1)} but not @samp{f(12, a+1)} or @samp{f(a+b, b+a)}.
|
|
(@xref{Conditional Rewrite Rules}, for a way to match the latter.)
|
|
|
|
Things other than variables must match exactly between the pattern
|
|
and the target formula. To match a particular variable exactly, use
|
|
the pseudo-function @samp{quote(v)} in the pattern. For example, the
|
|
pattern @samp{x+quote(y)} matches @samp{x+y}, @samp{2+y}, or
|
|
@samp{sin(a)+y}.
|
|
|
|
The special variable names @samp{e}, @samp{pi}, @samp{i}, @samp{phi},
|
|
@samp{gamma}, @samp{inf}, @samp{uinf}, and @samp{nan} always match
|
|
literally. Thus the pattern @samp{sin(d + e + f)} acts exactly like
|
|
@samp{sin(d + quote(e) + f)}.
|
|
|
|
If the @var{old} pattern is found to match a given formula, that
|
|
formula is replaced by @var{new}, where any occurrences in @var{new}
|
|
of meta-variables from the pattern are replaced with the sub-formulas
|
|
that they matched. Thus, applying the rule @samp{f(x,y) := g(y+x,x)}
|
|
to @samp{f(12, a+1)} would produce @samp{g(a+13, 12)}.
|
|
|
|
The normal @kbd{a r} command applies rewrite rules over and over
|
|
throughout the target formula until no further changes are possible
|
|
(up to a limit of 100 times). Use @kbd{C-u 1 a r} to make only one
|
|
change at a time.
|
|
|
|
@node Conditional Rewrite Rules, Algebraic Properties of Rewrite Rules, Basic Rewrite Rules, Rewrite Rules
|
|
@subsection Conditional Rewrite Rules
|
|
|
|
@noindent
|
|
A rewrite rule can also be @dfn{conditional}, written in the form
|
|
@samp{@var{old} := @var{new} :: @var{cond}}. (There is also the obsolete
|
|
form @samp{[@var{old}, @var{new}, @var{cond}]}.) If a @var{cond} part
|
|
is present in the
|
|
rule, this is an additional condition that must be satisfied before
|
|
the rule is accepted. Once @var{old} has been successfully matched
|
|
to the target expression, @var{cond} is evaluated (with all the
|
|
meta-variables substituted for the values they matched) and simplified
|
|
with @kbd{a s} (@code{calc-simplify}). If the result is a nonzero
|
|
number or any other object known to be nonzero (@pxref{Declarations}),
|
|
the rule is accepted. If the result is zero or if it is a symbolic
|
|
formula that is not known to be nonzero, the rule is rejected.
|
|
@xref{Logical Operations}, for a number of functions that return
|
|
1 or 0 according to the results of various tests.
|
|
|
|
For example, the formula @samp{n > 0} simplifies to 1 or 0 if @expr{n}
|
|
is replaced by a positive or nonpositive number, respectively (or if
|
|
@expr{n} has been declared to be positive or nonpositive). Thus,
|
|
the rule @samp{f(x,y) := g(y+x,x) :: x+y > 0} would apply to
|
|
@samp{f(0, 4)} but not to @samp{f(-3, 2)} or @samp{f(12, a+1)}
|
|
(assuming no outstanding declarations for @expr{a}). In the case of
|
|
@samp{f(-3, 2)}, the condition can be shown not to be satisfied; in
|
|
the case of @samp{f(12, a+1)}, the condition merely cannot be shown
|
|
to be satisfied, but that is enough to reject the rule.
|
|
|
|
While Calc will use declarations to reason about variables in the
|
|
formula being rewritten, declarations do not apply to meta-variables.
|
|
For example, the rule @samp{f(a) := g(a+1)} will match for any values
|
|
of @samp{a}, such as complex numbers, vectors, or formulas, even if
|
|
@samp{a} has been declared to be real or scalar. If you want the
|
|
meta-variable @samp{a} to match only literal real numbers, use
|
|
@samp{f(a) := g(a+1) :: real(a)}. If you want @samp{a} to match only
|
|
reals and formulas which are provably real, use @samp{dreal(a)} as
|
|
the condition.
|
|
|
|
The @samp{::} operator is a shorthand for the @code{condition}
|
|
function; @samp{@var{old} := @var{new} :: @var{cond}} is equivalent to
|
|
the formula @samp{condition(assign(@var{old}, @var{new}), @var{cond})}.
|
|
|
|
If you have several conditions, you can use @samp{... :: c1 :: c2 :: c3}
|
|
or @samp{... :: c1 && c2 && c3}. The two are entirely equivalent.
|
|
|
|
It is also possible to embed conditions inside the pattern:
|
|
@samp{f(x :: x>0, y) := g(y+x, x)}. This is purely a notational
|
|
convenience, though; where a condition appears in a rule has no
|
|
effect on when it is tested. The rewrite-rule compiler automatically
|
|
decides when it is best to test each condition while a rule is being
|
|
matched.
|
|
|
|
Certain conditions are handled as special cases by the rewrite rule
|
|
system and are tested very efficiently: Where @expr{x} is any
|
|
meta-variable, these conditions are @samp{integer(x)}, @samp{real(x)},
|
|
@samp{constant(x)}, @samp{negative(x)}, @samp{x >= y} where @expr{y}
|
|
is either a constant or another meta-variable and @samp{>=} may be
|
|
replaced by any of the six relational operators, and @samp{x % a = b}
|
|
where @expr{a} and @expr{b} are constants. Other conditions, like
|
|
@samp{x >= y+1} or @samp{dreal(x)}, will be less efficient to check
|
|
since Calc must bring the whole evaluator and simplifier into play.
|
|
|
|
An interesting property of @samp{::} is that neither of its arguments
|
|
will be touched by Calc's default simplifications. This is important
|
|
because conditions often are expressions that cannot safely be
|
|
evaluated early. For example, the @code{typeof} function never
|
|
remains in symbolic form; entering @samp{typeof(a)} will put the
|
|
number 100 (the type code for variables like @samp{a}) on the stack.
|
|
But putting the condition @samp{... :: typeof(a) = 6} on the stack
|
|
is safe since @samp{::} prevents the @code{typeof} from being
|
|
evaluated until the condition is actually used by the rewrite system.
|
|
|
|
Since @samp{::} protects its lefthand side, too, you can use a dummy
|
|
condition to protect a rule that must itself not evaluate early.
|
|
For example, it's not safe to put @samp{a(f,x) := apply(f, [x])} on
|
|
the stack because it will immediately evaluate to @samp{a(f,x) := f(x)},
|
|
where the meta-variable-ness of @code{f} on the righthand side has been
|
|
lost. But @samp{a(f,x) := apply(f, [x]) :: 1} is safe, and of course
|
|
the condition @samp{1} is always true (nonzero) so it has no effect on
|
|
the functioning of the rule. (The rewrite compiler will ensure that
|
|
it doesn't even impact the speed of matching the rule.)
|
|
|
|
@node Algebraic Properties of Rewrite Rules, Other Features of Rewrite Rules, Conditional Rewrite Rules, Rewrite Rules
|
|
@subsection Algebraic Properties of Rewrite Rules
|
|
|
|
@noindent
|
|
The rewrite mechanism understands the algebraic properties of functions
|
|
like @samp{+} and @samp{*}. In particular, pattern matching takes
|
|
the associativity and commutativity of the following functions into
|
|
account:
|
|
|
|
@smallexample
|
|
+ - * = != && || and or xor vint vunion vxor gcd lcm max min beta
|
|
@end smallexample
|
|
|
|
For example, the rewrite rule:
|
|
|
|
@example
|
|
a x + b x := (a + b) x
|
|
@end example
|
|
|
|
@noindent
|
|
will match formulas of the form,
|
|
|
|
@example
|
|
a x + b x, x a + x b, a x + x b, x a + b x
|
|
@end example
|
|
|
|
Rewrites also understand the relationship between the @samp{+} and @samp{-}
|
|
operators. The above rewrite rule will also match the formulas,
|
|
|
|
@example
|
|
a x - b x, x a - x b, a x - x b, x a - b x
|
|
@end example
|
|
|
|
@noindent
|
|
by matching @samp{b} in the pattern to @samp{-b} from the formula.
|
|
|
|
Applied to a sum of many terms like @samp{r + a x + s + b x + t}, this
|
|
pattern will check all pairs of terms for possible matches. The rewrite
|
|
will take whichever suitable pair it discovers first.
|
|
|
|
In general, a pattern using an associative operator like @samp{a + b}
|
|
will try @var{2 n} different ways to match a sum of @var{n} terms
|
|
like @samp{x + y + z - w}. First, @samp{a} is matched against each
|
|
of @samp{x}, @samp{y}, @samp{z}, and @samp{-w} in turn, with @samp{b}
|
|
being matched to the remainders @samp{y + z - w}, @samp{x + z - w}, etc.
|
|
If none of these succeed, then @samp{b} is matched against each of the
|
|
four terms with @samp{a} matching the remainder. Half-and-half matches,
|
|
like @samp{(x + y) + (z - w)}, are not tried.
|
|
|
|
Note that @samp{*} is not commutative when applied to matrices, but
|
|
rewrite rules pretend that it is. If you type @kbd{m v} to enable
|
|
Matrix mode (@pxref{Matrix Mode}), rewrite rules will match @samp{*}
|
|
literally, ignoring its usual commutativity property. (In the
|
|
current implementation, the associativity also vanishes---it is as
|
|
if the pattern had been enclosed in a @code{plain} marker; see below.)
|
|
If you are applying rewrites to formulas with matrices, it's best to
|
|
enable Matrix mode first to prevent algebraically incorrect rewrites
|
|
from occurring.
|
|
|
|
The pattern @samp{-x} will actually match any expression. For example,
|
|
the rule
|
|
|
|
@example
|
|
f(-x) := -f(x)
|
|
@end example
|
|
|
|
@noindent
|
|
will rewrite @samp{f(a)} to @samp{-f(-a)}. To avoid this, either use
|
|
a @code{plain} marker as described below, or add a @samp{negative(x)}
|
|
condition. The @code{negative} function is true if its argument
|
|
``looks'' negative, for example, because it is a negative number or
|
|
because it is a formula like @samp{-x}. The new rule using this
|
|
condition is:
|
|
|
|
@example
|
|
f(x) := -f(-x) :: negative(x) @r{or, equivalently,}
|
|
f(-x) := -f(x) :: negative(-x)
|
|
@end example
|
|
|
|
In the same way, the pattern @samp{x - y} will match the sum @samp{a + b}
|
|
by matching @samp{y} to @samp{-b}.
|
|
|
|
The pattern @samp{a b} will also match the formula @samp{x/y} if
|
|
@samp{y} is a number. Thus the rule @samp{a x + @w{b x} := (a+b) x}
|
|
will also convert @samp{a x + x / 2} to @samp{(a + 0.5) x} (or
|
|
@samp{(a + 1:2) x}, depending on the current fraction mode).
|
|
|
|
Calc will @emph{not} take other liberties with @samp{*}, @samp{/}, and
|
|
@samp{^}. For example, the pattern @samp{f(a b)} will not match
|
|
@samp{f(x^2)}, and @samp{f(a + b)} will not match @samp{f(2 x)}, even
|
|
though conceivably these patterns could match with @samp{a = b = x}.
|
|
Nor will @samp{f(a b)} match @samp{f(x / y)} if @samp{y} is not a
|
|
constant, even though it could be considered to match with @samp{a = x}
|
|
and @samp{b = 1/y}. The reasons are partly for efficiency, and partly
|
|
because while few mathematical operations are substantively different
|
|
for addition and subtraction, often it is preferable to treat the cases
|
|
of multiplication, division, and integer powers separately.
|
|
|
|
Even more subtle is the rule set
|
|
|
|
@example
|
|
[ f(a) + f(b) := f(a + b), -f(a) := f(-a) ]
|
|
@end example
|
|
|
|
@noindent
|
|
attempting to match @samp{f(x) - f(y)}. You might think that Calc
|
|
will view this subtraction as @samp{f(x) + (-f(y))} and then apply
|
|
the above two rules in turn, but actually this will not work because
|
|
Calc only does this when considering rules for @samp{+} (like the
|
|
first rule in this set). So it will see first that @samp{f(x) + (-f(y))}
|
|
does not match @samp{f(a) + f(b)} for any assignments of the
|
|
meta-variables, and then it will see that @samp{f(x) - f(y)} does
|
|
not match @samp{-f(a)} for any assignment of @samp{a}. Because Calc
|
|
tries only one rule at a time, it will not be able to rewrite
|
|
@samp{f(x) - f(y)} with this rule set. An explicit @samp{f(a) - f(b)}
|
|
rule will have to be added.
|
|
|
|
Another thing patterns will @emph{not} do is break up complex numbers.
|
|
The pattern @samp{myconj(a + @w{b i)} := a - b i} will work for formulas
|
|
involving the special constant @samp{i} (such as @samp{3 - 4 i}), but
|
|
it will not match actual complex numbers like @samp{(3, -4)}. A version
|
|
of the above rule for complex numbers would be
|
|
|
|
@example
|
|
myconj(a) := re(a) - im(a) (0,1) :: im(a) != 0
|
|
@end example
|
|
|
|
@noindent
|
|
(Because the @code{re} and @code{im} functions understand the properties
|
|
of the special constant @samp{i}, this rule will also work for
|
|
@samp{3 - 4 i}. In fact, this particular rule would probably be better
|
|
without the @samp{im(a) != 0} condition, since if @samp{im(a) = 0} the
|
|
righthand side of the rule will still give the correct answer for the
|
|
conjugate of a real number.)
|
|
|
|
It is also possible to specify optional arguments in patterns. The rule
|
|
|
|
@example
|
|
opt(a) x + opt(b) (x^opt(c) + opt(d)) := f(a, b, c, d)
|
|
@end example
|
|
|
|
@noindent
|
|
will match the formula
|
|
|
|
@example
|
|
5 (x^2 - 4) + 3 x
|
|
@end example
|
|
|
|
@noindent
|
|
in a fairly straightforward manner, but it will also match reduced
|
|
formulas like
|
|
|
|
@example
|
|
x + x^2, 2(x + 1) - x, x + x
|
|
@end example
|
|
|
|
@noindent
|
|
producing, respectively,
|
|
|
|
@example
|
|
f(1, 1, 2, 0), f(-1, 2, 1, 1), f(1, 1, 1, 0)
|
|
@end example
|
|
|
|
(The latter two formulas can be entered only if default simplifications
|
|
have been turned off with @kbd{m O}.)
|
|
|
|
The default value for a term of a sum is zero. The default value
|
|
for a part of a product, for a power, or for the denominator of a
|
|
quotient, is one. Also, @samp{-x} matches the pattern @samp{opt(a) b}
|
|
with @samp{a = -1}.
|
|
|
|
In particular, the distributive-law rule can be refined to
|
|
|
|
@example
|
|
opt(a) x + opt(b) x := (a + b) x
|
|
@end example
|
|
|
|
@noindent
|
|
so that it will convert, e.g., @samp{a x - x}, to @samp{(a - 1) x}.
|
|
|
|
The pattern @samp{opt(a) + opt(b) x} matches almost any formulas which
|
|
are linear in @samp{x}. You can also use the @code{lin} and @code{islin}
|
|
functions with rewrite conditions to test for this; @pxref{Logical
|
|
Operations}. These functions are not as convenient to use in rewrite
|
|
rules, but they recognize more kinds of formulas as linear:
|
|
@samp{x/z} is considered linear with @expr{b = 1/z} by @code{lin},
|
|
but it will not match the above pattern because that pattern calls
|
|
for a multiplication, not a division.
|
|
|
|
As another example, the obvious rule to replace @samp{sin(x)^2 + cos(x)^2}
|
|
by 1,
|
|
|
|
@example
|
|
sin(x)^2 + cos(x)^2 := 1
|
|
@end example
|
|
|
|
@noindent
|
|
misses many cases because the sine and cosine may both be multiplied by
|
|
an equal factor. Here's a more successful rule:
|
|
|
|
@example
|
|
opt(a) sin(x)^2 + opt(a) cos(x)^2 := a
|
|
@end example
|
|
|
|
Note that this rule will @emph{not} match @samp{sin(x)^2 + 6 cos(x)^2}
|
|
because one @expr{a} would have ``matched'' 1 while the other matched 6.
|
|
|
|
Calc automatically converts a rule like
|
|
|
|
@example
|
|
f(x-1, x) := g(x)
|
|
@end example
|
|
|
|
@noindent
|
|
into the form
|
|
|
|
@example
|
|
f(temp, x) := g(x) :: temp = x-1
|
|
@end example
|
|
|
|
@noindent
|
|
(where @code{temp} stands for a new, invented meta-variable that
|
|
doesn't actually have a name). This modified rule will successfully
|
|
match @samp{f(6, 7)}, binding @samp{temp} and @samp{x} to 6 and 7,
|
|
respectively, then verifying that they differ by one even though
|
|
@samp{6} does not superficially look like @samp{x-1}.
|
|
|
|
However, Calc does not solve equations to interpret a rule. The
|
|
following rule,
|
|
|
|
@example
|
|
f(x-1, x+1) := g(x)
|
|
@end example
|
|
|
|
@noindent
|
|
will not work. That is, it will match @samp{f(a - 1 + b, a + 1 + b)}
|
|
but not @samp{f(6, 8)}. Calc always interprets at least one occurrence
|
|
of a variable by literal matching. If the variable appears ``isolated''
|
|
then Calc is smart enough to use it for literal matching. But in this
|
|
last example, Calc is forced to rewrite the rule to @samp{f(x-1, temp)
|
|
:= g(x) :: temp = x+1} where the @samp{x-1} term must correspond to an
|
|
actual ``something-minus-one'' in the target formula.
|
|
|
|
A successful way to write this would be @samp{f(x, x+2) := g(x+1)}.
|
|
You could make this resemble the original form more closely by using
|
|
@code{let} notation, which is described in the next section:
|
|
|
|
@example
|
|
f(xm1, x+1) := g(x) :: let(x := xm1+1)
|
|
@end example
|
|
|
|
Calc does this rewriting or ``conditionalizing'' for any sub-pattern
|
|
which involves only the functions in the following list, operating
|
|
only on constants and meta-variables which have already been matched
|
|
elsewhere in the pattern. When matching a function call, Calc is
|
|
careful to match arguments which are plain variables before arguments
|
|
which are calls to any of the functions below, so that a pattern like
|
|
@samp{f(x-1, x)} can be conditionalized even though the isolated
|
|
@samp{x} comes after the @samp{x-1}.
|
|
|
|
@smallexample
|
|
+ - * / \ % ^ abs sign round rounde roundu trunc floor ceil
|
|
max min re im conj arg
|
|
@end smallexample
|
|
|
|
You can suppress all of the special treatments described in this
|
|
section by surrounding a function call with a @code{plain} marker.
|
|
This marker causes the function call which is its argument to be
|
|
matched literally, without regard to commutativity, associativity,
|
|
negation, or conditionalization. When you use @code{plain}, the
|
|
``deep structure'' of the formula being matched can show through.
|
|
For example,
|
|
|
|
@example
|
|
plain(a - a b) := f(a, b)
|
|
@end example
|
|
|
|
@noindent
|
|
will match only literal subtractions. However, the @code{plain}
|
|
marker does not affect its arguments' arguments. In this case,
|
|
commutativity and associativity is still considered while matching
|
|
the @w{@samp{a b}} sub-pattern, so the whole pattern will match
|
|
@samp{x - y x} as well as @samp{x - x y}. We could go still
|
|
further and use
|
|
|
|
@example
|
|
plain(a - plain(a b)) := f(a, b)
|
|
@end example
|
|
|
|
@noindent
|
|
which would do a completely strict match for the pattern.
|
|
|
|
By contrast, the @code{quote} marker means that not only the
|
|
function name but also the arguments must be literally the same.
|
|
The above pattern will match @samp{x - x y} but
|
|
|
|
@example
|
|
quote(a - a b) := f(a, b)
|
|
@end example
|
|
|
|
@noindent
|
|
will match only the single formula @samp{a - a b}. Also,
|
|
|
|
@example
|
|
quote(a - quote(a b)) := f(a, b)
|
|
@end example
|
|
|
|
@noindent
|
|
will match only @samp{a - quote(a b)}---probably not the desired
|
|
effect!
|
|
|
|
A certain amount of algebra is also done when substituting the
|
|
meta-variables on the righthand side of a rule. For example,
|
|
in the rule
|
|
|
|
@example
|
|
a + f(b) := f(a + b)
|
|
@end example
|
|
|
|
@noindent
|
|
matching @samp{f(x) - y} would produce @samp{f((-y) + x)} if
|
|
taken literally, but the rewrite mechanism will simplify the
|
|
righthand side to @samp{f(x - y)} automatically. (Of course,
|
|
the default simplifications would do this anyway, so this
|
|
special simplification is only noticeable if you have turned the
|
|
default simplifications off.) This rewriting is done only when
|
|
a meta-variable expands to a ``negative-looking'' expression.
|
|
If this simplification is not desirable, you can use a @code{plain}
|
|
marker on the righthand side:
|
|
|
|
@example
|
|
a + f(b) := f(plain(a + b))
|
|
@end example
|
|
|
|
@noindent
|
|
In this example, we are still allowing the pattern-matcher to
|
|
use all the algebra it can muster, but the righthand side will
|
|
always simplify to a literal addition like @samp{f((-y) + x)}.
|
|
|
|
@node Other Features of Rewrite Rules, Composing Patterns in Rewrite Rules, Algebraic Properties of Rewrite Rules, Rewrite Rules
|
|
@subsection Other Features of Rewrite Rules
|
|
|
|
@noindent
|
|
Certain ``function names'' serve as markers in rewrite rules.
|
|
Here is a complete list of these markers. First are listed the
|
|
markers that work inside a pattern; then come the markers that
|
|
work in the righthand side of a rule.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex import
|
|
One kind of marker, @samp{import(x)}, takes the place of a whole
|
|
rule. Here @expr{x} is the name of a variable containing another
|
|
rule set; those rules are ``spliced into'' the rule set that
|
|
imports them. For example, if @samp{[f(a+b) := f(a) + f(b),
|
|
f(a b) := a f(b) :: real(a)]} is stored in variable @samp{linearF},
|
|
then the rule set @samp{[f(0) := 0, import(linearF)]} will apply
|
|
all three rules. It is possible to modify the imported rules
|
|
slightly: @samp{import(x, v1, x1, v2, x2, @dots{})} imports
|
|
the rule set @expr{x} with all occurrences of
|
|
@texline @math{v_1},
|
|
@infoline @expr{v1},
|
|
as either a variable name or a function name, replaced with
|
|
@texline @math{x_1}
|
|
@infoline @expr{x1}
|
|
and so on. (If
|
|
@texline @math{v_1}
|
|
@infoline @expr{v1}
|
|
is used as a function name, then
|
|
@texline @math{x_1}
|
|
@infoline @expr{x1}
|
|
must be either a function name itself or a @w{@samp{< >}} nameless
|
|
function; @pxref{Specifying Operators}.) For example, @samp{[g(0) := 0,
|
|
import(linearF, f, g)]} applies the linearity rules to the function
|
|
@samp{g} instead of @samp{f}. Imports can be nested, but the
|
|
import-with-renaming feature may fail to rename sub-imports properly.
|
|
|
|
The special functions allowed in patterns are:
|
|
|
|
@table @samp
|
|
@item quote(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex quote
|
|
This pattern matches exactly @expr{x}; variable names in @expr{x} are
|
|
not interpreted as meta-variables. The only flexibility is that
|
|
numbers are compared for numeric equality, so that the pattern
|
|
@samp{f(quote(12))} will match both @samp{f(12)} and @samp{f(12.0)}.
|
|
(Numbers are always treated this way by the rewrite mechanism:
|
|
The rule @samp{f(x,x) := g(x)} will match @samp{f(12, 12.0)}.
|
|
The rewrite may produce either @samp{g(12)} or @samp{g(12.0)}
|
|
as a result in this case.)
|
|
|
|
@item plain(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex plain
|
|
Here @expr{x} must be a function call @samp{f(x1,x2,@dots{})}. This
|
|
pattern matches a call to function @expr{f} with the specified
|
|
argument patterns. No special knowledge of the properties of the
|
|
function @expr{f} is used in this case; @samp{+} is not commutative or
|
|
associative. Unlike @code{quote}, the arguments @samp{x1,x2,@dots{}}
|
|
are treated as patterns. If you wish them to be treated ``plainly''
|
|
as well, you must enclose them with more @code{plain} markers:
|
|
@samp{plain(plain(@w{-a}) + plain(b c))}.
|
|
|
|
@item opt(x,def)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex opt
|
|
Here @expr{x} must be a variable name. This must appear as an
|
|
argument to a function or an element of a vector; it specifies that
|
|
the argument or element is optional.
|
|
As an argument to @samp{+}, @samp{-}, @samp{*}, @samp{&&}, or @samp{||},
|
|
or as the second argument to @samp{/} or @samp{^}, the value @var{def}
|
|
may be omitted. The pattern @samp{x + opt(y)} matches a sum by
|
|
binding one summand to @expr{x} and the other to @expr{y}, and it
|
|
matches anything else by binding the whole expression to @expr{x} and
|
|
zero to @expr{y}. The other operators above work similarly.
|
|
|
|
For general miscellaneous functions, the default value @code{def}
|
|
must be specified. Optional arguments are dropped starting with
|
|
the rightmost one during matching. For example, the pattern
|
|
@samp{f(opt(a,0), b, opt(c,b))} will match @samp{f(b)}, @samp{f(a,b)},
|
|
or @samp{f(a,b,c)}. Default values of zero and @expr{b} are
|
|
supplied in this example for the omitted arguments. Note that
|
|
the literal variable @expr{b} will be the default in the latter
|
|
case, @emph{not} the value that matched the meta-variable @expr{b}.
|
|
In other words, the default @var{def} is effectively quoted.
|
|
|
|
@item condition(x,c)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex condition
|
|
@tindex ::
|
|
This matches the pattern @expr{x}, with the attached condition
|
|
@expr{c}. It is the same as @samp{x :: c}.
|
|
|
|
@item pand(x,y)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pand
|
|
@tindex &&&
|
|
This matches anything that matches both pattern @expr{x} and
|
|
pattern @expr{y}. It is the same as @samp{x &&& y}.
|
|
@pxref{Composing Patterns in Rewrite Rules}.
|
|
|
|
@item por(x,y)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex por
|
|
@tindex |||
|
|
This matches anything that matches either pattern @expr{x} or
|
|
pattern @expr{y}. It is the same as @w{@samp{x ||| y}}.
|
|
|
|
@item pnot(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex pnot
|
|
@tindex !!!
|
|
This matches anything that does not match pattern @expr{x}.
|
|
It is the same as @samp{!!! x}.
|
|
|
|
@item cons(h,t)
|
|
@ignore
|
|
@mindex cons
|
|
@end ignore
|
|
@tindex cons (rewrites)
|
|
This matches any vector of one or more elements. The first
|
|
element is matched to @expr{h}; a vector of the remaining
|
|
elements is matched to @expr{t}. Note that vectors of fixed
|
|
length can also be matched as actual vectors: The rule
|
|
@samp{cons(a,cons(b,[])) := cons(a+b,[])} is equivalent
|
|
to the rule @samp{[a,b] := [a+b]}.
|
|
|
|
@item rcons(t,h)
|
|
@ignore
|
|
@mindex rcons
|
|
@end ignore
|
|
@tindex rcons (rewrites)
|
|
This is like @code{cons}, except that the @emph{last} element
|
|
is matched to @expr{h}, with the remaining elements matched
|
|
to @expr{t}.
|
|
|
|
@item apply(f,args)
|
|
@ignore
|
|
@mindex apply
|
|
@end ignore
|
|
@tindex apply (rewrites)
|
|
This matches any function call. The name of the function, in
|
|
the form of a variable, is matched to @expr{f}. The arguments
|
|
of the function, as a vector of zero or more objects, are
|
|
matched to @samp{args}. Constants, variables, and vectors
|
|
do @emph{not} match an @code{apply} pattern. For example,
|
|
@samp{apply(f,x)} matches any function call, @samp{apply(quote(f),x)}
|
|
matches any call to the function @samp{f}, @samp{apply(f,[a,b])}
|
|
matches any function call with exactly two arguments, and
|
|
@samp{apply(quote(f), cons(a,cons(b,x)))} matches any call
|
|
to the function @samp{f} with two or more arguments. Another
|
|
way to implement the latter, if the rest of the rule does not
|
|
need to refer to the first two arguments of @samp{f} by name,
|
|
would be @samp{apply(quote(f), x :: vlen(x) >= 2)}.
|
|
Here's a more interesting sample use of @code{apply}:
|
|
|
|
@example
|
|
apply(f,[x+n]) := n + apply(f,[x])
|
|
:: in(f, [floor,ceil,round,trunc]) :: integer(n)
|
|
@end example
|
|
|
|
Note, however, that this will be slower to match than a rule
|
|
set with four separate rules. The reason is that Calc sorts
|
|
the rules of a rule set according to top-level function name;
|
|
if the top-level function is @code{apply}, Calc must try the
|
|
rule for every single formula and sub-formula. If the top-level
|
|
function in the pattern is, say, @code{floor}, then Calc invokes
|
|
the rule only for sub-formulas which are calls to @code{floor}.
|
|
|
|
Formulas normally written with operators like @code{+} are still
|
|
considered function calls: @code{apply(f,x)} matches @samp{a+b}
|
|
with @samp{f = add}, @samp{x = [a,b]}.
|
|
|
|
You must use @code{apply} for meta-variables with function names
|
|
on both sides of a rewrite rule: @samp{apply(f, [x]) := f(x+1)}
|
|
is @emph{not} correct, because it rewrites @samp{spam(6)} into
|
|
@samp{f(7)}. The righthand side should be @samp{apply(f, [x+1])}.
|
|
Also note that you will have to use No-Simplify mode (@kbd{m O})
|
|
when entering this rule so that the @code{apply} isn't
|
|
evaluated immediately to get the new rule @samp{f(x) := f(x+1)}.
|
|
Or, use @kbd{s e} to enter the rule without going through the stack,
|
|
or enter the rule as @samp{apply(f, [x]) := apply(f, [x+1]) @w{:: 1}}.
|
|
@xref{Conditional Rewrite Rules}.
|
|
|
|
@item select(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex select
|
|
This is used for applying rules to formulas with selections;
|
|
@pxref{Selections with Rewrite Rules}.
|
|
@end table
|
|
|
|
Special functions for the righthand sides of rules are:
|
|
|
|
@table @samp
|
|
@item quote(x)
|
|
The notation @samp{quote(x)} is changed to @samp{x} when the
|
|
righthand side is used. As far as the rewrite rule is concerned,
|
|
@code{quote} is invisible. However, @code{quote} has the special
|
|
property in Calc that its argument is not evaluated. Thus,
|
|
while it will not work to put the rule @samp{t(a) := typeof(a)}
|
|
on the stack because @samp{typeof(a)} is evaluated immediately
|
|
to produce @samp{t(a) := 100}, you can use @code{quote} to
|
|
protect the righthand side: @samp{t(a) := quote(typeof(a))}.
|
|
(@xref{Conditional Rewrite Rules}, for another trick for
|
|
protecting rules from evaluation.)
|
|
|
|
@item plain(x)
|
|
Special properties of and simplifications for the function call
|
|
@expr{x} are not used. One interesting case where @code{plain}
|
|
is useful is the rule, @samp{q(x) := quote(x)}, trying to expand a
|
|
shorthand notation for the @code{quote} function. This rule will
|
|
not work as shown; instead of replacing @samp{q(foo)} with
|
|
@samp{quote(foo)}, it will replace it with @samp{foo}! The correct
|
|
rule would be @samp{q(x) := plain(quote(x))}.
|
|
|
|
@item cons(h,t)
|
|
Where @expr{t} is a vector, this is converted into an expanded
|
|
vector during rewrite processing. Note that @code{cons} is a regular
|
|
Calc function which normally does this anyway; the only way @code{cons}
|
|
is treated specially by rewrites is that @code{cons} on the righthand
|
|
side of a rule will be evaluated even if default simplifications
|
|
have been turned off.
|
|
|
|
@item rcons(t,h)
|
|
Analogous to @code{cons} except putting @expr{h} at the @emph{end} of
|
|
the vector @expr{t}.
|
|
|
|
@item apply(f,args)
|
|
Where @expr{f} is a variable and @var{args} is a vector, this
|
|
is converted to a function call. Once again, note that @code{apply}
|
|
is also a regular Calc function.
|
|
|
|
@item eval(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex eval
|
|
The formula @expr{x} is handled in the usual way, then the
|
|
default simplifications are applied to it even if they have
|
|
been turned off normally. This allows you to treat any function
|
|
similarly to the way @code{cons} and @code{apply} are always
|
|
treated. However, there is a slight difference: @samp{cons(2+3, [])}
|
|
with default simplifications off will be converted to @samp{[2+3]},
|
|
whereas @samp{eval(cons(2+3, []))} will be converted to @samp{[5]}.
|
|
|
|
@item evalsimp(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex evalsimp
|
|
The formula @expr{x} has meta-variables substituted in the usual
|
|
way, then algebraically simplified as if by the @kbd{a s} command.
|
|
|
|
@item evalextsimp(x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex evalextsimp
|
|
The formula @expr{x} has meta-variables substituted in the normal
|
|
way, then ``extendedly'' simplified as if by the @kbd{a e} command.
|
|
|
|
@item select(x)
|
|
@xref{Selections with Rewrite Rules}.
|
|
@end table
|
|
|
|
There are also some special functions you can use in conditions.
|
|
|
|
@table @samp
|
|
@item let(v := x)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex let
|
|
The expression @expr{x} is evaluated with meta-variables substituted.
|
|
The @kbd{a s} command's simplifications are @emph{not} applied by
|
|
default, but @expr{x} can include calls to @code{evalsimp} or
|
|
@code{evalextsimp} as described above to invoke higher levels
|
|
of simplification. The
|
|
result of @expr{x} is then bound to the meta-variable @expr{v}. As
|
|
usual, if this meta-variable has already been matched to something
|
|
else the two values must be equal; if the meta-variable is new then
|
|
it is bound to the result of the expression. This variable can then
|
|
appear in later conditions, and on the righthand side of the rule.
|
|
In fact, @expr{v} may be any pattern in which case the result of
|
|
evaluating @expr{x} is matched to that pattern, binding any
|
|
meta-variables that appear in that pattern. Note that @code{let}
|
|
can only appear by itself as a condition, or as one term of an
|
|
@samp{&&} which is a whole condition: It cannot be inside
|
|
an @samp{||} term or otherwise buried.
|
|
|
|
The alternate, equivalent form @samp{let(v, x)} is also recognized.
|
|
Note that the use of @samp{:=} by @code{let}, while still being
|
|
assignment-like in character, is unrelated to the use of @samp{:=}
|
|
in the main part of a rewrite rule.
|
|
|
|
As an example, @samp{f(a) := g(ia) :: let(ia := 1/a) :: constant(ia)}
|
|
replaces @samp{f(a)} with @samp{g} of the inverse of @samp{a}, if
|
|
that inverse exists and is constant. For example, if @samp{a} is a
|
|
singular matrix the operation @samp{1/a} is left unsimplified and
|
|
@samp{constant(ia)} fails, but if @samp{a} is an invertible matrix
|
|
then the rule succeeds. Without @code{let} there would be no way
|
|
to express this rule that didn't have to invert the matrix twice.
|
|
Note that, because the meta-variable @samp{ia} is otherwise unbound
|
|
in this rule, the @code{let} condition itself always ``succeeds''
|
|
because no matter what @samp{1/a} evaluates to, it can successfully
|
|
be bound to @code{ia}.
|
|
|
|
Here's another example, for integrating cosines of linear
|
|
terms: @samp{myint(cos(y),x) := sin(y)/b :: let([a,b,x] := lin(y,x))}.
|
|
The @code{lin} function returns a 3-vector if its argument is linear,
|
|
or leaves itself unevaluated if not. But an unevaluated @code{lin}
|
|
call will not match the 3-vector on the lefthand side of the @code{let},
|
|
so this @code{let} both verifies that @code{y} is linear, and binds
|
|
the coefficients @code{a} and @code{b} for use elsewhere in the rule.
|
|
(It would have been possible to use @samp{sin(a x + b)/b} for the
|
|
righthand side instead, but using @samp{sin(y)/b} avoids gratuitous
|
|
rearrangement of the argument of the sine.)
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex ierf
|
|
Similarly, here is a rule that implements an inverse-@code{erf}
|
|
function. It uses @code{root} to search for a solution. If
|
|
@code{root} succeeds, it will return a vector of two numbers
|
|
where the first number is the desired solution. If no solution
|
|
is found, @code{root} remains in symbolic form. So we use
|
|
@code{let} to check that the result was indeed a vector.
|
|
|
|
@example
|
|
ierf(x) := y :: let([y,z] := root(erf(a) = x, a, .5))
|
|
@end example
|
|
|
|
@item matches(v,p)
|
|
The meta-variable @var{v}, which must already have been matched
|
|
to something elsewhere in the rule, is compared against pattern
|
|
@var{p}. Since @code{matches} is a standard Calc function, it
|
|
can appear anywhere in a condition. But if it appears alone or
|
|
as a term of a top-level @samp{&&}, then you get the special
|
|
extra feature that meta-variables which are bound to things
|
|
inside @var{p} can be used elsewhere in the surrounding rewrite
|
|
rule.
|
|
|
|
The only real difference between @samp{let(p := v)} and
|
|
@samp{matches(v, p)} is that the former evaluates @samp{v} using
|
|
the default simplifications, while the latter does not.
|
|
|
|
@item remember
|
|
@vindex remember
|
|
This is actually a variable, not a function. If @code{remember}
|
|
appears as a condition in a rule, then when that rule succeeds
|
|
the original expression and rewritten expression are added to the
|
|
front of the rule set that contained the rule. If the rule set
|
|
was not stored in a variable, @code{remember} is ignored. The
|
|
lefthand side is enclosed in @code{quote} in the added rule if it
|
|
contains any variables.
|
|
|
|
For example, the rule @samp{f(n) := n f(n-1) :: remember} applied
|
|
to @samp{f(7)} will add the rule @samp{f(7) := 7 f(6)} to the front
|
|
of the rule set. The rule set @code{EvalRules} works slightly
|
|
differently: There, the evaluation of @samp{f(6)} will complete before
|
|
the result is added to the rule set, in this case as @samp{f(7) := 5040}.
|
|
Thus @code{remember} is most useful inside @code{EvalRules}.
|
|
|
|
It is up to you to ensure that the optimization performed by
|
|
@code{remember} is safe. For example, the rule @samp{foo(n) := n
|
|
:: evalv(eatfoo) > 0 :: remember} is a bad idea (@code{evalv} is
|
|
the function equivalent of the @kbd{=} command); if the variable
|
|
@code{eatfoo} ever contains 1, rules like @samp{foo(7) := 7} will
|
|
be added to the rule set and will continue to operate even if
|
|
@code{eatfoo} is later changed to 0.
|
|
|
|
@item remember(c)
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex remember
|
|
Remember the match as described above, but only if condition @expr{c}
|
|
is true. For example, @samp{remember(n % 4 = 0)} in the above factorial
|
|
rule remembers only every fourth result. Note that @samp{remember(1)}
|
|
is equivalent to @samp{remember}, and @samp{remember(0)} has no effect.
|
|
@end table
|
|
|
|
@node Composing Patterns in Rewrite Rules, Nested Formulas with Rewrite Rules, Other Features of Rewrite Rules, Rewrite Rules
|
|
@subsection Composing Patterns in Rewrite Rules
|
|
|
|
@noindent
|
|
There are three operators, @samp{&&&}, @samp{|||}, and @samp{!!!},
|
|
that combine rewrite patterns to make larger patterns. The
|
|
combinations are ``and,'' ``or,'' and ``not,'' respectively, and
|
|
these operators are the pattern equivalents of @samp{&&}, @samp{||}
|
|
and @samp{!} (which operate on zero-or-nonzero logical values).
|
|
|
|
Note that @samp{&&&}, @samp{|||}, and @samp{!!!} are left in symbolic
|
|
form by all regular Calc features; they have special meaning only in
|
|
the context of rewrite rule patterns.
|
|
|
|
The pattern @samp{@var{p1} &&& @var{p2}} matches anything that
|
|
matches both @var{p1} and @var{p2}. One especially useful case is
|
|
when one of @var{p1} or @var{p2} is a meta-variable. For example,
|
|
here is a rule that operates on error forms:
|
|
|
|
@example
|
|
f(x &&& a +/- b, x) := g(x)
|
|
@end example
|
|
|
|
This does the same thing, but is arguably simpler than, the rule
|
|
|
|
@example
|
|
f(a +/- b, a +/- b) := g(a +/- b)
|
|
@end example
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex ends
|
|
Here's another interesting example:
|
|
|
|
@example
|
|
ends(cons(a, x) &&& rcons(y, b)) := [a, b]
|
|
@end example
|
|
|
|
@noindent
|
|
which effectively clips out the middle of a vector leaving just
|
|
the first and last elements. This rule will change a one-element
|
|
vector @samp{[a]} to @samp{[a, a]}. The similar rule
|
|
|
|
@example
|
|
ends(cons(a, rcons(y, b))) := [a, b]
|
|
@end example
|
|
|
|
@noindent
|
|
would do the same thing except that it would fail to match a
|
|
one-element vector.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The pattern @samp{@var{p1} ||| @var{p2}} matches anything that
|
|
matches either @var{p1} or @var{p2}. Calc first tries matching
|
|
against @var{p1}; if that fails, it goes on to try @var{p2}.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex curve
|
|
A simple example of @samp{|||} is
|
|
|
|
@example
|
|
curve(inf ||| -inf) := 0
|
|
@end example
|
|
|
|
@noindent
|
|
which converts both @samp{curve(inf)} and @samp{curve(-inf)} to zero.
|
|
|
|
Here is a larger example:
|
|
|
|
@example
|
|
log(a, b) ||| (ln(a) :: let(b := e)) := mylog(a, b)
|
|
@end example
|
|
|
|
This matches both generalized and natural logarithms in a single rule.
|
|
Note that the @samp{::} term must be enclosed in parentheses because
|
|
that operator has lower precedence than @samp{|||} or @samp{:=}.
|
|
|
|
(In practice this rule would probably include a third alternative,
|
|
omitted here for brevity, to take care of @code{log10}.)
|
|
|
|
While Calc generally treats interior conditions exactly the same as
|
|
conditions on the outside of a rule, it does guarantee that if all the
|
|
variables in the condition are special names like @code{e}, or already
|
|
bound in the pattern to which the condition is attached (say, if
|
|
@samp{a} had appeared in this condition), then Calc will process this
|
|
condition right after matching the pattern to the left of the @samp{::}.
|
|
Thus, we know that @samp{b} will be bound to @samp{e} only if the
|
|
@code{ln} branch of the @samp{|||} was taken.
|
|
|
|
Note that this rule was careful to bind the same set of meta-variables
|
|
on both sides of the @samp{|||}. Calc does not check this, but if
|
|
you bind a certain meta-variable only in one branch and then use that
|
|
meta-variable elsewhere in the rule, results are unpredictable:
|
|
|
|
@example
|
|
f(a,b) ||| g(b) := h(a,b)
|
|
@end example
|
|
|
|
Here if the pattern matches @samp{g(17)}, Calc makes no promises about
|
|
the value that will be substituted for @samp{a} on the righthand side.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
The pattern @samp{!!! @var{pat}} matches anything that does not
|
|
match @var{pat}. Any meta-variables that are bound while matching
|
|
@var{pat} remain unbound outside of @var{pat}.
|
|
|
|
For example,
|
|
|
|
@example
|
|
f(x &&& !!! a +/- b, !!![]) := g(x)
|
|
@end example
|
|
|
|
@noindent
|
|
converts @code{f} whose first argument is anything @emph{except} an
|
|
error form, and whose second argument is not the empty vector, into
|
|
a similar call to @code{g} (but without the second argument).
|
|
|
|
If we know that the second argument will be a vector (empty or not),
|
|
then an equivalent rule would be:
|
|
|
|
@example
|
|
f(x, y) := g(x) :: typeof(x) != 7 :: vlen(y) > 0
|
|
@end example
|
|
|
|
@noindent
|
|
where of course 7 is the @code{typeof} code for error forms.
|
|
Another final condition, that works for any kind of @samp{y},
|
|
would be @samp{!istrue(y == [])}. (The @code{istrue} function
|
|
returns an explicit 0 if its argument was left in symbolic form;
|
|
plain @samp{!(y == [])} or @samp{y != []} would not work to replace
|
|
@samp{!!![]} since these would be left unsimplified, and thus cause
|
|
the rule to fail, if @samp{y} was something like a variable name.)
|
|
|
|
It is possible for a @samp{!!!} to refer to meta-variables bound
|
|
elsewhere in the pattern. For example,
|
|
|
|
@example
|
|
f(a, !!!a) := g(a)
|
|
@end example
|
|
|
|
@noindent
|
|
matches any call to @code{f} with different arguments, changing
|
|
this to @code{g} with only the first argument.
|
|
|
|
If a function call is to be matched and one of the argument patterns
|
|
contains a @samp{!!!} somewhere inside it, that argument will be
|
|
matched last. Thus
|
|
|
|
@example
|
|
f(!!!a, a) := g(a)
|
|
@end example
|
|
|
|
@noindent
|
|
will be careful to bind @samp{a} to the second argument of @code{f}
|
|
before testing the first argument. If Calc had tried to match the
|
|
first argument of @code{f} first, the results would have been
|
|
disastrous: since @code{a} was unbound so far, the pattern @samp{a}
|
|
would have matched anything at all, and the pattern @samp{!!!a}
|
|
therefore would @emph{not} have matched anything at all!
|
|
|
|
@node Nested Formulas with Rewrite Rules, Multi-Phase Rewrite Rules, Composing Patterns in Rewrite Rules, Rewrite Rules
|
|
@subsection Nested Formulas with Rewrite Rules
|
|
|
|
@noindent
|
|
When @kbd{a r} (@code{calc-rewrite}) is used, it takes an expression from
|
|
the top of the stack and attempts to match any of the specified rules
|
|
to any part of the expression, starting with the whole expression
|
|
and then, if that fails, trying deeper and deeper sub-expressions.
|
|
For each part of the expression, the rules are tried in the order
|
|
they appear in the rules vector. The first rule to match the first
|
|
sub-expression wins; it replaces the matched sub-expression according
|
|
to the @var{new} part of the rule.
|
|
|
|
Often, the rule set will match and change the formula several times.
|
|
The top-level formula is first matched and substituted repeatedly until
|
|
it no longer matches the pattern; then, sub-formulas are tried, and
|
|
so on. Once every part of the formula has gotten its chance, the
|
|
rewrite mechanism starts over again with the top-level formula
|
|
(in case a substitution of one of its arguments has caused it again
|
|
to match). This continues until no further matches can be made
|
|
anywhere in the formula.
|
|
|
|
It is possible for a rule set to get into an infinite loop. The
|
|
most obvious case, replacing a formula with itself, is not a problem
|
|
because a rule is not considered to ``succeed'' unless the righthand
|
|
side actually comes out to something different than the original
|
|
formula or sub-formula that was matched. But if you accidentally
|
|
had both @samp{ln(a b) := ln(a) + ln(b)} and the reverse
|
|
@samp{ln(a) + ln(b) := ln(a b)} in your rule set, Calc would
|
|
run forever switching a formula back and forth between the two
|
|
forms.
|
|
|
|
To avoid disaster, Calc normally stops after 100 changes have been
|
|
made to the formula. This will be enough for most multiple rewrites,
|
|
but it will keep an endless loop of rewrites from locking up the
|
|
computer forever. (On most systems, you can also type @kbd{C-g} to
|
|
halt any Emacs command prematurely.)
|
|
|
|
To change this limit, give a positive numeric prefix argument.
|
|
In particular, @kbd{M-1 a r} applies only one rewrite at a time,
|
|
useful when you are first testing your rule (or just if repeated
|
|
rewriting is not what is called for by your application).
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@ignore
|
|
@mindex iter@idots
|
|
@end ignore
|
|
@tindex iterations
|
|
You can also put a ``function call'' @samp{iterations(@var{n})}
|
|
in place of a rule anywhere in your rules vector (but usually at
|
|
the top). Then, @var{n} will be used instead of 100 as the default
|
|
number of iterations for this rule set. You can use
|
|
@samp{iterations(inf)} if you want no iteration limit by default.
|
|
A prefix argument will override the @code{iterations} limit in the
|
|
rule set.
|
|
|
|
@example
|
|
[ iterations(1),
|
|
f(x) := f(x+1) ]
|
|
@end example
|
|
|
|
More precisely, the limit controls the number of ``iterations,''
|
|
where each iteration is a successful matching of a rule pattern whose
|
|
righthand side, after substituting meta-variables and applying the
|
|
default simplifications, is different from the original sub-formula
|
|
that was matched.
|
|
|
|
A prefix argument of zero sets the limit to infinity. Use with caution!
|
|
|
|
Given a negative numeric prefix argument, @kbd{a r} will match and
|
|
substitute the top-level expression up to that many times, but
|
|
will not attempt to match the rules to any sub-expressions.
|
|
|
|
In a formula, @code{rewrite(@var{expr}, @var{rules}, @var{n})}
|
|
does a rewriting operation. Here @var{expr} is the expression
|
|
being rewritten, @var{rules} is the rule, vector of rules, or
|
|
variable containing the rules, and @var{n} is the optional
|
|
iteration limit, which may be a positive integer, a negative
|
|
integer, or @samp{inf} or @samp{-inf}. If @var{n} is omitted
|
|
the @code{iterations} value from the rule set is used; if both
|
|
are omitted, 100 is used.
|
|
|
|
@node Multi-Phase Rewrite Rules, Selections with Rewrite Rules, Nested Formulas with Rewrite Rules, Rewrite Rules
|
|
@subsection Multi-Phase Rewrite Rules
|
|
|
|
@noindent
|
|
It is possible to separate a rewrite rule set into several @dfn{phases}.
|
|
During each phase, certain rules will be enabled while certain others
|
|
will be disabled. A @dfn{phase schedule} controls the order in which
|
|
phases occur during the rewriting process.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex phase
|
|
@vindex all
|
|
If a call to the marker function @code{phase} appears in the rules
|
|
vector in place of a rule, all rules following that point will be
|
|
members of the phase(s) identified in the arguments to @code{phase}.
|
|
Phases are given integer numbers. The markers @samp{phase()} and
|
|
@samp{phase(all)} both mean the following rules belong to all phases;
|
|
this is the default at the start of the rule set.
|
|
|
|
If you do not explicitly schedule the phases, Calc sorts all phase
|
|
numbers that appear in the rule set and executes the phases in
|
|
ascending order. For example, the rule set
|
|
|
|
@example
|
|
@group
|
|
[ f0(x) := g0(x),
|
|
phase(1),
|
|
f1(x) := g1(x),
|
|
phase(2),
|
|
f2(x) := g2(x),
|
|
phase(3),
|
|
f3(x) := g3(x),
|
|
phase(1,2),
|
|
f4(x) := g4(x) ]
|
|
@end group
|
|
@end example
|
|
|
|
@noindent
|
|
has three phases, 1 through 3. Phase 1 consists of the @code{f0},
|
|
@code{f1}, and @code{f4} rules (in that order). Phase 2 consists of
|
|
@code{f0}, @code{f2}, and @code{f4}. Phase 3 consists of @code{f0}
|
|
and @code{f3}.
|
|
|
|
When Calc rewrites a formula using this rule set, it first rewrites
|
|
the formula using only the phase 1 rules until no further changes are
|
|
possible. Then it switches to the phase 2 rule set and continues
|
|
until no further changes occur, then finally rewrites with phase 3.
|
|
When no more phase 3 rules apply, rewriting finishes. (This is
|
|
assuming @kbd{a r} with a large enough prefix argument to allow the
|
|
rewriting to run to completion; the sequence just described stops
|
|
early if the number of iterations specified in the prefix argument,
|
|
100 by default, is reached.)
|
|
|
|
During each phase, Calc descends through the nested levels of the
|
|
formula as described previously. (@xref{Nested Formulas with Rewrite
|
|
Rules}.) Rewriting starts at the top of the formula, then works its
|
|
way down to the parts, then goes back to the top and works down again.
|
|
The phase 2 rules do not begin until no phase 1 rules apply anywhere
|
|
in the formula.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex schedule
|
|
A @code{schedule} marker appearing in the rule set (anywhere, but
|
|
conventionally at the top) changes the default schedule of phases.
|
|
In the simplest case, @code{schedule} has a sequence of phase numbers
|
|
for arguments; each phase number is invoked in turn until the
|
|
arguments to @code{schedule} are exhausted. Thus adding
|
|
@samp{schedule(3,2,1)} at the top of the above rule set would
|
|
reverse the order of the phases; @samp{schedule(1,2,3)} would have
|
|
no effect since this is the default schedule; and @samp{schedule(1,2,1,3)}
|
|
would give phase 1 a second chance after phase 2 has completed, before
|
|
moving on to phase 3.
|
|
|
|
Any argument to @code{schedule} can instead be a vector of phase
|
|
numbers (or even of sub-vectors). Then the sub-sequence of phases
|
|
described by the vector are tried repeatedly until no change occurs
|
|
in any phase in the sequence. For example, @samp{schedule([1, 2], 3)}
|
|
tries phase 1, then phase 2, then, if either phase made any changes
|
|
to the formula, repeats these two phases until they can make no
|
|
further progress. Finally, it goes on to phase 3 for finishing
|
|
touches.
|
|
|
|
Also, items in @code{schedule} can be variable names as well as
|
|
numbers. A variable name is interpreted as the name of a function
|
|
to call on the whole formula. For example, @samp{schedule(1, simplify)}
|
|
says to apply the phase-1 rules (presumably, all of them), then to
|
|
call @code{simplify} which is the function name equivalent of @kbd{a s}.
|
|
Likewise, @samp{schedule([1, simplify])} says to alternate between
|
|
phase 1 and @kbd{a s} until no further changes occur.
|
|
|
|
Phases can be used purely to improve efficiency; if it is known that
|
|
a certain group of rules will apply only at the beginning of rewriting,
|
|
and a certain other group will apply only at the end, then rewriting
|
|
will be faster if these groups are identified as separate phases.
|
|
Once the phase 1 rules are done, Calc can put them aside and no longer
|
|
spend any time on them while it works on phase 2.
|
|
|
|
There are also some problems that can only be solved with several
|
|
rewrite phases. For a real-world example of a multi-phase rule set,
|
|
examine the set @code{FitRules}, which is used by the curve-fitting
|
|
command to convert a model expression to linear form.
|
|
@xref{Curve Fitting Details}. This set is divided into four phases.
|
|
The first phase rewrites certain kinds of expressions to be more
|
|
easily linearizable, but less computationally efficient. After the
|
|
linear components have been picked out, the final phase includes the
|
|
opposite rewrites to put each component back into an efficient form.
|
|
If both sets of rules were included in one big phase, Calc could get
|
|
into an infinite loop going back and forth between the two forms.
|
|
|
|
Elsewhere in @code{FitRules}, the components are first isolated,
|
|
then recombined where possible to reduce the complexity of the linear
|
|
fit, then finally packaged one component at a time into vectors.
|
|
If the packaging rules were allowed to begin before the recombining
|
|
rules were finished, some components might be put away into vectors
|
|
before they had a chance to recombine. By putting these rules in
|
|
two separate phases, this problem is neatly avoided.
|
|
|
|
@node Selections with Rewrite Rules, Matching Commands, Multi-Phase Rewrite Rules, Rewrite Rules
|
|
@subsection Selections with Rewrite Rules
|
|
|
|
@noindent
|
|
If a sub-formula of the current formula is selected (as by @kbd{j s};
|
|
@pxref{Selecting Subformulas}), the @kbd{a r} (@code{calc-rewrite})
|
|
command applies only to that sub-formula. Together with a negative
|
|
prefix argument, you can use this fact to apply a rewrite to one
|
|
specific part of a formula without affecting any other parts.
|
|
|
|
@kindex j r
|
|
@pindex calc-rewrite-selection
|
|
The @kbd{j r} (@code{calc-rewrite-selection}) command allows more
|
|
sophisticated operations on selections. This command prompts for
|
|
the rules in the same way as @kbd{a r}, but it then applies those
|
|
rules to the whole formula in question even though a sub-formula
|
|
of it has been selected. However, the selected sub-formula will
|
|
first have been surrounded by a @samp{select( )} function call.
|
|
(Calc's evaluator does not understand the function name @code{select};
|
|
this is only a tag used by the @kbd{j r} command.)
|
|
|
|
For example, suppose the formula on the stack is @samp{2 (a + b)^2}
|
|
and the sub-formula @samp{a + b} is selected. This formula will
|
|
be rewritten to @samp{2 select(a + b)^2} and then the rewrite
|
|
rules will be applied in the usual way. The rewrite rules can
|
|
include references to @code{select} to tell where in the pattern
|
|
the selected sub-formula should appear.
|
|
|
|
If there is still exactly one @samp{select( )} function call in
|
|
the formula after rewriting is done, it indicates which part of
|
|
the formula should be selected afterwards. Otherwise, the
|
|
formula will be unselected.
|
|
|
|
You can make @kbd{j r} act much like @kbd{a r} by enclosing both parts
|
|
of the rewrite rule with @samp{select()}. However, @kbd{j r}
|
|
allows you to use the current selection in more flexible ways.
|
|
Suppose you wished to make a rule which removed the exponent from
|
|
the selected term; the rule @samp{select(a)^x := select(a)} would
|
|
work. In the above example, it would rewrite @samp{2 select(a + b)^2}
|
|
to @samp{2 select(a + b)}. This would then be returned to the
|
|
stack as @samp{2 (a + b)} with the @samp{a + b} selected.
|
|
|
|
The @kbd{j r} command uses one iteration by default, unlike
|
|
@kbd{a r} which defaults to 100 iterations. A numeric prefix
|
|
argument affects @kbd{j r} in the same way as @kbd{a r}.
|
|
@xref{Nested Formulas with Rewrite Rules}.
|
|
|
|
As with other selection commands, @kbd{j r} operates on the stack
|
|
entry that contains the cursor. (If the cursor is on the top-of-stack
|
|
@samp{.} marker, it works as if the cursor were on the formula
|
|
at stack level 1.)
|
|
|
|
If you don't specify a set of rules, the rules are taken from the
|
|
top of the stack, just as with @kbd{a r}. In this case, the
|
|
cursor must indicate stack entry 2 or above as the formula to be
|
|
rewritten (otherwise the same formula would be used as both the
|
|
target and the rewrite rules).
|
|
|
|
If the indicated formula has no selection, the cursor position within
|
|
the formula temporarily selects a sub-formula for the purposes of this
|
|
command. If the cursor is not on any sub-formula (e.g., it is in
|
|
the line-number area to the left of the formula), the @samp{select( )}
|
|
markers are ignored by the rewrite mechanism and the rules are allowed
|
|
to apply anywhere in the formula.
|
|
|
|
As a special feature, the normal @kbd{a r} command also ignores
|
|
@samp{select( )} calls in rewrite rules. For example, if you used the
|
|
above rule @samp{select(a)^x := select(a)} with @kbd{a r}, it would apply
|
|
the rule as if it were @samp{a^x := a}. Thus, you can write general
|
|
purpose rules with @samp{select( )} hints inside them so that they
|
|
will ``do the right thing'' in both @kbd{a r} and @kbd{j r},
|
|
both with and without selections.
|
|
|
|
@node Matching Commands, Automatic Rewrites, Selections with Rewrite Rules, Rewrite Rules
|
|
@subsection Matching Commands
|
|
|
|
@noindent
|
|
@kindex a m
|
|
@pindex calc-match
|
|
@tindex match
|
|
The @kbd{a m} (@code{calc-match}) [@code{match}] function takes a
|
|
vector of formulas and a rewrite-rule-style pattern, and produces
|
|
a vector of all formulas which match the pattern. The command
|
|
prompts you to enter the pattern; as for @kbd{a r}, you can enter
|
|
a single pattern (i.e., a formula with meta-variables), or a
|
|
vector of patterns, or a variable which contains patterns, or
|
|
you can give a blank response in which case the patterns are taken
|
|
from the top of the stack. The pattern set will be compiled once
|
|
and saved if it is stored in a variable. If there are several
|
|
patterns in the set, vector elements are kept if they match any
|
|
of the patterns.
|
|
|
|
For example, @samp{match(a+b, [x, x+y, x-y, 7, x+y+z])}
|
|
will return @samp{[x+y, x-y, x+y+z]}.
|
|
|
|
The @code{import} mechanism is not available for pattern sets.
|
|
|
|
The @kbd{a m} command can also be used to extract all vector elements
|
|
which satisfy any condition: The pattern @samp{x :: x>0} will select
|
|
all the positive vector elements.
|
|
|
|
@kindex I a m
|
|
@tindex matchnot
|
|
With the Inverse flag [@code{matchnot}], this command extracts all
|
|
vector elements which do @emph{not} match the given pattern.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex matches
|
|
There is also a function @samp{matches(@var{x}, @var{p})} which
|
|
evaluates to 1 if expression @var{x} matches pattern @var{p}, or
|
|
to 0 otherwise. This is sometimes useful for including into the
|
|
conditional clauses of other rewrite rules.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex vmatches
|
|
The function @code{vmatches} is just like @code{matches}, except
|
|
that if the match succeeds it returns a vector of assignments to
|
|
the meta-variables instead of the number 1. For example,
|
|
@samp{vmatches(f(1,2), f(a,b))} returns @samp{[a := 1, b := 2]}.
|
|
If the match fails, the function returns the number 0.
|
|
|
|
@node Automatic Rewrites, Debugging Rewrites, Matching Commands, Rewrite Rules
|
|
@subsection Automatic Rewrites
|
|
|
|
@noindent
|
|
@cindex @code{EvalRules} variable
|
|
@vindex EvalRules
|
|
It is possible to get Calc to apply a set of rewrite rules on all
|
|
results, effectively adding to the built-in set of default
|
|
simplifications. To do this, simply store your rule set in the
|
|
variable @code{EvalRules}. There is a convenient @kbd{s E} command
|
|
for editing @code{EvalRules}; @pxref{Operations on Variables}.
|
|
|
|
For example, suppose you want @samp{sin(a + b)} to be expanded out
|
|
to @samp{sin(b) cos(a) + cos(b) sin(a)} wherever it appears, and
|
|
similarly for @samp{cos(a + b)}. The corresponding rewrite rule
|
|
set would be,
|
|
|
|
@smallexample
|
|
@group
|
|
[ sin(a + b) := cos(a) sin(b) + sin(a) cos(b),
|
|
cos(a + b) := cos(a) cos(b) - sin(a) sin(b) ]
|
|
@end group
|
|
@end smallexample
|
|
|
|
To apply these manually, you could put them in a variable called
|
|
@code{trigexp} and then use @kbd{a r trigexp} every time you wanted
|
|
to expand trig functions. But if instead you store them in the
|
|
variable @code{EvalRules}, they will automatically be applied to all
|
|
sines and cosines of sums. Then, with @samp{2 x} and @samp{45} on
|
|
the stack, typing @kbd{+ S} will (assuming Degrees mode) result in
|
|
@samp{0.7071 sin(2 x) + 0.7071 cos(2 x)} automatically.
|
|
|
|
As each level of a formula is evaluated, the rules from
|
|
@code{EvalRules} are applied before the default simplifications.
|
|
Rewriting continues until no further @code{EvalRules} apply.
|
|
Note that this is different from the usual order of application of
|
|
rewrite rules: @code{EvalRules} works from the bottom up, simplifying
|
|
the arguments to a function before the function itself, while @kbd{a r}
|
|
applies rules from the top down.
|
|
|
|
Because the @code{EvalRules} are tried first, you can use them to
|
|
override the normal behavior of any built-in Calc function.
|
|
|
|
It is important not to write a rule that will get into an infinite
|
|
loop. For example, the rule set @samp{[f(0) := 1, f(n) := n f(n-1)]}
|
|
appears to be a good definition of a factorial function, but it is
|
|
unsafe. Imagine what happens if @samp{f(2.5)} is simplified. Calc
|
|
will continue to subtract 1 from this argument forever without reaching
|
|
zero. A safer second rule would be @samp{f(n) := n f(n-1) :: n>0}.
|
|
Another dangerous rule is @samp{g(x, y) := g(y, x)}. Rewriting
|
|
@samp{g(2, 4)}, this would bounce back and forth between that and
|
|
@samp{g(4, 2)} forever. If an infinite loop in @code{EvalRules}
|
|
occurs, Emacs will eventually stop with a ``Computation got stuck
|
|
or ran too long'' message.
|
|
|
|
Another subtle difference between @code{EvalRules} and regular rewrites
|
|
concerns rules that rewrite a formula into an identical formula. For
|
|
example, @samp{f(n) := f(floor(n))} ``fails to match'' when @expr{n} is
|
|
already an integer. But in @code{EvalRules} this case is detected only
|
|
if the righthand side literally becomes the original formula before any
|
|
further simplification. This means that @samp{f(n) := f(floor(n))} will
|
|
get into an infinite loop if it occurs in @code{EvalRules}. Calc will
|
|
replace @samp{f(6)} with @samp{f(floor(6))}, which is different from
|
|
@samp{f(6)}, so it will consider the rule to have matched and will
|
|
continue simplifying that formula; first the argument is simplified
|
|
to get @samp{f(6)}, then the rule matches again to get @samp{f(floor(6))}
|
|
again, ad infinitum. A much safer rule would check its argument first,
|
|
say, with @samp{f(n) := f(floor(n)) :: !dint(n)}.
|
|
|
|
(What really happens is that the rewrite mechanism substitutes the
|
|
meta-variables in the righthand side of a rule, compares to see if the
|
|
result is the same as the original formula and fails if so, then uses
|
|
the default simplifications to simplify the result and compares again
|
|
(and again fails if the formula has simplified back to its original
|
|
form). The only special wrinkle for the @code{EvalRules} is that the
|
|
same rules will come back into play when the default simplifications
|
|
are used. What Calc wants to do is build @samp{f(floor(6))}, see that
|
|
this is different from the original formula, simplify to @samp{f(6)},
|
|
see that this is the same as the original formula, and thus halt the
|
|
rewriting. But while simplifying, @samp{f(6)} will again trigger
|
|
the same @code{EvalRules} rule and Calc will get into a loop inside
|
|
the rewrite mechanism itself.)
|
|
|
|
The @code{phase}, @code{schedule}, and @code{iterations} markers do
|
|
not work in @code{EvalRules}. If the rule set is divided into phases,
|
|
only the phase 1 rules are applied, and the schedule is ignored.
|
|
The rules are always repeated as many times as possible.
|
|
|
|
The @code{EvalRules} are applied to all function calls in a formula,
|
|
but not to numbers (and other number-like objects like error forms),
|
|
nor to vectors or individual variable names. (Though they will apply
|
|
to @emph{components} of vectors and error forms when appropriate.) You
|
|
might try to make a variable @code{phihat} which automatically expands
|
|
to its definition without the need to press @kbd{=} by writing the
|
|
rule @samp{quote(phihat) := (1-sqrt(5))/2}, but unfortunately this rule
|
|
will not work as part of @code{EvalRules}.
|
|
|
|
Finally, another limitation is that Calc sometimes calls its built-in
|
|
functions directly rather than going through the default simplifications.
|
|
When it does this, @code{EvalRules} will not be able to override those
|
|
functions. For example, when you take the absolute value of the complex
|
|
number @expr{(2, 3)}, Calc computes @samp{sqrt(2*2 + 3*3)} by calling
|
|
the multiplication, addition, and square root functions directly rather
|
|
than applying the default simplifications to this formula. So an
|
|
@code{EvalRules} rule that (perversely) rewrites @samp{sqrt(13) := 6}
|
|
would not apply. (However, if you put Calc into Symbolic mode so that
|
|
@samp{sqrt(13)} will be left in symbolic form by the built-in square
|
|
root function, your rule will be able to apply. But if the complex
|
|
number were @expr{(3,4)}, so that @samp{sqrt(25)} must be calculated,
|
|
then Symbolic mode will not help because @samp{sqrt(25)} can be
|
|
evaluated exactly to 5.)
|
|
|
|
One subtle restriction that normally only manifests itself with
|
|
@code{EvalRules} is that while a given rewrite rule is in the process
|
|
of being checked, that same rule cannot be recursively applied. Calc
|
|
effectively removes the rule from its rule set while checking the rule,
|
|
then puts it back once the match succeeds or fails. (The technical
|
|
reason for this is that compiled pattern programs are not reentrant.)
|
|
For example, consider the rule @samp{foo(x) := x :: foo(x/2) > 0}
|
|
attempting to match @samp{foo(8)}. This rule will be inactive while
|
|
the condition @samp{foo(4) > 0} is checked, even though it might be
|
|
an integral part of evaluating that condition. Note that this is not
|
|
a problem for the more usual recursive type of rule, such as
|
|
@samp{foo(x) := foo(x/2)}, because there the rule has succeeded and
|
|
been reactivated by the time the righthand side is evaluated.
|
|
|
|
If @code{EvalRules} has no stored value (its default state), or if
|
|
anything but a vector is stored in it, then it is ignored.
|
|
|
|
Even though Calc's rewrite mechanism is designed to compare rewrite
|
|
rules to formulas as quickly as possible, storing rules in
|
|
@code{EvalRules} may make Calc run substantially slower. This is
|
|
particularly true of rules where the top-level call is a commonly used
|
|
function, or is not fixed. The rule @samp{f(n) := n f(n-1) :: n>0} will
|
|
only activate the rewrite mechanism for calls to the function @code{f},
|
|
but @samp{lg(n) + lg(m) := lg(n m)} will check every @samp{+} operator.
|
|
|
|
@smallexample
|
|
apply(f, [a*b]) := apply(f, [a]) + apply(f, [b]) :: in(f, [ln, log10])
|
|
@end smallexample
|
|
|
|
@noindent
|
|
may seem more ``efficient'' than two separate rules for @code{ln} and
|
|
@code{log10}, but actually it is vastly less efficient because rules
|
|
with @code{apply} as the top-level pattern must be tested against
|
|
@emph{every} function call that is simplified.
|
|
|
|
@cindex @code{AlgSimpRules} variable
|
|
@vindex AlgSimpRules
|
|
Suppose you want @samp{sin(a + b)} to be expanded out not all the time,
|
|
but only when @kbd{a s} is used to simplify the formula. The variable
|
|
@code{AlgSimpRules} holds rules for this purpose. The @kbd{a s} command
|
|
will apply @code{EvalRules} and @code{AlgSimpRules} to the formula, as
|
|
well as all of its built-in simplifications.
|
|
|
|
Most of the special limitations for @code{EvalRules} don't apply to
|
|
@code{AlgSimpRules}. Calc simply does an @kbd{a r AlgSimpRules}
|
|
command with an infinite repeat count as the first step of @kbd{a s}.
|
|
It then applies its own built-in simplifications throughout the
|
|
formula, and then repeats these two steps (along with applying the
|
|
default simplifications) until no further changes are possible.
|
|
|
|
@cindex @code{ExtSimpRules} variable
|
|
@cindex @code{UnitSimpRules} variable
|
|
@vindex ExtSimpRules
|
|
@vindex UnitSimpRules
|
|
There are also @code{ExtSimpRules} and @code{UnitSimpRules} variables
|
|
that are used by @kbd{a e} and @kbd{u s}, respectively; these commands
|
|
also apply @code{EvalRules} and @code{AlgSimpRules}. The variable
|
|
@code{IntegSimpRules} contains simplification rules that are used
|
|
only during integration by @kbd{a i}.
|
|
|
|
@node Debugging Rewrites, Examples of Rewrite Rules, Automatic Rewrites, Rewrite Rules
|
|
@subsection Debugging Rewrites
|
|
|
|
@noindent
|
|
If a buffer named @samp{*Trace*} exists, the rewrite mechanism will
|
|
record some useful information there as it operates. The original
|
|
formula is written there, as is the result of each successful rewrite,
|
|
and the final result of the rewriting. All phase changes are also
|
|
noted.
|
|
|
|
Calc always appends to @samp{*Trace*}. You must empty this buffer
|
|
yourself periodically if it is in danger of growing unwieldy.
|
|
|
|
Note that the rewriting mechanism is substantially slower when the
|
|
@samp{*Trace*} buffer exists, even if the buffer is not visible on
|
|
the screen. Once you are done, you will probably want to kill this
|
|
buffer (with @kbd{C-x k *Trace* @key{RET}}). If you leave it in
|
|
existence and forget about it, all your future rewrite commands will
|
|
be needlessly slow.
|
|
|
|
@node Examples of Rewrite Rules, , Debugging Rewrites, Rewrite Rules
|
|
@subsection Examples of Rewrite Rules
|
|
|
|
@noindent
|
|
Returning to the example of substituting the pattern
|
|
@samp{sin(x)^2 + cos(x)^2} with 1, we saw that the rule
|
|
@samp{opt(a) sin(x)^2 + opt(a) cos(x)^2 := a} does a good job of
|
|
finding suitable cases. Another solution would be to use the rule
|
|
@samp{cos(x)^2 := 1 - sin(x)^2}, followed by algebraic simplification
|
|
if necessary. This rule will be the most effective way to do the job,
|
|
but at the expense of making some changes that you might not desire.
|
|
|
|
Another algebraic rewrite rule is @samp{exp(x+y) := exp(x) exp(y)}.
|
|
To make this work with the @w{@kbd{j r}} command so that it can be
|
|
easily targeted to a particular exponential in a large formula,
|
|
you might wish to write the rule as @samp{select(exp(x+y)) :=
|
|
select(exp(x) exp(y))}. The @samp{select} markers will be
|
|
ignored by the regular @kbd{a r} command
|
|
(@pxref{Selections with Rewrite Rules}).
|
|
|
|
A surprisingly useful rewrite rule is @samp{a/(b-c) := a*(b+c)/(b^2-c^2)}.
|
|
This will simplify the formula whenever @expr{b} and/or @expr{c} can
|
|
be made simpler by squaring. For example, applying this rule to
|
|
@samp{2 / (sqrt(2) + 3)} yields @samp{6:7 - 2:7 sqrt(2)} (assuming
|
|
Symbolic mode has been enabled to keep the square root from being
|
|
evaluated to a floating-point approximation). This rule is also
|
|
useful when working with symbolic complex numbers, e.g.,
|
|
@samp{(a + b i) / (c + d i)}.
|
|
|
|
As another example, we could define our own ``triangular numbers'' function
|
|
with the rules @samp{[tri(0) := 0, tri(n) := n + tri(n-1) :: n>0]}. Enter
|
|
this vector and store it in a variable: @kbd{@w{s t} trirules}. Now, given
|
|
a suitable formula like @samp{tri(5)} on the stack, type @samp{a r trirules}
|
|
to apply these rules repeatedly. After six applications, @kbd{a r} will
|
|
stop with 15 on the stack. Once these rules are debugged, it would probably
|
|
be most useful to add them to @code{EvalRules} so that Calc will evaluate
|
|
the new @code{tri} function automatically. We could then use @kbd{Z K} on
|
|
the keyboard macro @kbd{' tri($) @key{RET}} to make a command that applies
|
|
@code{tri} to the value on the top of the stack. @xref{Programming}.
|
|
|
|
@cindex Quaternions
|
|
The following rule set, contributed by
|
|
@texline Fran\c cois
|
|
@infoline Francois
|
|
Pinard, implements @dfn{quaternions}, a generalization of the concept of
|
|
complex numbers. Quaternions have four components, and are here
|
|
represented by function calls @samp{quat(@var{w}, [@var{x}, @var{y},
|
|
@var{z}])} with ``real part'' @var{w} and the three ``imaginary'' parts
|
|
collected into a vector. Various arithmetical operations on quaternions
|
|
are supported. To use these rules, either add them to @code{EvalRules},
|
|
or create a command based on @kbd{a r} for simplifying quaternion
|
|
formulas. A convenient way to enter quaternions would be a command
|
|
defined by a keyboard macro containing: @kbd{' quat($$$$, [$$$, $$, $])
|
|
@key{RET}}.
|
|
|
|
@smallexample
|
|
[ quat(w, x, y, z) := quat(w, [x, y, z]),
|
|
quat(w, [0, 0, 0]) := w,
|
|
abs(quat(w, v)) := hypot(w, v),
|
|
-quat(w, v) := quat(-w, -v),
|
|
r + quat(w, v) := quat(r + w, v) :: real(r),
|
|
r - quat(w, v) := quat(r - w, -v) :: real(r),
|
|
quat(w1, v1) + quat(w2, v2) := quat(w1 + w2, v1 + v2),
|
|
r * quat(w, v) := quat(r * w, r * v) :: real(r),
|
|
plain(quat(w1, v1) * quat(w2, v2))
|
|
:= quat(w1 * w2 - v1 * v2, w1 * v2 + w2 * v1 + cross(v1, v2)),
|
|
quat(w1, v1) / r := quat(w1 / r, v1 / r) :: real(r),
|
|
z / quat(w, v) := z * quatinv(quat(w, v)),
|
|
quatinv(quat(w, v)) := quat(w, -v) / (w^2 + v^2),
|
|
quatsqr(quat(w, v)) := quat(w^2 - v^2, 2 * w * v),
|
|
quat(w, v)^k := quatsqr(quat(w, v)^(k / 2))
|
|
:: integer(k) :: k > 0 :: k % 2 = 0,
|
|
quat(w, v)^k := quatsqr(quat(w, v)^((k - 1) / 2)) * quat(w, v)
|
|
:: integer(k) :: k > 2,
|
|
quat(w, v)^-k := quatinv(quat(w, v)^k) :: integer(k) :: k > 0 ]
|
|
@end smallexample
|
|
|
|
Quaternions, like matrices, have non-commutative multiplication.
|
|
In other words, @expr{q1 * q2 = q2 * q1} is not necessarily true if
|
|
@expr{q1} and @expr{q2} are @code{quat} forms. The @samp{quat*quat}
|
|
rule above uses @code{plain} to prevent Calc from rearranging the
|
|
product. It may also be wise to add the line @samp{[quat(), matrix]}
|
|
to the @code{Decls} matrix, to ensure that Calc's other algebraic
|
|
operations will not rearrange a quaternion product. @xref{Declarations}.
|
|
|
|
These rules also accept a four-argument @code{quat} form, converting
|
|
it to the preferred form in the first rule. If you would rather see
|
|
results in the four-argument form, just append the two items
|
|
@samp{phase(2), quat(w, [x, y, z]) := quat(w, x, y, z)} to the end
|
|
of the rule set. (But remember that multi-phase rule sets don't work
|
|
in @code{EvalRules}.)
|
|
|
|
@node Units, Store and Recall, Algebra, Top
|
|
@chapter Operating on Units
|
|
|
|
@noindent
|
|
One special interpretation of algebraic formulas is as numbers with units.
|
|
For example, the formula @samp{5 m / s^2} can be read ``five meters
|
|
per second squared.'' The commands in this chapter help you
|
|
manipulate units expressions in this form. Units-related commands
|
|
begin with the @kbd{u} prefix key.
|
|
|
|
@menu
|
|
* Basic Operations on Units::
|
|
* The Units Table::
|
|
* Predefined Units::
|
|
* User-Defined Units::
|
|
@end menu
|
|
|
|
@node Basic Operations on Units, The Units Table, Units, Units
|
|
@section Basic Operations on Units
|
|
|
|
@noindent
|
|
A @dfn{units expression} is a formula which is basically a number
|
|
multiplied and/or divided by one or more @dfn{unit names}, which may
|
|
optionally be raised to integer powers. Actually, the value part need not
|
|
be a number; any product or quotient involving unit names is a units
|
|
expression. Many of the units commands will also accept any formula,
|
|
where the command applies to all units expressions which appear in the
|
|
formula.
|
|
|
|
A unit name is a variable whose name appears in the @dfn{unit table},
|
|
or a variable whose name is a prefix character like @samp{k} (for ``kilo'')
|
|
or @samp{u} (for ``micro'') followed by a name in the unit table.
|
|
A substantial table of built-in units is provided with Calc;
|
|
@pxref{Predefined Units}. You can also define your own unit names;
|
|
@pxref{User-Defined Units}.
|
|
|
|
Note that if the value part of a units expression is exactly @samp{1},
|
|
it will be removed by the Calculator's automatic algebra routines: The
|
|
formula @samp{1 mm} is ``simplified'' to @samp{mm}. This is only a
|
|
display anomaly, however; @samp{mm} will work just fine as a
|
|
representation of one millimeter.
|
|
|
|
You may find that Algebraic mode (@pxref{Algebraic Entry}) makes working
|
|
with units expressions easier. Otherwise, you will have to remember
|
|
to hit the apostrophe key every time you wish to enter units.
|
|
|
|
@kindex u s
|
|
@pindex calc-simplify-units
|
|
@ignore
|
|
@mindex usimpl@idots
|
|
@end ignore
|
|
@tindex usimplify
|
|
The @kbd{u s} (@code{calc-simplify-units}) [@code{usimplify}] command
|
|
simplifies a units
|
|
expression. It uses @kbd{a s} (@code{calc-simplify}) to simplify the
|
|
expression first as a regular algebraic formula; it then looks for
|
|
features that can be further simplified by converting one object's units
|
|
to be compatible with another's. For example, @samp{5 m + 23 mm} will
|
|
simplify to @samp{5.023 m}. When different but compatible units are
|
|
added, the righthand term's units are converted to match those of the
|
|
lefthand term. @xref{Simplification Modes}, for a way to have this done
|
|
automatically at all times.
|
|
|
|
Units simplification also handles quotients of two units with the same
|
|
dimensionality, as in @w{@samp{2 in s/L cm}} to @samp{5.08 s/L}; fractional
|
|
powers of unit expressions, as in @samp{sqrt(9 mm^2)} to @samp{3 mm} and
|
|
@samp{sqrt(9 acre)} to a quantity in meters; and @code{floor},
|
|
@code{ceil}, @code{round}, @code{rounde}, @code{roundu}, @code{trunc},
|
|
@code{float}, @code{frac}, @code{abs}, and @code{clean}
|
|
applied to units expressions, in which case
|
|
the operation in question is applied only to the numeric part of the
|
|
expression. Finally, trigonometric functions of quantities with units
|
|
of angle are evaluated, regardless of the current angular mode.
|
|
|
|
@kindex u c
|
|
@pindex calc-convert-units
|
|
The @kbd{u c} (@code{calc-convert-units}) command converts a units
|
|
expression to new, compatible units. For example, given the units
|
|
expression @samp{55 mph}, typing @kbd{u c m/s @key{RET}} produces
|
|
@samp{24.5872 m/s}. If the units you request are inconsistent with
|
|
the original units, the number will be converted into your units
|
|
times whatever ``remainder'' units are left over. For example,
|
|
converting @samp{55 mph} into acres produces @samp{6.08e-3 acre / m s}.
|
|
(Recall that multiplication binds more strongly than division in Calc
|
|
formulas, so the units here are acres per meter-second.) Remainder
|
|
units are expressed in terms of ``fundamental'' units like @samp{m} and
|
|
@samp{s}, regardless of the input units.
|
|
|
|
One special exception is that if you specify a single unit name, and
|
|
a compatible unit appears somewhere in the units expression, then
|
|
that compatible unit will be converted to the new unit and the
|
|
remaining units in the expression will be left alone. For example,
|
|
given the input @samp{980 cm/s^2}, the command @kbd{u c ms} will
|
|
change the @samp{s} to @samp{ms} to get @samp{9.8e-4 cm/ms^2}.
|
|
The ``remainder unit'' @samp{cm} is left alone rather than being
|
|
changed to the base unit @samp{m}.
|
|
|
|
You can use explicit unit conversion instead of the @kbd{u s} command
|
|
to gain more control over the units of the result of an expression.
|
|
For example, given @samp{5 m + 23 mm}, you can type @kbd{u c m} or
|
|
@kbd{u c mm} to express the result in either meters or millimeters.
|
|
(For that matter, you could type @kbd{u c fath} to express the result
|
|
in fathoms, if you preferred!)
|
|
|
|
In place of a specific set of units, you can also enter one of the
|
|
units system names @code{si}, @code{mks} (equivalent), or @code{cgs}.
|
|
For example, @kbd{u c si @key{RET}} converts the expression into
|
|
International System of Units (SI) base units. Also, @kbd{u c base}
|
|
converts to Calc's base units, which are the same as @code{si} units
|
|
except that @code{base} uses @samp{g} as the fundamental unit of mass
|
|
whereas @code{si} uses @samp{kg}.
|
|
|
|
@cindex Composite units
|
|
The @kbd{u c} command also accepts @dfn{composite units}, which
|
|
are expressed as the sum of several compatible unit names. For
|
|
example, converting @samp{30.5 in} to units @samp{mi+ft+in} (miles,
|
|
feet, and inches) produces @samp{2 ft + 6.5 in}. Calc first
|
|
sorts the unit names into order of decreasing relative size.
|
|
It then accounts for as much of the input quantity as it can
|
|
using an integer number times the largest unit, then moves on
|
|
to the next smaller unit, and so on. Only the smallest unit
|
|
may have a non-integer amount attached in the result. A few
|
|
standard unit names exist for common combinations, such as
|
|
@code{mfi} for @samp{mi+ft+in}, and @code{tpo} for @samp{ton+lb+oz}.
|
|
Composite units are expanded as if by @kbd{a x}, so that
|
|
@samp{(ft+in)/hr} is first converted to @samp{ft/hr+in/hr}.
|
|
|
|
If the value on the stack does not contain any units, @kbd{u c} will
|
|
prompt first for the old units which this value should be considered
|
|
to have, then for the new units. Assuming the old and new units you
|
|
give are consistent with each other, the result also will not contain
|
|
any units. For example, @kbd{@w{u c} cm @key{RET} in @key{RET}} converts the number
|
|
2 on the stack to 5.08.
|
|
|
|
@kindex u b
|
|
@pindex calc-base-units
|
|
The @kbd{u b} (@code{calc-base-units}) command is shorthand for
|
|
@kbd{u c base}; it converts the units expression on the top of the
|
|
stack into @code{base} units. If @kbd{u s} does not simplify a
|
|
units expression as far as you would like, try @kbd{u b}.
|
|
|
|
The @kbd{u c} and @kbd{u b} commands treat temperature units (like
|
|
@samp{degC} and @samp{K}) as relative temperatures. For example,
|
|
@kbd{u c} converts @samp{10 degC} to @samp{18 degF}: A change of 10
|
|
degrees Celsius corresponds to a change of 18 degrees Fahrenheit.
|
|
|
|
@kindex u t
|
|
@pindex calc-convert-temperature
|
|
@cindex Temperature conversion
|
|
The @kbd{u t} (@code{calc-convert-temperature}) command converts
|
|
absolute temperatures. The value on the stack must be a simple units
|
|
expression with units of temperature only. This command would convert
|
|
@samp{10 degC} to @samp{50 degF}, the equivalent temperature on the
|
|
Fahrenheit scale.
|
|
|
|
@kindex u r
|
|
@pindex calc-remove-units
|
|
@kindex u x
|
|
@pindex calc-extract-units
|
|
The @kbd{u r} (@code{calc-remove-units}) command removes units from the
|
|
formula at the top of the stack. The @kbd{u x}
|
|
(@code{calc-extract-units}) command extracts only the units portion of a
|
|
formula. These commands essentially replace every term of the formula
|
|
that does or doesn't (respectively) look like a unit name by the
|
|
constant 1, then resimplify the formula.
|
|
|
|
@kindex u a
|
|
@pindex calc-autorange-units
|
|
The @kbd{u a} (@code{calc-autorange-units}) command turns on and off a
|
|
mode in which unit prefixes like @code{k} (``kilo'') are automatically
|
|
applied to keep the numeric part of a units expression in a reasonable
|
|
range. This mode affects @kbd{u s} and all units conversion commands
|
|
except @kbd{u b}. For example, with autoranging on, @samp{12345 Hz}
|
|
will be simplified to @samp{12.345 kHz}. Autoranging is useful for
|
|
some kinds of units (like @code{Hz} and @code{m}), but is probably
|
|
undesirable for non-metric units like @code{ft} and @code{tbsp}.
|
|
(Composite units are more appropriate for those; see above.)
|
|
|
|
Autoranging always applies the prefix to the leftmost unit name.
|
|
Calc chooses the largest prefix that causes the number to be greater
|
|
than or equal to 1.0. Thus an increasing sequence of adjusted times
|
|
would be @samp{1 ms, 10 ms, 100 ms, 1 s, 10 s, 100 s, 1 ks}.
|
|
Generally the rule of thumb is that the number will be adjusted
|
|
to be in the interval @samp{[1 .. 1000)}, although there are several
|
|
exceptions to this rule. First, if the unit has a power then this
|
|
is not possible; @samp{0.1 s^2} simplifies to @samp{100000 ms^2}.
|
|
Second, the ``centi-'' prefix is allowed to form @code{cm} (centimeters),
|
|
but will not apply to other units. The ``deci-,'' ``deka-,'' and
|
|
``hecto-'' prefixes are never used. Thus the allowable interval is
|
|
@samp{[1 .. 10)} for millimeters and @samp{[1 .. 100)} for centimeters.
|
|
Finally, a prefix will not be added to a unit if the resulting name
|
|
is also the actual name of another unit; @samp{1e-15 t} would normally
|
|
be considered a ``femto-ton,'' but it is written as @samp{1000 at}
|
|
(1000 atto-tons) instead because @code{ft} would be confused with feet.
|
|
|
|
@node The Units Table, Predefined Units, Basic Operations on Units, Units
|
|
@section The Units Table
|
|
|
|
@noindent
|
|
@kindex u v
|
|
@pindex calc-enter-units-table
|
|
The @kbd{u v} (@code{calc-enter-units-table}) command displays the units table
|
|
in another buffer called @code{*Units Table*}. Each entry in this table
|
|
gives the unit name as it would appear in an expression, the definition
|
|
of the unit in terms of simpler units, and a full name or description of
|
|
the unit. Fundamental units are defined as themselves; these are the
|
|
units produced by the @kbd{u b} command. The fundamental units are
|
|
meters, seconds, grams, kelvins, amperes, candelas, moles, radians,
|
|
and steradians.
|
|
|
|
The Units Table buffer also displays the Unit Prefix Table. Note that
|
|
two prefixes, ``kilo'' and ``hecto,'' accept either upper- or lower-case
|
|
prefix letters. @samp{Meg} is also accepted as a synonym for the @samp{M}
|
|
prefix. Whenever a unit name can be interpreted as either a built-in name
|
|
or a prefix followed by another built-in name, the former interpretation
|
|
wins. For example, @samp{2 pt} means two pints, not two pico-tons.
|
|
|
|
The Units Table buffer, once created, is not rebuilt unless you define
|
|
new units. To force the buffer to be rebuilt, give any numeric prefix
|
|
argument to @kbd{u v}.
|
|
|
|
@kindex u V
|
|
@pindex calc-view-units-table
|
|
The @kbd{u V} (@code{calc-view-units-table}) command is like @kbd{u v} except
|
|
that the cursor is not moved into the Units Table buffer. You can
|
|
type @kbd{u V} again to remove the Units Table from the display. To
|
|
return from the Units Table buffer after a @kbd{u v}, type @kbd{C-x * c}
|
|
again or use the regular Emacs @w{@kbd{C-x o}} (@code{other-window})
|
|
command. You can also kill the buffer with @kbd{C-x k} if you wish;
|
|
the actual units table is safely stored inside the Calculator.
|
|
|
|
@kindex u g
|
|
@pindex calc-get-unit-definition
|
|
The @kbd{u g} (@code{calc-get-unit-definition}) command retrieves a unit's
|
|
defining expression and pushes it onto the Calculator stack. For example,
|
|
@kbd{u g in} will produce the expression @samp{2.54 cm}. This is the
|
|
same definition for the unit that would appear in the Units Table buffer.
|
|
Note that this command works only for actual unit names; @kbd{u g km}
|
|
will report that no such unit exists, for example, because @code{km} is
|
|
really the unit @code{m} with a @code{k} (``kilo'') prefix. To see a
|
|
definition of a unit in terms of base units, it is easier to push the
|
|
unit name on the stack and then reduce it to base units with @kbd{u b}.
|
|
|
|
@kindex u e
|
|
@pindex calc-explain-units
|
|
The @kbd{u e} (@code{calc-explain-units}) command displays an English
|
|
description of the units of the expression on the stack. For example,
|
|
for the expression @samp{62 km^2 g / s^2 mol K}, the description is
|
|
``Square-Kilometer Gram per (Second-squared Mole Degree-Kelvin).'' This
|
|
command uses the English descriptions that appear in the righthand
|
|
column of the Units Table.
|
|
|
|
@node Predefined Units, User-Defined Units, The Units Table, Units
|
|
@section Predefined Units
|
|
|
|
@noindent
|
|
Since the exact definitions of many kinds of units have evolved over the
|
|
years, and since certain countries sometimes have local differences in
|
|
their definitions, it is a good idea to examine Calc's definition of a
|
|
unit before depending on its exact value. For example, there are three
|
|
different units for gallons, corresponding to the US (@code{gal}),
|
|
Canadian (@code{galC}), and British (@code{galUK}) definitions. Also,
|
|
note that @code{oz} is a standard ounce of mass, @code{ozt} is a Troy
|
|
ounce, and @code{ozfl} is a fluid ounce.
|
|
|
|
The temperature units corresponding to degrees Kelvin and Centigrade
|
|
(Celsius) are the same in this table, since most units commands treat
|
|
temperatures as being relative. The @code{calc-convert-temperature}
|
|
command has special rules for handling the different absolute magnitudes
|
|
of the various temperature scales.
|
|
|
|
The unit of volume ``liters'' can be referred to by either the lower-case
|
|
@code{l} or the upper-case @code{L}.
|
|
|
|
The unit @code{A} stands for Amperes; the name @code{Ang} is used
|
|
@tex
|
|
for \AA ngstroms.
|
|
@end tex
|
|
@ifinfo
|
|
for Angstroms.
|
|
@end ifinfo
|
|
|
|
The unit @code{pt} stands for pints; the name @code{point} stands for
|
|
a typographical point, defined by @samp{72 point = 1 in}. This is
|
|
slightly different than the point defined by the American Typefounder's
|
|
Association in 1886, but the point used by Calc has become standard
|
|
largely due to its use by the PostScript page description language.
|
|
There is also @code{texpt}, which stands for a printer's point as
|
|
defined by the @TeX{} typesetting system: @samp{72.27 texpt = 1 in}.
|
|
Other units used by @TeX{} are available; they are @code{texpc} (a pica),
|
|
@code{texbp} (a ``big point'', equal to a standard point which is larger
|
|
than the point used by @TeX{}), @code{texdd} (a Didot point),
|
|
@code{texcc} (a Cicero) and @code{texsp} (a scaled @TeX{} point,
|
|
all dimensions representable in @TeX{} are multiples of this value).
|
|
|
|
The unit @code{e} stands for the elementary (electron) unit of charge;
|
|
because algebra command could mistake this for the special constant
|
|
@expr{e}, Calc provides the alternate unit name @code{ech} which is
|
|
preferable to @code{e}.
|
|
|
|
The name @code{g} stands for one gram of mass; there is also @code{gf},
|
|
one gram of force. (Likewise for @kbd{lb}, pounds, and @kbd{lbf}.)
|
|
Meanwhile, one ``@expr{g}'' of acceleration is denoted @code{ga}.
|
|
|
|
The unit @code{ton} is a U.S. ton of @samp{2000 lb}, and @code{t} is
|
|
a metric ton of @samp{1000 kg}.
|
|
|
|
The names @code{s} (or @code{sec}) and @code{min} refer to units of
|
|
time; @code{arcsec} and @code{arcmin} are units of angle.
|
|
|
|
Some ``units'' are really physical constants; for example, @code{c}
|
|
represents the speed of light, and @code{h} represents Planck's
|
|
constant. You can use these just like other units: converting
|
|
@samp{.5 c} to @samp{m/s} expresses one-half the speed of light in
|
|
meters per second. You can also use this merely as a handy reference;
|
|
the @kbd{u g} command gets the definition of one of these constants
|
|
in its normal terms, and @kbd{u b} expresses the definition in base
|
|
units.
|
|
|
|
Two units, @code{pi} and @code{alpha} (the fine structure constant,
|
|
approximately @mathit{1/137}) are dimensionless. The units simplification
|
|
commands simply treat these names as equivalent to their corresponding
|
|
values. However you can, for example, use @kbd{u c} to convert a pure
|
|
number into multiples of the fine structure constant, or @kbd{u b} to
|
|
convert this back into a pure number. (When @kbd{u c} prompts for the
|
|
``old units,'' just enter a blank line to signify that the value
|
|
really is unitless.)
|
|
|
|
@c Describe angular units, luminosity vs. steradians problem.
|
|
|
|
@node User-Defined Units, , Predefined Units, Units
|
|
@section User-Defined Units
|
|
|
|
@noindent
|
|
Calc provides ways to get quick access to your selected ``favorite''
|
|
units, as well as ways to define your own new units.
|
|
|
|
@kindex u 0-9
|
|
@pindex calc-quick-units
|
|
@vindex Units
|
|
@cindex @code{Units} variable
|
|
@cindex Quick units
|
|
To select your favorite units, store a vector of unit names or
|
|
expressions in the Calc variable @code{Units}. The @kbd{u 1}
|
|
through @kbd{u 9} commands (@code{calc-quick-units}) provide access
|
|
to these units. If the value on the top of the stack is a plain
|
|
number (with no units attached), then @kbd{u 1} gives it the
|
|
specified units. (Basically, it multiplies the number by the
|
|
first item in the @code{Units} vector.) If the number on the
|
|
stack @emph{does} have units, then @kbd{u 1} converts that number
|
|
to the new units. For example, suppose the vector @samp{[in, ft]}
|
|
is stored in @code{Units}. Then @kbd{30 u 1} will create the
|
|
expression @samp{30 in}, and @kbd{u 2} will convert that expression
|
|
to @samp{2.5 ft}.
|
|
|
|
The @kbd{u 0} command accesses the tenth element of @code{Units}.
|
|
Only ten quick units may be defined at a time. If the @code{Units}
|
|
variable has no stored value (the default), or if its value is not
|
|
a vector, then the quick-units commands will not function. The
|
|
@kbd{s U} command is a convenient way to edit the @code{Units}
|
|
variable; @pxref{Operations on Variables}.
|
|
|
|
@kindex u d
|
|
@pindex calc-define-unit
|
|
@cindex User-defined units
|
|
The @kbd{u d} (@code{calc-define-unit}) command records the units
|
|
expression on the top of the stack as the definition for a new,
|
|
user-defined unit. For example, putting @samp{16.5 ft} on the stack and
|
|
typing @kbd{u d rod} defines the new unit @samp{rod} to be equivalent to
|
|
16.5 feet. The unit conversion and simplification commands will now
|
|
treat @code{rod} just like any other unit of length. You will also be
|
|
prompted for an optional English description of the unit, which will
|
|
appear in the Units Table.
|
|
|
|
@kindex u u
|
|
@pindex calc-undefine-unit
|
|
The @kbd{u u} (@code{calc-undefine-unit}) command removes a user-defined
|
|
unit. It is not possible to remove one of the predefined units,
|
|
however.
|
|
|
|
If you define a unit with an existing unit name, your new definition
|
|
will replace the original definition of that unit. If the unit was a
|
|
predefined unit, the old definition will not be replaced, only
|
|
``shadowed.'' The built-in definition will reappear if you later use
|
|
@kbd{u u} to remove the shadowing definition.
|
|
|
|
To create a new fundamental unit, use either 1 or the unit name itself
|
|
as the defining expression. Otherwise the expression can involve any
|
|
other units that you like (except for composite units like @samp{mfi}).
|
|
You can create a new composite unit with a sum of other units as the
|
|
defining expression. The next unit operation like @kbd{u c} or @kbd{u v}
|
|
will rebuild the internal unit table incorporating your modifications.
|
|
Note that erroneous definitions (such as two units defined in terms of
|
|
each other) will not be detected until the unit table is next rebuilt;
|
|
@kbd{u v} is a convenient way to force this to happen.
|
|
|
|
Temperature units are treated specially inside the Calculator; it is not
|
|
possible to create user-defined temperature units.
|
|
|
|
@kindex u p
|
|
@pindex calc-permanent-units
|
|
@cindex Calc init file, user-defined units
|
|
The @kbd{u p} (@code{calc-permanent-units}) command stores the user-defined
|
|
units in your Calc init file (the file given by the variable
|
|
@code{calc-settings-file}, typically @file{~/.calc.el}), so that the
|
|
units will still be available in subsequent Emacs sessions. If there
|
|
was already a set of user-defined units in your Calc init file, it
|
|
is replaced by the new set. (@xref{General Mode Commands}, for a way to
|
|
tell Calc to use a different file for the Calc init file.)
|
|
|
|
@node Store and Recall, Graphics, Units, Top
|
|
@chapter Storing and Recalling
|
|
|
|
@noindent
|
|
Calculator variables are really just Lisp variables that contain numbers
|
|
or formulas in a form that Calc can understand. The commands in this
|
|
section allow you to manipulate variables conveniently. Commands related
|
|
to variables use the @kbd{s} prefix key.
|
|
|
|
@menu
|
|
* Storing Variables::
|
|
* Recalling Variables::
|
|
* Operations on Variables::
|
|
* Let Command::
|
|
* Evaluates-To Operator::
|
|
@end menu
|
|
|
|
@node Storing Variables, Recalling Variables, Store and Recall, Store and Recall
|
|
@section Storing Variables
|
|
|
|
@noindent
|
|
@kindex s s
|
|
@pindex calc-store
|
|
@cindex Storing variables
|
|
@cindex Quick variables
|
|
@vindex q0
|
|
@vindex q9
|
|
The @kbd{s s} (@code{calc-store}) command stores the value at the top of
|
|
the stack into a specified variable. It prompts you to enter the
|
|
name of the variable. If you press a single digit, the value is stored
|
|
immediately in one of the ``quick'' variables @code{q0} through
|
|
@code{q9}. Or you can enter any variable name.
|
|
|
|
@kindex s t
|
|
@pindex calc-store-into
|
|
The @kbd{s s} command leaves the stored value on the stack. There is
|
|
also an @kbd{s t} (@code{calc-store-into}) command, which removes a
|
|
value from the stack and stores it in a variable.
|
|
|
|
If the top of stack value is an equation @samp{a = 7} or assignment
|
|
@samp{a := 7} with a variable on the lefthand side, then Calc will
|
|
assign that variable with that value by default, i.e., if you type
|
|
@kbd{s s @key{RET}} or @kbd{s t @key{RET}}. In this example, the
|
|
value 7 would be stored in the variable @samp{a}. (If you do type
|
|
a variable name at the prompt, the top-of-stack value is stored in
|
|
its entirety, even if it is an equation: @samp{s s b @key{RET}}
|
|
with @samp{a := 7} on the stack stores @samp{a := 7} in @code{b}.)
|
|
|
|
In fact, the top of stack value can be a vector of equations or
|
|
assignments with different variables on their lefthand sides; the
|
|
default will be to store all the variables with their corresponding
|
|
righthand sides simultaneously.
|
|
|
|
It is also possible to type an equation or assignment directly at
|
|
the prompt for the @kbd{s s} or @kbd{s t} command: @kbd{s s foo = 7}.
|
|
In this case the expression to the right of the @kbd{=} or @kbd{:=}
|
|
symbol is evaluated as if by the @kbd{=} command, and that value is
|
|
stored in the variable. No value is taken from the stack; @kbd{s s}
|
|
and @kbd{s t} are equivalent when used in this way.
|
|
|
|
@kindex s 0-9
|
|
@kindex t 0-9
|
|
The prefix keys @kbd{s} and @kbd{t} may be followed immediately by a
|
|
digit; @kbd{s 9} is equivalent to @kbd{s s 9}, and @kbd{t 9} is
|
|
equivalent to @kbd{s t 9}. (The @kbd{t} prefix is otherwise used
|
|
for trail and time/date commands.)
|
|
|
|
@kindex s +
|
|
@kindex s -
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex s *
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s /
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s ^
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s |
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s n
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s &
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s [
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s ]
|
|
@pindex calc-store-plus
|
|
@pindex calc-store-minus
|
|
@pindex calc-store-times
|
|
@pindex calc-store-div
|
|
@pindex calc-store-power
|
|
@pindex calc-store-concat
|
|
@pindex calc-store-neg
|
|
@pindex calc-store-inv
|
|
@pindex calc-store-decr
|
|
@pindex calc-store-incr
|
|
There are also several ``arithmetic store'' commands. For example,
|
|
@kbd{s +} removes a value from the stack and adds it to the specified
|
|
variable. The other arithmetic stores are @kbd{s -}, @kbd{s *}, @kbd{s /},
|
|
@kbd{s ^}, and @w{@kbd{s |}} (vector concatenation), plus @kbd{s n} and
|
|
@kbd{s &} which negate or invert the value in a variable, and @w{@kbd{s [}}
|
|
and @kbd{s ]} which decrease or increase a variable by one.
|
|
|
|
All the arithmetic stores accept the Inverse prefix to reverse the
|
|
order of the operands. If @expr{v} represents the contents of the
|
|
variable, and @expr{a} is the value drawn from the stack, then regular
|
|
@w{@kbd{s -}} assigns
|
|
@texline @math{v \coloneq v - a},
|
|
@infoline @expr{v := v - a},
|
|
but @kbd{I s -} assigns
|
|
@texline @math{v \coloneq a - v}.
|
|
@infoline @expr{v := a - v}.
|
|
While @kbd{I s *} might seem pointless, it is
|
|
useful if matrix multiplication is involved. Actually, all the
|
|
arithmetic stores use formulas designed to behave usefully both
|
|
forwards and backwards:
|
|
|
|
@example
|
|
@group
|
|
s + v := v + a v := a + v
|
|
s - v := v - a v := a - v
|
|
s * v := v * a v := a * v
|
|
s / v := v / a v := a / v
|
|
s ^ v := v ^ a v := a ^ v
|
|
s | v := v | a v := a | v
|
|
s n v := v / (-1) v := (-1) / v
|
|
s & v := v ^ (-1) v := (-1) ^ v
|
|
s [ v := v - 1 v := 1 - v
|
|
s ] v := v - (-1) v := (-1) - v
|
|
@end group
|
|
@end example
|
|
|
|
In the last four cases, a numeric prefix argument will be used in
|
|
place of the number one. (For example, @kbd{M-2 s ]} increases
|
|
a variable by 2, and @kbd{M-2 I s ]} replaces a variable by
|
|
minus-two minus the variable.
|
|
|
|
The first six arithmetic stores can also be typed @kbd{s t +}, @kbd{s t -},
|
|
etc. The commands @kbd{s s +}, @kbd{s s -}, and so on are analogous
|
|
arithmetic stores that don't remove the value @expr{a} from the stack.
|
|
|
|
All arithmetic stores report the new value of the variable in the
|
|
Trail for your information. They signal an error if the variable
|
|
previously had no stored value. If default simplifications have been
|
|
turned off, the arithmetic stores temporarily turn them on for numeric
|
|
arguments only (i.e., they temporarily do an @kbd{m N} command).
|
|
@xref{Simplification Modes}. Large vectors put in the trail by
|
|
these commands always use abbreviated (@kbd{t .}) mode.
|
|
|
|
@kindex s m
|
|
@pindex calc-store-map
|
|
The @kbd{s m} command is a general way to adjust a variable's value
|
|
using any Calc function. It is a ``mapping'' command analogous to
|
|
@kbd{V M}, @kbd{V R}, etc. @xref{Reducing and Mapping}, to see
|
|
how to specify a function for a mapping command. Basically,
|
|
all you do is type the Calc command key that would invoke that
|
|
function normally. For example, @kbd{s m n} applies the @kbd{n}
|
|
key to negate the contents of the variable, so @kbd{s m n} is
|
|
equivalent to @kbd{s n}. Also, @kbd{s m Q} takes the square root
|
|
of the value stored in a variable, @kbd{s m v v} uses @kbd{v v} to
|
|
reverse the vector stored in the variable, and @kbd{s m H I S}
|
|
takes the hyperbolic arcsine of the variable contents.
|
|
|
|
If the mapping function takes two or more arguments, the additional
|
|
arguments are taken from the stack; the old value of the variable
|
|
is provided as the first argument. Thus @kbd{s m -} with @expr{a}
|
|
on the stack computes @expr{v - a}, just like @kbd{s -}. With the
|
|
Inverse prefix, the variable's original value becomes the @emph{last}
|
|
argument instead of the first. Thus @kbd{I s m -} is also
|
|
equivalent to @kbd{I s -}.
|
|
|
|
@kindex s x
|
|
@pindex calc-store-exchange
|
|
The @kbd{s x} (@code{calc-store-exchange}) command exchanges the value
|
|
of a variable with the value on the top of the stack. Naturally, the
|
|
variable must already have a stored value for this to work.
|
|
|
|
You can type an equation or assignment at the @kbd{s x} prompt. The
|
|
command @kbd{s x a=6} takes no values from the stack; instead, it
|
|
pushes the old value of @samp{a} on the stack and stores @samp{a = 6}.
|
|
|
|
@kindex s u
|
|
@pindex calc-unstore
|
|
@cindex Void variables
|
|
@cindex Un-storing variables
|
|
Until you store something in them, most variables are ``void,'' that is,
|
|
they contain no value at all. If they appear in an algebraic formula
|
|
they will be left alone even if you press @kbd{=} (@code{calc-evaluate}).
|
|
The @kbd{s u} (@code{calc-unstore}) command returns a variable to the
|
|
void state.
|
|
|
|
@kindex s c
|
|
@pindex calc-copy-variable
|
|
The @kbd{s c} (@code{calc-copy-variable}) command copies the stored
|
|
value of one variable to another. One way it differs from a simple
|
|
@kbd{s r} followed by an @kbd{s t} (aside from saving keystrokes) is
|
|
that the value never goes on the stack and thus is never rounded,
|
|
evaluated, or simplified in any way; it is not even rounded down to the
|
|
current precision.
|
|
|
|
The only variables with predefined values are the ``special constants''
|
|
@code{pi}, @code{e}, @code{i}, @code{phi}, and @code{gamma}. You are free
|
|
to unstore these variables or to store new values into them if you like,
|
|
although some of the algebraic-manipulation functions may assume these
|
|
variables represent their standard values. Calc displays a warning if
|
|
you change the value of one of these variables, or of one of the other
|
|
special variables @code{inf}, @code{uinf}, and @code{nan} (which are
|
|
normally void).
|
|
|
|
Note that @code{pi} doesn't actually have 3.14159265359 stored in it,
|
|
but rather a special magic value that evaluates to @cpi{} at the current
|
|
precision. Likewise @code{e}, @code{i}, and @code{phi} evaluate
|
|
according to the current precision or polar mode. If you recall a value
|
|
from @code{pi} and store it back, this magic property will be lost. The
|
|
magic property is preserved, however, when a variable is copied with
|
|
@kbd{s c}.
|
|
|
|
@kindex s k
|
|
@pindex calc-copy-special-constant
|
|
If one of the ``special constants'' is redefined (or undefined) so that
|
|
it no longer has its magic property, the property can be restored with
|
|
@kbd{s k} (@code{calc-copy-special-constant}). This command will prompt
|
|
for a special constant and a variable to store it in, and so a special
|
|
constant can be stored in any variable. Here, the special constant that
|
|
you enter doesn't depend on the value of the corresponding variable;
|
|
@code{pi} will represent 3.14159@dots{} regardless of what is currently
|
|
stored in the Calc variable @code{pi}. If one of the other special
|
|
variables, @code{inf}, @code{uinf} or @code{nan}, is given a value, its
|
|
original behavior can be restored by voiding it with @kbd{s u}.
|
|
|
|
@node Recalling Variables, Operations on Variables, Storing Variables, Store and Recall
|
|
@section Recalling Variables
|
|
|
|
@noindent
|
|
@kindex s r
|
|
@pindex calc-recall
|
|
@cindex Recalling variables
|
|
The most straightforward way to extract the stored value from a variable
|
|
is to use the @kbd{s r} (@code{calc-recall}) command. This command prompts
|
|
for a variable name (similarly to @code{calc-store}), looks up the value
|
|
of the specified variable, and pushes that value onto the stack. It is
|
|
an error to try to recall a void variable.
|
|
|
|
It is also possible to recall the value from a variable by evaluating a
|
|
formula containing that variable. For example, @kbd{' a @key{RET} =} is
|
|
the same as @kbd{s r a @key{RET}} except that if the variable is void, the
|
|
former will simply leave the formula @samp{a} on the stack whereas the
|
|
latter will produce an error message.
|
|
|
|
@kindex r 0-9
|
|
The @kbd{r} prefix may be followed by a digit, so that @kbd{r 9} is
|
|
equivalent to @kbd{s r 9}. (The @kbd{r} prefix is otherwise unused
|
|
in the current version of Calc.)
|
|
|
|
@node Operations on Variables, Let Command, Recalling Variables, Store and Recall
|
|
@section Other Operations on Variables
|
|
|
|
@noindent
|
|
@kindex s e
|
|
@pindex calc-edit-variable
|
|
The @kbd{s e} (@code{calc-edit-variable}) command edits the stored
|
|
value of a variable without ever putting that value on the stack
|
|
or simplifying or evaluating the value. It prompts for the name of
|
|
the variable to edit. If the variable has no stored value, the
|
|
editing buffer will start out empty. If the editing buffer is
|
|
empty when you press @kbd{C-c C-c} to finish, the variable will
|
|
be made void. @xref{Editing Stack Entries}, for a general
|
|
description of editing.
|
|
|
|
The @kbd{s e} command is especially useful for creating and editing
|
|
rewrite rules which are stored in variables. Sometimes these rules
|
|
contain formulas which must not be evaluated until the rules are
|
|
actually used. (For example, they may refer to @samp{deriv(x,y)},
|
|
where @code{x} will someday become some expression involving @code{y};
|
|
if you let Calc evaluate the rule while you are defining it, Calc will
|
|
replace @samp{deriv(x,y)} with 0 because the formula @code{x} does
|
|
not itself refer to @code{y}.) By contrast, recalling the variable,
|
|
editing with @kbd{`}, and storing will evaluate the variable's value
|
|
as a side effect of putting the value on the stack.
|
|
|
|
@kindex s A
|
|
@kindex s D
|
|
@ignore
|
|
@mindex @idots
|
|
@end ignore
|
|
@kindex s E
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s F
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s G
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s H
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s I
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s L
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s P
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s R
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s T
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s U
|
|
@ignore
|
|
@mindex @null
|
|
@end ignore
|
|
@kindex s X
|
|
@pindex calc-store-AlgSimpRules
|
|
@pindex calc-store-Decls
|
|
@pindex calc-store-EvalRules
|
|
@pindex calc-store-FitRules
|
|
@pindex calc-store-GenCount
|
|
@pindex calc-store-Holidays
|
|
@pindex calc-store-IntegLimit
|
|
@pindex calc-store-LineStyles
|
|
@pindex calc-store-PointStyles
|
|
@pindex calc-store-PlotRejects
|
|
@pindex calc-store-TimeZone
|
|
@pindex calc-store-Units
|
|
@pindex calc-store-ExtSimpRules
|
|
There are several special-purpose variable-editing commands that
|
|
use the @kbd{s} prefix followed by a shifted letter:
|
|
|
|
@table @kbd
|
|
@item s A
|
|
Edit @code{AlgSimpRules}. @xref{Algebraic Simplifications}.
|
|
@item s D
|
|
Edit @code{Decls}. @xref{Declarations}.
|
|
@item s E
|
|
Edit @code{EvalRules}. @xref{Default Simplifications}.
|
|
@item s F
|
|
Edit @code{FitRules}. @xref{Curve Fitting}.
|
|
@item s G
|
|
Edit @code{GenCount}. @xref{Solving Equations}.
|
|
@item s H
|
|
Edit @code{Holidays}. @xref{Business Days}.
|
|
@item s I
|
|
Edit @code{IntegLimit}. @xref{Calculus}.
|
|
@item s L
|
|
Edit @code{LineStyles}. @xref{Graphics}.
|
|
@item s P
|
|
Edit @code{PointStyles}. @xref{Graphics}.
|
|
@item s R
|
|
Edit @code{PlotRejects}. @xref{Graphics}.
|
|
@item s T
|
|
Edit @code{TimeZone}. @xref{Time Zones}.
|
|
@item s U
|
|
Edit @code{Units}. @xref{User-Defined Units}.
|
|
@item s X
|
|
Edit @code{ExtSimpRules}. @xref{Unsafe Simplifications}.
|
|
@end table
|
|
|
|
These commands are just versions of @kbd{s e} that use fixed variable
|
|
names rather than prompting for the variable name.
|
|
|
|
@kindex s p
|
|
@pindex calc-permanent-variable
|
|
@cindex Storing variables
|
|
@cindex Permanent variables
|
|
@cindex Calc init file, variables
|
|
The @kbd{s p} (@code{calc-permanent-variable}) command saves a
|
|
variable's value permanently in your Calc init file (the file given by
|
|
the variable @code{calc-settings-file}, typically @file{~/.calc.el}), so
|
|
that its value will still be available in future Emacs sessions. You
|
|
can re-execute @w{@kbd{s p}} later on to update the saved value, but the
|
|
only way to remove a saved variable is to edit your calc init file
|
|
by hand. (@xref{General Mode Commands}, for a way to tell Calc to
|
|
use a different file for the Calc init file.)
|
|
|
|
If you do not specify the name of a variable to save (i.e.,
|
|
@kbd{s p @key{RET}}), all Calc variables with defined values
|
|
are saved except for the special constants @code{pi}, @code{e},
|
|
@code{i}, @code{phi}, and @code{gamma}; the variables @code{TimeZone}
|
|
and @code{PlotRejects};
|
|
@code{FitRules}, @code{DistribRules}, and other built-in rewrite
|
|
rules; and @code{PlotData@var{n}} variables generated
|
|
by the graphics commands. (You can still save these variables by
|
|
explicitly naming them in an @kbd{s p} command.)
|
|
|
|
@kindex s i
|
|
@pindex calc-insert-variables
|
|
The @kbd{s i} (@code{calc-insert-variables}) command writes
|
|
the values of all Calc variables into a specified buffer.
|
|
The variables are written with the prefix @code{var-} in the form of
|
|
Lisp @code{setq} commands
|
|
which store the values in string form. You can place these commands
|
|
in your Calc init file (or @file{.emacs}) if you wish, though in this case it
|
|
would be easier to use @kbd{s p @key{RET}}. (Note that @kbd{s i}
|
|
omits the same set of variables as @w{@kbd{s p @key{RET}}}; the difference
|
|
is that @kbd{s i} will store the variables in any buffer, and it also
|
|
stores in a more human-readable format.)
|
|
|
|
@node Let Command, Evaluates-To Operator, Operations on Variables, Store and Recall
|
|
@section The Let Command
|
|
|
|
@noindent
|
|
@kindex s l
|
|
@pindex calc-let
|
|
@cindex Variables, temporary assignment
|
|
@cindex Temporary assignment to variables
|
|
If you have an expression like @samp{a+b^2} on the stack and you wish to
|
|
compute its value where @expr{b=3}, you can simply store 3 in @expr{b} and
|
|
then press @kbd{=} to reevaluate the formula. This has the side-effect
|
|
of leaving the stored value of 3 in @expr{b} for future operations.
|
|
|
|
The @kbd{s l} (@code{calc-let}) command evaluates a formula under a
|
|
@emph{temporary} assignment of a variable. It stores the value on the
|
|
top of the stack into the specified variable, then evaluates the
|
|
second-to-top stack entry, then restores the original value (or lack of one)
|
|
in the variable. Thus after @kbd{'@w{ }a+b^2 @key{RET} 3 s l b @key{RET}},
|
|
the stack will contain the formula @samp{a + 9}. The subsequent command
|
|
@kbd{@w{5 s l a} @key{RET}} will replace this formula with the number 14.
|
|
The variables @samp{a} and @samp{b} are not permanently affected in any way
|
|
by these commands.
|
|
|
|
The value on the top of the stack may be an equation or assignment, or
|
|
a vector of equations or assignments, in which case the default will be
|
|
analogous to the case of @kbd{s t @key{RET}}. @xref{Storing Variables}.
|
|
|
|
Also, you can answer the variable-name prompt with an equation or
|
|
assignment: @kbd{s l b=3 @key{RET}} is the same as storing 3 on the stack
|
|
and typing @kbd{s l b @key{RET}}.
|
|
|
|
The @kbd{a b} (@code{calc-substitute}) command is another way to substitute
|
|
a variable with a value in a formula. It does an actual substitution
|
|
rather than temporarily assigning the variable and evaluating. For
|
|
example, letting @expr{n=2} in @samp{f(n pi)} with @kbd{a b} will
|
|
produce @samp{f(2 pi)}, whereas @kbd{s l} would give @samp{f(6.28)}
|
|
since the evaluation step will also evaluate @code{pi}.
|
|
|
|
@node Evaluates-To Operator, , Let Command, Store and Recall
|
|
@section The Evaluates-To Operator
|
|
|
|
@noindent
|
|
@tindex evalto
|
|
@tindex =>
|
|
@cindex Evaluates-to operator
|
|
@cindex @samp{=>} operator
|
|
The special algebraic symbol @samp{=>} is known as the @dfn{evaluates-to
|
|
operator}. (It will show up as an @code{evalto} function call in
|
|
other language modes like Pascal and La@TeX{}.) This is a binary
|
|
operator, that is, it has a lefthand and a righthand argument,
|
|
although it can be entered with the righthand argument omitted.
|
|
|
|
A formula like @samp{@var{a} => @var{b}} is evaluated by Calc as
|
|
follows: First, @var{a} is not simplified or modified in any
|
|
way. The previous value of argument @var{b} is thrown away; the
|
|
formula @var{a} is then copied and evaluated as if by the @kbd{=}
|
|
command according to all current modes and stored variable values,
|
|
and the result is installed as the new value of @var{b}.
|
|
|
|
For example, suppose you enter the algebraic formula @samp{2 + 3 => 17}.
|
|
The number 17 is ignored, and the lefthand argument is left in its
|
|
unevaluated form; the result is the formula @samp{2 + 3 => 5}.
|
|
|
|
@kindex s =
|
|
@pindex calc-evalto
|
|
You can enter an @samp{=>} formula either directly using algebraic
|
|
entry (in which case the righthand side may be omitted since it is
|
|
going to be replaced right away anyhow), or by using the @kbd{s =}
|
|
(@code{calc-evalto}) command, which takes @var{a} from the stack
|
|
and replaces it with @samp{@var{a} => @var{b}}.
|
|
|
|
Calc keeps track of all @samp{=>} operators on the stack, and
|
|
recomputes them whenever anything changes that might affect their
|
|
values, i.e., a mode setting or variable value. This occurs only
|
|
if the @samp{=>} operator is at the top level of the formula, or
|
|
if it is part of a top-level vector. In other words, pushing
|
|
@samp{2 + (a => 17)} will change the 17 to the actual value of
|
|
@samp{a} when you enter the formula, but the result will not be
|
|
dynamically updated when @samp{a} is changed later because the
|
|
@samp{=>} operator is buried inside a sum. However, a vector
|
|
of @samp{=>} operators will be recomputed, since it is convenient
|
|
to push a vector like @samp{[a =>, b =>, c =>]} on the stack to
|
|
make a concise display of all the variables in your problem.
|
|
(Another way to do this would be to use @samp{[a, b, c] =>},
|
|
which provides a slightly different format of display. You
|
|
can use whichever you find easiest to read.)
|
|
|
|
@kindex m C
|
|
@pindex calc-auto-recompute
|
|
The @kbd{m C} (@code{calc-auto-recompute}) command allows you to
|
|
turn this automatic recomputation on or off. If you turn
|
|
recomputation off, you must explicitly recompute an @samp{=>}
|
|
operator on the stack in one of the usual ways, such as by
|
|
pressing @kbd{=}. Turning recomputation off temporarily can save
|
|
a lot of time if you will be changing several modes or variables
|
|
before you look at the @samp{=>} entries again.
|
|
|
|
Most commands are not especially useful with @samp{=>} operators
|
|
as arguments. For example, given @samp{x + 2 => 17}, it won't
|
|
work to type @kbd{1 +} to get @samp{x + 3 => 18}. If you want
|
|
to operate on the lefthand side of the @samp{=>} operator on
|
|
the top of the stack, type @kbd{j 1} (that's the digit ``one'')
|
|
to select the lefthand side, execute your commands, then type
|
|
@kbd{j u} to unselect.
|
|
|
|
All current modes apply when an @samp{=>} operator is computed,
|
|
including the current simplification mode. Recall that the
|
|
formula @samp{x + y + x} is not handled by Calc's default
|
|
simplifications, but the @kbd{a s} command will reduce it to
|
|
the simpler form @samp{y + 2 x}. You can also type @kbd{m A}
|
|
to enable an Algebraic Simplification mode in which the
|
|
equivalent of @kbd{a s} is used on all of Calc's results.
|
|
If you enter @samp{x + y + x =>} normally, the result will
|
|
be @samp{x + y + x => x + y + x}. If you change to
|
|
Algebraic Simplification mode, the result will be
|
|
@samp{x + y + x => y + 2 x}. However, just pressing @kbd{a s}
|
|
once will have no effect on @samp{x + y + x => x + y + x},
|
|
because the righthand side depends only on the lefthand side
|
|
and the current mode settings, and the lefthand side is not
|
|
affected by commands like @kbd{a s}.
|
|
|
|
The ``let'' command (@kbd{s l}) has an interesting interaction
|
|
with the @samp{=>} operator. The @kbd{s l} command evaluates the
|
|
second-to-top stack entry with the top stack entry supplying
|
|
a temporary value for a given variable. As you might expect,
|
|
if that stack entry is an @samp{=>} operator its righthand
|
|
side will temporarily show this value for the variable. In
|
|
fact, all @samp{=>}s on the stack will be updated if they refer
|
|
to that variable. But this change is temporary in the sense
|
|
that the next command that causes Calc to look at those stack
|
|
entries will make them revert to the old variable value.
|
|
|
|
@smallexample
|
|
@group
|
|
2: a => a 2: a => 17 2: a => a
|
|
1: a + 1 => a + 1 1: a + 1 => 18 1: a + 1 => a + 1
|
|
. . .
|
|
|
|
17 s l a @key{RET} p 8 @key{RET}
|
|
@end group
|
|
@end smallexample
|
|
|
|
Here the @kbd{p 8} command changes the current precision,
|
|
thus causing the @samp{=>} forms to be recomputed after the
|
|
influence of the ``let'' is gone. The @kbd{d @key{SPC}} command
|
|
(@code{calc-refresh}) is a handy way to force the @samp{=>}
|
|
operators on the stack to be recomputed without any other
|
|
side effects.
|
|
|
|
@kindex s :
|
|
@pindex calc-assign
|
|
@tindex assign
|
|
@tindex :=
|
|
Embedded mode also uses @samp{=>} operators. In Embedded mode,
|
|
the lefthand side of an @samp{=>} operator can refer to variables
|
|
assigned elsewhere in the file by @samp{:=} operators. The
|
|
assignment operator @samp{a := 17} does not actually do anything
|
|
by itself. But Embedded mode recognizes it and marks it as a sort
|
|
of file-local definition of the variable. You can enter @samp{:=}
|
|
operators in Algebraic mode, or by using the @kbd{s :}
|
|
(@code{calc-assign}) [@code{assign}] command which takes a variable
|
|
and value from the stack and replaces them with an assignment.
|
|
|
|
@xref{TeX and LaTeX Language Modes}, for the way @samp{=>} appears in
|
|
@TeX{} language output. The @dfn{eqn} mode gives similar
|
|
treatment to @samp{=>}.
|
|
|
|
@node Graphics, Kill and Yank, Store and Recall, Top
|
|
@chapter Graphics
|
|
|
|
@noindent
|
|
The commands for graphing data begin with the @kbd{g} prefix key. Calc
|
|
uses GNUPLOT 2.0 or later to do graphics. These commands will only work
|
|
if GNUPLOT is available on your system. (While GNUPLOT sounds like
|
|
a relative of GNU Emacs, it is actually completely unrelated.
|
|
However, it is free software. It can be obtained from
|
|
@samp{http://www.gnuplot.info}.)
|
|
|
|
@vindex calc-gnuplot-name
|
|
If you have GNUPLOT installed on your system but Calc is unable to
|
|
find it, you may need to set the @code{calc-gnuplot-name} variable
|
|
in your Calc init file or @file{.emacs}. You may also need to set some Lisp
|
|
variables to show Calc how to run GNUPLOT on your system; these
|
|
are described under @kbd{g D} and @kbd{g O} below. If you are
|
|
using the X window system, Calc will configure GNUPLOT for you
|
|
automatically. If you have GNUPLOT 3.0 or later and you are not using X,
|
|
Calc will configure GNUPLOT to display graphs using simple character
|
|
graphics that will work on any terminal.
|
|
|
|
@menu
|
|
* Basic Graphics::
|
|
* Three Dimensional Graphics::
|
|
* Managing Curves::
|
|
* Graphics Options::
|
|
* Devices::
|
|
@end menu
|
|
|
|
@node Basic Graphics, Three Dimensional Graphics, Graphics, Graphics
|
|
@section Basic Graphics
|
|
|
|
@noindent
|
|
@kindex g f
|
|
@pindex calc-graph-fast
|
|
The easiest graphics command is @kbd{g f} (@code{calc-graph-fast}).
|
|
This command takes two vectors of equal length from the stack.
|
|
The vector at the top of the stack represents the ``y'' values of
|
|
the various data points. The vector in the second-to-top position
|
|
represents the corresponding ``x'' values. This command runs
|
|
GNUPLOT (if it has not already been started by previous graphing
|
|
commands) and displays the set of data points. The points will
|
|
be connected by lines, and there will also be some kind of symbol
|
|
to indicate the points themselves.
|
|
|
|
The ``x'' entry may instead be an interval form, in which case suitable
|
|
``x'' values are interpolated between the minimum and maximum values of
|
|
the interval (whether the interval is open or closed is ignored).
|
|
|
|
The ``x'' entry may also be a number, in which case Calc uses the
|
|
sequence of ``x'' values @expr{x}, @expr{x+1}, @expr{x+2}, etc.
|
|
(Generally the number 0 or 1 would be used for @expr{x} in this case.)
|
|
|
|
The ``y'' entry may be any formula instead of a vector. Calc effectively
|
|
uses @kbd{N} (@code{calc-eval-num}) to evaluate variables in the formula;
|
|
the result of this must be a formula in a single (unassigned) variable.
|
|
The formula is plotted with this variable taking on the various ``x''
|
|
values. Graphs of formulas by default use lines without symbols at the
|
|
computed data points. Note that if neither ``x'' nor ``y'' is a vector,
|
|
Calc guesses at a reasonable number of data points to use. See the
|
|
@kbd{g N} command below. (The ``x'' values must be either a vector
|
|
or an interval if ``y'' is a formula.)
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex xy
|
|
If ``y'' is (or evaluates to) a formula of the form
|
|
@samp{xy(@var{x}, @var{y})} then the result is a
|
|
parametric plot. The two arguments of the fictitious @code{xy} function
|
|
are used as the ``x'' and ``y'' coordinates of the curve, respectively.
|
|
In this case the ``x'' vector or interval you specified is not directly
|
|
visible in the graph. For example, if ``x'' is the interval @samp{[0..360]}
|
|
and ``y'' is the formula @samp{xy(sin(t), cos(t))}, the resulting graph
|
|
will be a circle.
|
|
|
|
Also, ``x'' and ``y'' may each be variable names, in which case Calc
|
|
looks for suitable vectors, intervals, or formulas stored in those
|
|
variables.
|
|
|
|
The ``x'' and ``y'' values for the data points (as pulled from the vectors,
|
|
calculated from the formulas, or interpolated from the intervals) should
|
|
be real numbers (integers, fractions, or floats). If either the ``x''
|
|
value or the ``y'' value of a given data point is not a real number, that
|
|
data point will be omitted from the graph. The points on either side
|
|
of the invalid point will @emph{not} be connected by a line.
|
|
|
|
See the documentation for @kbd{g a} below for a description of the way
|
|
numeric prefix arguments affect @kbd{g f}.
|
|
|
|
@cindex @code{PlotRejects} variable
|
|
@vindex PlotRejects
|
|
If you store an empty vector in the variable @code{PlotRejects}
|
|
(i.e., @kbd{[ ] s t PlotRejects}), Calc will append information to
|
|
this vector for every data point which was rejected because its
|
|
``x'' or ``y'' values were not real numbers. The result will be
|
|
a matrix where each row holds the curve number, data point number,
|
|
``x'' value, and ``y'' value for a rejected data point.
|
|
@xref{Evaluates-To Operator}, for a handy way to keep tabs on the
|
|
current value of @code{PlotRejects}. @xref{Operations on Variables},
|
|
for the @kbd{s R} command which is another easy way to examine
|
|
@code{PlotRejects}.
|
|
|
|
@kindex g c
|
|
@pindex calc-graph-clear
|
|
To clear the graphics display, type @kbd{g c} (@code{calc-graph-clear}).
|
|
If the GNUPLOT output device is an X window, the window will go away.
|
|
Effects on other kinds of output devices will vary. You don't need
|
|
to use @kbd{g c} if you don't want to---if you give another @kbd{g f}
|
|
or @kbd{g p} command later on, it will reuse the existing graphics
|
|
window if there is one.
|
|
|
|
@node Three Dimensional Graphics, Managing Curves, Basic Graphics, Graphics
|
|
@section Three-Dimensional Graphics
|
|
|
|
@kindex g F
|
|
@pindex calc-graph-fast-3d
|
|
The @kbd{g F} (@code{calc-graph-fast-3d}) command makes a three-dimensional
|
|
graph. It works only if you have GNUPLOT 3.0 or later; with GNUPLOT 2.0,
|
|
you will see a GNUPLOT error message if you try this command.
|
|
|
|
The @kbd{g F} command takes three values from the stack, called ``x'',
|
|
``y'', and ``z'', respectively. As was the case for 2D graphs, there
|
|
are several options for these values.
|
|
|
|
In the first case, ``x'' and ``y'' are each vectors (not necessarily of
|
|
the same length); either or both may instead be interval forms. The
|
|
``z'' value must be a matrix with the same number of rows as elements
|
|
in ``x'', and the same number of columns as elements in ``y''. The
|
|
result is a surface plot where
|
|
@texline @math{z_{ij}}
|
|
@infoline @expr{z_ij}
|
|
is the height of the point
|
|
at coordinate @expr{(x_i, y_j)} on the surface. The 3D graph will
|
|
be displayed from a certain default viewpoint; you can change this
|
|
viewpoint by adding a @samp{set view} to the @samp{*Gnuplot Commands*}
|
|
buffer as described later. See the GNUPLOT documentation for a
|
|
description of the @samp{set view} command.
|
|
|
|
Each point in the matrix will be displayed as a dot in the graph,
|
|
and these points will be connected by a grid of lines (@dfn{isolines}).
|
|
|
|
In the second case, ``x'', ``y'', and ``z'' are all vectors of equal
|
|
length. The resulting graph displays a 3D line instead of a surface,
|
|
where the coordinates of points along the line are successive triplets
|
|
of values from the input vectors.
|
|
|
|
In the third case, ``x'' and ``y'' are vectors or interval forms, and
|
|
``z'' is any formula involving two variables (not counting variables
|
|
with assigned values). These variables are sorted into alphabetical
|
|
order; the first takes on values from ``x'' and the second takes on
|
|
values from ``y'' to form a matrix of results that are graphed as a
|
|
3D surface.
|
|
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex xyz
|
|
If the ``z'' formula evaluates to a call to the fictitious function
|
|
@samp{xyz(@var{x}, @var{y}, @var{z})}, then the result is a
|
|
``parametric surface.'' In this case, the axes of the graph are
|
|
taken from the @var{x} and @var{y} values in these calls, and the
|
|
``x'' and ``y'' values from the input vectors or intervals are used only
|
|
to specify the range of inputs to the formula. For example, plotting
|
|
@samp{[0..360], [0..180], xyz(sin(x)*sin(y), cos(x)*sin(y), cos(y))}
|
|
will draw a sphere. (Since the default resolution for 3D plots is
|
|
5 steps in each of ``x'' and ``y'', this will draw a very crude
|
|
sphere. You could use the @kbd{g N} command, described below, to
|
|
increase this resolution, or specify the ``x'' and ``y'' values as
|
|
vectors with more than 5 elements.
|
|
|
|
It is also possible to have a function in a regular @kbd{g f} plot
|
|
evaluate to an @code{xyz} call. Since @kbd{g f} plots a line, not
|
|
a surface, the result will be a 3D parametric line. For example,
|
|
@samp{[[0..720], xyz(sin(x), cos(x), x)]} will plot two turns of a
|
|
helix (a three-dimensional spiral).
|
|
|
|
As for @kbd{g f}, each of ``x'', ``y'', and ``z'' may instead be
|
|
variables containing the relevant data.
|
|
|
|
@node Managing Curves, Graphics Options, Three Dimensional Graphics, Graphics
|
|
@section Managing Curves
|
|
|
|
@noindent
|
|
The @kbd{g f} command is really shorthand for the following commands:
|
|
@kbd{C-u g d g a g p}. Likewise, @w{@kbd{g F}} is shorthand for
|
|
@kbd{C-u g d g A g p}. You can gain more control over your graph
|
|
by using these commands directly.
|
|
|
|
@kindex g a
|
|
@pindex calc-graph-add
|
|
The @kbd{g a} (@code{calc-graph-add}) command adds the ``curve''
|
|
represented by the two values on the top of the stack to the current
|
|
graph. You can have any number of curves in the same graph. When
|
|
you give the @kbd{g p} command, all the curves will be drawn superimposed
|
|
on the same axes.
|
|
|
|
The @kbd{g a} command (and many others that affect the current graph)
|
|
will cause a special buffer, @samp{*Gnuplot Commands*}, to be displayed
|
|
in another window. This buffer is a template of the commands that will
|
|
be sent to GNUPLOT when it is time to draw the graph. The first
|
|
@kbd{g a} command adds a @code{plot} command to this buffer. Succeeding
|
|
@kbd{g a} commands add extra curves onto that @code{plot} command.
|
|
Other graph-related commands put other GNUPLOT commands into this
|
|
buffer. In normal usage you never need to work with this buffer
|
|
directly, but you can if you wish. The only constraint is that there
|
|
must be only one @code{plot} command, and it must be the last command
|
|
in the buffer. If you want to save and later restore a complete graph
|
|
configuration, you can use regular Emacs commands to save and restore
|
|
the contents of the @samp{*Gnuplot Commands*} buffer.
|
|
|
|
@vindex PlotData1
|
|
@vindex PlotData2
|
|
If the values on the stack are not variable names, @kbd{g a} will invent
|
|
variable names for them (of the form @samp{PlotData@var{n}}) and store
|
|
the values in those variables. The ``x'' and ``y'' variables are what
|
|
go into the @code{plot} command in the template. If you add a curve
|
|
that uses a certain variable and then later change that variable, you
|
|
can replot the graph without having to delete and re-add the curve.
|
|
That's because the variable name, not the vector, interval or formula
|
|
itself, is what was added by @kbd{g a}.
|
|
|
|
A numeric prefix argument on @kbd{g a} or @kbd{g f} changes the way
|
|
stack entries are interpreted as curves. With a positive prefix
|
|
argument @expr{n}, the top @expr{n} stack entries are ``y'' values
|
|
for @expr{n} different curves which share a common ``x'' value in
|
|
the @expr{n+1}st stack entry. (Thus @kbd{g a} with no prefix
|
|
argument is equivalent to @kbd{C-u 1 g a}.)
|
|
|
|
A prefix of zero or plain @kbd{C-u} means to take two stack entries,
|
|
``x'' and ``y'' as usual, but to interpret ``y'' as a vector of
|
|
``y'' values for several curves that share a common ``x''.
|
|
|
|
A negative prefix argument tells Calc to read @expr{n} vectors from
|
|
the stack; each vector @expr{[x, y]} describes an independent curve.
|
|
This is the only form of @kbd{g a} that creates several curves at once
|
|
that don't have common ``x'' values. (Of course, the range of ``x''
|
|
values covered by all the curves ought to be roughly the same if
|
|
they are to look nice on the same graph.)
|
|
|
|
For example, to plot
|
|
@texline @math{\sin n x}
|
|
@infoline @expr{sin(n x)}
|
|
for integers @expr{n}
|
|
from 1 to 5, you could use @kbd{v x} to create a vector of integers
|
|
(@expr{n}), then @kbd{V M '} or @kbd{V M $} to map @samp{sin(n x)}
|
|
across this vector. The resulting vector of formulas is suitable
|
|
for use as the ``y'' argument to a @kbd{C-u g a} or @kbd{C-u g f}
|
|
command.
|
|
|
|
@kindex g A
|
|
@pindex calc-graph-add-3d
|
|
The @kbd{g A} (@code{calc-graph-add-3d}) command adds a 3D curve
|
|
to the graph. It is not valid to intermix 2D and 3D curves in a
|
|
single graph. This command takes three arguments, ``x'', ``y'',
|
|
and ``z'', from the stack. With a positive prefix @expr{n}, it
|
|
takes @expr{n+2} arguments (common ``x'' and ``y'', plus @expr{n}
|
|
separate ``z''s). With a zero prefix, it takes three stack entries
|
|
but the ``z'' entry is a vector of curve values. With a negative
|
|
prefix @expr{-n}, it takes @expr{n} vectors of the form @expr{[x, y, z]}.
|
|
The @kbd{g A} command works by adding a @code{splot} (surface-plot)
|
|
command to the @samp{*Gnuplot Commands*} buffer.
|
|
|
|
(Although @kbd{g a} adds a 2D @code{plot} command to the
|
|
@samp{*Gnuplot Commands*} buffer, Calc changes this to @code{splot}
|
|
before sending it to GNUPLOT if it notices that the data points are
|
|
evaluating to @code{xyz} calls. It will not work to mix 2D and 3D
|
|
@kbd{g a} curves in a single graph, although Calc does not currently
|
|
check for this.)
|
|
|
|
@kindex g d
|
|
@pindex calc-graph-delete
|
|
The @kbd{g d} (@code{calc-graph-delete}) command deletes the most
|
|
recently added curve from the graph. It has no effect if there are
|
|
no curves in the graph. With a numeric prefix argument of any kind,
|
|
it deletes all of the curves from the graph.
|
|
|
|
@kindex g H
|
|
@pindex calc-graph-hide
|
|
The @kbd{g H} (@code{calc-graph-hide}) command ``hides'' or ``unhides''
|
|
the most recently added curve. A hidden curve will not appear in
|
|
the actual plot, but information about it such as its name and line and
|
|
point styles will be retained.
|
|
|
|
@kindex g j
|
|
@pindex calc-graph-juggle
|
|
The @kbd{g j} (@code{calc-graph-juggle}) command moves the curve
|
|
at the end of the list (the ``most recently added curve'') to the
|
|
front of the list. The next-most-recent curve is thus exposed for
|
|
@w{@kbd{g d}} or similar commands to use. With @kbd{g j} you can work
|
|
with any curve in the graph even though curve-related commands only
|
|
affect the last curve in the list.
|
|
|
|
@kindex g p
|
|
@pindex calc-graph-plot
|
|
The @kbd{g p} (@code{calc-graph-plot}) command uses GNUPLOT to draw
|
|
the graph described in the @samp{*Gnuplot Commands*} buffer. Any
|
|
GNUPLOT parameters which are not defined by commands in this buffer
|
|
are reset to their default values. The variables named in the @code{plot}
|
|
command are written to a temporary data file and the variable names
|
|
are then replaced by the file name in the template. The resulting
|
|
plotting commands are fed to the GNUPLOT program. See the documentation
|
|
for the GNUPLOT program for more specific information. All temporary
|
|
files are removed when Emacs or GNUPLOT exits.
|
|
|
|
If you give a formula for ``y'', Calc will remember all the values that
|
|
it calculates for the formula so that later plots can reuse these values.
|
|
Calc throws out these saved values when you change any circumstances
|
|
that may affect the data, such as switching from Degrees to Radians
|
|
mode, or changing the value of a parameter in the formula. You can
|
|
force Calc to recompute the data from scratch by giving a negative
|
|
numeric prefix argument to @kbd{g p}.
|
|
|
|
Calc uses a fairly rough step size when graphing formulas over intervals.
|
|
This is to ensure quick response. You can ``refine'' a plot by giving
|
|
a positive numeric prefix argument to @kbd{g p}. Calc goes through
|
|
the data points it has computed and saved from previous plots of the
|
|
function, and computes and inserts a new data point midway between
|
|
each of the existing points. You can refine a plot any number of times,
|
|
but beware that the amount of calculation involved doubles each time.
|
|
|
|
Calc does not remember computed values for 3D graphs. This means the
|
|
numerix prefix argument, if any, to @kbd{g p} is effectively ignored if
|
|
the current graph is three-dimensional.
|
|
|
|
@kindex g P
|
|
@pindex calc-graph-print
|
|
The @kbd{g P} (@code{calc-graph-print}) command is like @kbd{g p},
|
|
except that it sends the output to a printer instead of to the
|
|
screen. More precisely, @kbd{g p} looks for @samp{set terminal}
|
|
or @samp{set output} commands in the @samp{*Gnuplot Commands*} buffer;
|
|
lacking these it uses the default settings. However, @kbd{g P}
|
|
ignores @samp{set terminal} and @samp{set output} commands and
|
|
uses a different set of default values. All of these values are
|
|
controlled by the @kbd{g D} and @kbd{g O} commands discussed below.
|
|
Provided everything is set up properly, @kbd{g p} will plot to
|
|
the screen unless you have specified otherwise and @kbd{g P} will
|
|
always plot to the printer.
|
|
|
|
@node Graphics Options, Devices, Managing Curves, Graphics
|
|
@section Graphics Options
|
|
|
|
@noindent
|
|
@kindex g g
|
|
@pindex calc-graph-grid
|
|
The @kbd{g g} (@code{calc-graph-grid}) command turns the ``grid''
|
|
on and off. It is off by default; tick marks appear only at the
|
|
edges of the graph. With the grid turned on, dotted lines appear
|
|
across the graph at each tick mark. Note that this command only
|
|
changes the setting in @samp{*Gnuplot Commands*}; to see the effects
|
|
of the change you must give another @kbd{g p} command.
|
|
|
|
@kindex g b
|
|
@pindex calc-graph-border
|
|
The @kbd{g b} (@code{calc-graph-border}) command turns the border
|
|
(the box that surrounds the graph) on and off. It is on by default.
|
|
This command will only work with GNUPLOT 3.0 and later versions.
|
|
|
|
@kindex g k
|
|
@pindex calc-graph-key
|
|
The @kbd{g k} (@code{calc-graph-key}) command turns the ``key''
|
|
on and off. The key is a chart in the corner of the graph that
|
|
shows the correspondence between curves and line styles. It is
|
|
off by default, and is only really useful if you have several
|
|
curves on the same graph.
|
|
|
|
@kindex g N
|
|
@pindex calc-graph-num-points
|
|
The @kbd{g N} (@code{calc-graph-num-points}) command allows you
|
|
to select the number of data points in the graph. This only affects
|
|
curves where neither ``x'' nor ``y'' is specified as a vector.
|
|
Enter a blank line to revert to the default value (initially 15).
|
|
With no prefix argument, this command affects only the current graph.
|
|
With a positive prefix argument this command changes or, if you enter
|
|
a blank line, displays the default number of points used for all
|
|
graphs created by @kbd{g a} that don't specify the resolution explicitly.
|
|
With a negative prefix argument, this command changes or displays
|
|
the default value (initially 5) used for 3D graphs created by @kbd{g A}.
|
|
Note that a 3D setting of 5 means that a total of @expr{5^2 = 25} points
|
|
will be computed for the surface.
|
|
|
|
Data values in the graph of a function are normally computed to a
|
|
precision of five digits, regardless of the current precision at the
|
|
time. This is usually more than adequate, but there are cases where
|
|
it will not be. For example, plotting @expr{1 + x} with @expr{x} in the
|
|
interval @samp{[0 ..@: 1e-6]} will round all the data points down
|
|
to 1.0! Putting the command @samp{set precision @var{n}} in the
|
|
@samp{*Gnuplot Commands*} buffer will cause the data to be computed
|
|
at precision @var{n} instead of 5. Since this is such a rare case,
|
|
there is no keystroke-based command to set the precision.
|
|
|
|
@kindex g h
|
|
@pindex calc-graph-header
|
|
The @kbd{g h} (@code{calc-graph-header}) command sets the title
|
|
for the graph. This will show up centered above the graph.
|
|
The default title is blank (no title).
|
|
|
|
@kindex g n
|
|
@pindex calc-graph-name
|
|
The @kbd{g n} (@code{calc-graph-name}) command sets the title of an
|
|
individual curve. Like the other curve-manipulating commands, it
|
|
affects the most recently added curve, i.e., the last curve on the
|
|
list in the @samp{*Gnuplot Commands*} buffer. To set the title of
|
|
the other curves you must first juggle them to the end of the list
|
|
with @kbd{g j}, or edit the @samp{*Gnuplot Commands*} buffer by hand.
|
|
Curve titles appear in the key; if the key is turned off they are
|
|
not used.
|
|
|
|
@kindex g t
|
|
@kindex g T
|
|
@pindex calc-graph-title-x
|
|
@pindex calc-graph-title-y
|
|
The @kbd{g t} (@code{calc-graph-title-x}) and @kbd{g T}
|
|
(@code{calc-graph-title-y}) commands set the titles on the ``x''
|
|
and ``y'' axes, respectively. These titles appear next to the
|
|
tick marks on the left and bottom edges of the graph, respectively.
|
|
Calc does not have commands to control the tick marks themselves,
|
|
but you can edit them into the @samp{*Gnuplot Commands*} buffer if
|
|
you wish. See the GNUPLOT documentation for details.
|
|
|
|
@kindex g r
|
|
@kindex g R
|
|
@pindex calc-graph-range-x
|
|
@pindex calc-graph-range-y
|
|
The @kbd{g r} (@code{calc-graph-range-x}) and @kbd{g R}
|
|
(@code{calc-graph-range-y}) commands set the range of values on the
|
|
``x'' and ``y'' axes, respectively. You are prompted to enter a
|
|
suitable range. This should be either a pair of numbers of the
|
|
form, @samp{@var{min}:@var{max}}, or a blank line to revert to the
|
|
default behavior of setting the range based on the range of values
|
|
in the data, or @samp{$} to take the range from the top of the stack.
|
|
Ranges on the stack can be represented as either interval forms or
|
|
vectors: @samp{[@var{min} ..@: @var{max}]} or @samp{[@var{min}, @var{max}]}.
|
|
|
|
@kindex g l
|
|
@kindex g L
|
|
@pindex calc-graph-log-x
|
|
@pindex calc-graph-log-y
|
|
The @kbd{g l} (@code{calc-graph-log-x}) and @kbd{g L} (@code{calc-graph-log-y})
|
|
commands allow you to set either or both of the axes of the graph to
|
|
be logarithmic instead of linear.
|
|
|
|
@kindex g C-l
|
|
@kindex g C-r
|
|
@kindex g C-t
|
|
@pindex calc-graph-log-z
|
|
@pindex calc-graph-range-z
|
|
@pindex calc-graph-title-z
|
|
For 3D plots, @kbd{g C-t}, @kbd{g C-r}, and @kbd{g C-l} (those are
|
|
letters with the Control key held down) are the corresponding commands
|
|
for the ``z'' axis.
|
|
|
|
@kindex g z
|
|
@kindex g Z
|
|
@pindex calc-graph-zero-x
|
|
@pindex calc-graph-zero-y
|
|
The @kbd{g z} (@code{calc-graph-zero-x}) and @kbd{g Z}
|
|
(@code{calc-graph-zero-y}) commands control whether a dotted line is
|
|
drawn to indicate the ``x'' and/or ``y'' zero axes. (These are the same
|
|
dotted lines that would be drawn there anyway if you used @kbd{g g} to
|
|
turn the ``grid'' feature on.) Zero-axis lines are on by default, and
|
|
may be turned off only in GNUPLOT 3.0 and later versions. They are
|
|
not available for 3D plots.
|
|
|
|
@kindex g s
|
|
@pindex calc-graph-line-style
|
|
The @kbd{g s} (@code{calc-graph-line-style}) command turns the connecting
|
|
lines on or off for the most recently added curve, and optionally selects
|
|
the style of lines to be used for that curve. Plain @kbd{g s} simply
|
|
toggles the lines on and off. With a numeric prefix argument, @kbd{g s}
|
|
turns lines on and sets a particular line style. Line style numbers
|
|
start at one and their meanings vary depending on the output device.
|
|
GNUPLOT guarantees that there will be at least six different line styles
|
|
available for any device.
|
|
|
|
@kindex g S
|
|
@pindex calc-graph-point-style
|
|
The @kbd{g S} (@code{calc-graph-point-style}) command similarly turns
|
|
the symbols at the data points on or off, or sets the point style.
|
|
If you turn both lines and points off, the data points will show as
|
|
tiny dots.
|
|
|
|
@cindex @code{LineStyles} variable
|
|
@cindex @code{PointStyles} variable
|
|
@vindex LineStyles
|
|
@vindex PointStyles
|
|
Another way to specify curve styles is with the @code{LineStyles} and
|
|
@code{PointStyles} variables. These variables initially have no stored
|
|
values, but if you store a vector of integers in one of these variables,
|
|
the @kbd{g a} and @kbd{g f} commands will use those style numbers
|
|
instead of the defaults for new curves that are added to the graph.
|
|
An entry should be a positive integer for a specific style, or 0 to let
|
|
the style be chosen automatically, or @mathit{-1} to turn off lines or points
|
|
altogether. If there are more curves than elements in the vector, the
|
|
last few curves will continue to have the default styles. Of course,
|
|
you can later use @kbd{g s} and @kbd{g S} to change any of these styles.
|
|
|
|
For example, @kbd{'[2 -1 3] @key{RET} s t LineStyles} causes the first curve
|
|
to have lines in style number 2, the second curve to have no connecting
|
|
lines, and the third curve to have lines in style 3. Point styles will
|
|
still be assigned automatically, but you could store another vector in
|
|
@code{PointStyles} to define them, too.
|
|
|
|
@node Devices, , Graphics Options, Graphics
|
|
@section Graphical Devices
|
|
|
|
@noindent
|
|
@kindex g D
|
|
@pindex calc-graph-device
|
|
The @kbd{g D} (@code{calc-graph-device}) command sets the device name
|
|
(or ``terminal name'' in GNUPLOT lingo) to be used by @kbd{g p} commands
|
|
on this graph. It does not affect the permanent default device name.
|
|
If you enter a blank name, the device name reverts to the default.
|
|
Enter @samp{?} to see a list of supported devices.
|
|
|
|
With a positive numeric prefix argument, @kbd{g D} instead sets
|
|
the default device name, used by all plots in the future which do
|
|
not override it with a plain @kbd{g D} command. If you enter a
|
|
blank line this command shows you the current default. The special
|
|
name @code{default} signifies that Calc should choose @code{x11} if
|
|
the X window system is in use (as indicated by the presence of a
|
|
@code{DISPLAY} environment variable), or otherwise @code{dumb} under
|
|
GNUPLOT 3.0 and later, or @code{postscript} under GNUPLOT 2.0.
|
|
This is the initial default value.
|
|
|
|
The @code{dumb} device is an interface to ``dumb terminals,'' i.e.,
|
|
terminals with no special graphics facilities. It writes a crude
|
|
picture of the graph composed of characters like @code{-} and @code{|}
|
|
to a buffer called @samp{*Gnuplot Trail*}, which Calc then displays.
|
|
The graph is made the same size as the Emacs screen, which on most
|
|
dumb terminals will be
|
|
@texline @math{80\times24}
|
|
@infoline 80x24
|
|
characters. The graph is displayed in
|
|
an Emacs ``recursive edit''; type @kbd{q} or @kbd{C-c C-c} to exit
|
|
the recursive edit and return to Calc. Note that the @code{dumb}
|
|
device is present only in GNUPLOT 3.0 and later versions.
|
|
|
|
The word @code{dumb} may be followed by two numbers separated by
|
|
spaces. These are the desired width and height of the graph in
|
|
characters. Also, the device name @code{big} is like @code{dumb}
|
|
but creates a graph four times the width and height of the Emacs
|
|
screen. You will then have to scroll around to view the entire
|
|
graph. In the @samp{*Gnuplot Trail*} buffer, @key{SPC}, @key{DEL},
|
|
@kbd{<}, and @kbd{>} are defined to scroll by one screenful in each
|
|
of the four directions.
|
|
|
|
With a negative numeric prefix argument, @kbd{g D} sets or displays
|
|
the device name used by @kbd{g P} (@code{calc-graph-print}). This
|
|
is initially @code{postscript}. If you don't have a PostScript
|
|
printer, you may decide once again to use @code{dumb} to create a
|
|
plot on any text-only printer.
|
|
|
|
@kindex g O
|
|
@pindex calc-graph-output
|
|
The @kbd{g O} (@code{calc-graph-output}) command sets the name of
|
|
the output file used by GNUPLOT. For some devices, notably @code{x11},
|
|
there is no output file and this information is not used. Many other
|
|
``devices'' are really file formats like @code{postscript}; in these
|
|
cases the output in the desired format goes into the file you name
|
|
with @kbd{g O}. Type @kbd{g O stdout @key{RET}} to set GNUPLOT to write
|
|
to its standard output stream, i.e., to @samp{*Gnuplot Trail*}.
|
|
This is the default setting.
|
|
|
|
Another special output name is @code{tty}, which means that GNUPLOT
|
|
is going to write graphics commands directly to its standard output,
|
|
which you wish Emacs to pass through to your terminal. Tektronix
|
|
graphics terminals, among other devices, operate this way. Calc does
|
|
this by telling GNUPLOT to write to a temporary file, then running a
|
|
sub-shell executing the command @samp{cat tempfile >/dev/tty}. On
|
|
typical Unix systems, this will copy the temporary file directly to
|
|
the terminal, bypassing Emacs entirely. You will have to type @kbd{C-l}
|
|
to Emacs afterwards to refresh the screen.
|
|
|
|
Once again, @kbd{g O} with a positive or negative prefix argument
|
|
sets the default or printer output file names, respectively. In each
|
|
case you can specify @code{auto}, which causes Calc to invent a temporary
|
|
file name for each @kbd{g p} (or @kbd{g P}) command. This temporary file
|
|
will be deleted once it has been displayed or printed. If the output file
|
|
name is not @code{auto}, the file is not automatically deleted.
|
|
|
|
The default and printer devices and output files can be saved
|
|
permanently by the @kbd{m m} (@code{calc-save-modes}) command. The
|
|
default number of data points (see @kbd{g N}) and the X geometry
|
|
(see @kbd{g X}) are also saved. Other graph information is @emph{not}
|
|
saved; you can save a graph's configuration simply by saving the contents
|
|
of the @samp{*Gnuplot Commands*} buffer.
|
|
|
|
@vindex calc-gnuplot-plot-command
|
|
@vindex calc-gnuplot-default-device
|
|
@vindex calc-gnuplot-default-output
|
|
@vindex calc-gnuplot-print-command
|
|
@vindex calc-gnuplot-print-device
|
|
@vindex calc-gnuplot-print-output
|
|
You may wish to configure the default and
|
|
printer devices and output files for the whole system. The relevant
|
|
Lisp variables are @code{calc-gnuplot-default-device} and @code{-output},
|
|
and @code{calc-gnuplot-print-device} and @code{-output}. The output
|
|
file names must be either strings as described above, or Lisp
|
|
expressions which are evaluated on the fly to get the output file names.
|
|
|
|
Other important Lisp variables are @code{calc-gnuplot-plot-command} and
|
|
@code{calc-gnuplot-print-command}, which give the system commands to
|
|
display or print the output of GNUPLOT, respectively. These may be
|
|
@code{nil} if no command is necessary, or strings which can include
|
|
@samp{%s} to signify the name of the file to be displayed or printed.
|
|
Or, these variables may contain Lisp expressions which are evaluated
|
|
to display or print the output. These variables are customizable
|
|
(@pxref{Customizing Calc}).
|
|
|
|
@kindex g x
|
|
@pindex calc-graph-display
|
|
The @kbd{g x} (@code{calc-graph-display}) command lets you specify
|
|
on which X window system display your graphs should be drawn. Enter
|
|
a blank line to see the current display name. This command has no
|
|
effect unless the current device is @code{x11}.
|
|
|
|
@kindex g X
|
|
@pindex calc-graph-geometry
|
|
The @kbd{g X} (@code{calc-graph-geometry}) command is a similar
|
|
command for specifying the position and size of the X window.
|
|
The normal value is @code{default}, which generally means your
|
|
window manager will let you place the window interactively.
|
|
Entering @samp{800x500+0+0} would create an 800-by-500 pixel
|
|
window in the upper-left corner of the screen.
|
|
|
|
The buffer called @samp{*Gnuplot Trail*} holds a transcript of the
|
|
session with GNUPLOT. This shows the commands Calc has ``typed'' to
|
|
GNUPLOT and the responses it has received. Calc tries to notice when an
|
|
error message has appeared here and display the buffer for you when
|
|
this happens. You can check this buffer yourself if you suspect
|
|
something has gone wrong.
|
|
|
|
@kindex g C
|
|
@pindex calc-graph-command
|
|
The @kbd{g C} (@code{calc-graph-command}) command prompts you to
|
|
enter any line of text, then simply sends that line to the current
|
|
GNUPLOT process. The @samp{*Gnuplot Trail*} buffer looks deceptively
|
|
like a Shell buffer but you can't type commands in it yourself.
|
|
Instead, you must use @kbd{g C} for this purpose.
|
|
|
|
@kindex g v
|
|
@kindex g V
|
|
@pindex calc-graph-view-commands
|
|
@pindex calc-graph-view-trail
|
|
The @kbd{g v} (@code{calc-graph-view-commands}) and @kbd{g V}
|
|
(@code{calc-graph-view-trail}) commands display the @samp{*Gnuplot Commands*}
|
|
and @samp{*Gnuplot Trail*} buffers, respectively, in another window.
|
|
This happens automatically when Calc thinks there is something you
|
|
will want to see in either of these buffers. If you type @kbd{g v}
|
|
or @kbd{g V} when the relevant buffer is already displayed, the
|
|
buffer is hidden again.
|
|
|
|
One reason to use @kbd{g v} is to add your own commands to the
|
|
@samp{*Gnuplot Commands*} buffer. Press @kbd{g v}, then use
|
|
@kbd{C-x o} to switch into that window. For example, GNUPLOT has
|
|
@samp{set label} and @samp{set arrow} commands that allow you to
|
|
annotate your plots. Since Calc doesn't understand these commands,
|
|
you have to add them to the @samp{*Gnuplot Commands*} buffer
|
|
yourself, then use @w{@kbd{g p}} to replot using these new commands. Note
|
|
that your commands must appear @emph{before} the @code{plot} command.
|
|
To get help on any GNUPLOT feature, type, e.g., @kbd{g C help set label}.
|
|
You may have to type @kbd{g C @key{RET}} a few times to clear the
|
|
``press return for more'' or ``subtopic of @dots{}'' requests.
|
|
Note that Calc always sends commands (like @samp{set nolabel}) to
|
|
reset all plotting parameters to the defaults before each plot, so
|
|
to delete a label all you need to do is delete the @samp{set label}
|
|
line you added (or comment it out with @samp{#}) and then replot
|
|
with @kbd{g p}.
|
|
|
|
@kindex g q
|
|
@pindex calc-graph-quit
|
|
You can use @kbd{g q} (@code{calc-graph-quit}) to kill the GNUPLOT
|
|
process that is running. The next graphing command you give will
|
|
start a fresh GNUPLOT process. The word @samp{Graph} appears in
|
|
the Calc window's mode line whenever a GNUPLOT process is currently
|
|
running. The GNUPLOT process is automatically killed when you
|
|
exit Emacs if you haven't killed it manually by then.
|
|
|
|
@kindex g K
|
|
@pindex calc-graph-kill
|
|
The @kbd{g K} (@code{calc-graph-kill}) command is like @kbd{g q}
|
|
except that it also views the @samp{*Gnuplot Trail*} buffer so that
|
|
you can see the process being killed. This is better if you are
|
|
killing GNUPLOT because you think it has gotten stuck.
|
|
|
|
@node Kill and Yank, Keypad Mode, Graphics, Top
|
|
@chapter Kill and Yank Functions
|
|
|
|
@noindent
|
|
The commands in this chapter move information between the Calculator and
|
|
other Emacs editing buffers.
|
|
|
|
In many cases Embedded mode is an easier and more natural way to
|
|
work with Calc from a regular editing buffer. @xref{Embedded Mode}.
|
|
|
|
@menu
|
|
* Killing From Stack::
|
|
* Yanking Into Stack::
|
|
* Grabbing From Buffers::
|
|
* Yanking Into Buffers::
|
|
* X Cut and Paste::
|
|
@end menu
|
|
|
|
@node Killing From Stack, Yanking Into Stack, Kill and Yank, Kill and Yank
|
|
@section Killing from the Stack
|
|
|
|
@noindent
|
|
@kindex C-k
|
|
@pindex calc-kill
|
|
@kindex M-k
|
|
@pindex calc-copy-as-kill
|
|
@kindex C-w
|
|
@pindex calc-kill-region
|
|
@kindex M-w
|
|
@pindex calc-copy-region-as-kill
|
|
@cindex Kill ring
|
|
@dfn{Kill} commands are Emacs commands that insert text into the
|
|
``kill ring,'' from which it can later be ``yanked'' by a @kbd{C-y}
|
|
command. Three common kill commands in normal Emacs are @kbd{C-k}, which
|
|
kills one line, @kbd{C-w}, which kills the region between mark and point,
|
|
and @kbd{M-w}, which puts the region into the kill ring without actually
|
|
deleting it. All of these commands work in the Calculator, too. Also,
|
|
@kbd{M-k} has been provided to complete the set; it puts the current line
|
|
into the kill ring without deleting anything.
|
|
|
|
The kill commands are unusual in that they pay attention to the location
|
|
of the cursor in the Calculator buffer. If the cursor is on or below the
|
|
bottom line, the kill commands operate on the top of the stack. Otherwise,
|
|
they operate on whatever stack element the cursor is on. Calc's kill
|
|
commands always operate on whole stack entries. (They act the same as their
|
|
standard Emacs cousins except they ``round up'' the specified region to
|
|
encompass full lines.) The text is copied into the kill ring exactly as
|
|
it appears on the screen, including line numbers if they are enabled.
|
|
|
|
A numeric prefix argument to @kbd{C-k} or @kbd{M-k} affects the number
|
|
of lines killed. A positive argument kills the current line and @expr{n-1}
|
|
lines below it. A negative argument kills the @expr{-n} lines above the
|
|
current line. Again this mirrors the behavior of the standard Emacs
|
|
@kbd{C-k} command. Although a whole line is always deleted, @kbd{C-k}
|
|
with no argument copies only the number itself into the kill ring, whereas
|
|
@kbd{C-k} with a prefix argument of 1 copies the number with its trailing
|
|
newline.
|
|
|
|
@node Yanking Into Stack, Grabbing From Buffers, Killing From Stack, Kill and Yank
|
|
@section Yanking into the Stack
|
|
|
|
@noindent
|
|
@kindex C-y
|
|
@pindex calc-yank
|
|
The @kbd{C-y} command yanks the most recently killed text back into the
|
|
Calculator. It pushes this value onto the top of the stack regardless of
|
|
the cursor position. In general it re-parses the killed text as a number
|
|
or formula (or a list of these separated by commas or newlines). However if
|
|
the thing being yanked is something that was just killed from the Calculator
|
|
itself, its full internal structure is yanked. For example, if you have
|
|
set the floating-point display mode to show only four significant digits,
|
|
then killing and re-yanking 3.14159 (which displays as 3.142) will yank the
|
|
full 3.14159, even though yanking it into any other buffer would yank the
|
|
number in its displayed form, 3.142. (Since the default display modes
|
|
show all objects to their full precision, this feature normally makes no
|
|
difference.)
|
|
|
|
@node Grabbing From Buffers, Yanking Into Buffers, Yanking Into Stack, Kill and Yank
|
|
@section Grabbing from Other Buffers
|
|
|
|
@noindent
|
|
@kindex C-x * g
|
|
@pindex calc-grab-region
|
|
The @kbd{C-x * g} (@code{calc-grab-region}) command takes the text between
|
|
point and mark in the current buffer and attempts to parse it as a
|
|
vector of values. Basically, it wraps the text in vector brackets
|
|
@samp{[ ]} unless the text already is enclosed in vector brackets,
|
|
then reads the text as if it were an algebraic entry. The contents
|
|
of the vector may be numbers, formulas, or any other Calc objects.
|
|
If the @kbd{C-x * g} command works successfully, it does an automatic
|
|
@kbd{C-x * c} to enter the Calculator buffer.
|
|
|
|
A numeric prefix argument grabs the specified number of lines around
|
|
point, ignoring the mark. A positive prefix grabs from point to the
|
|
@expr{n}th following newline (so that @kbd{M-1 C-x * g} grabs from point
|
|
to the end of the current line); a negative prefix grabs from point
|
|
back to the @expr{n+1}st preceding newline. In these cases the text
|
|
that is grabbed is exactly the same as the text that @kbd{C-k} would
|
|
delete given that prefix argument.
|
|
|
|
A prefix of zero grabs the current line; point may be anywhere on the
|
|
line.
|
|
|
|
A plain @kbd{C-u} prefix interprets the region between point and mark
|
|
as a single number or formula rather than a vector. For example,
|
|
@kbd{C-x * g} on the text @samp{2 a b} produces the vector of three
|
|
values @samp{[2, a, b]}, but @kbd{C-u C-x * g} on the same region
|
|
reads a formula which is a product of three things: @samp{2 a b}.
|
|
(The text @samp{a + b}, on the other hand, will be grabbed as a
|
|
vector of one element by plain @kbd{C-x * g} because the interpretation
|
|
@samp{[a, +, b]} would be a syntax error.)
|
|
|
|
If a different language has been specified (@pxref{Language Modes}),
|
|
the grabbed text will be interpreted according to that language.
|
|
|
|
@kindex C-x * r
|
|
@pindex calc-grab-rectangle
|
|
The @kbd{C-x * r} (@code{calc-grab-rectangle}) command takes the text between
|
|
point and mark and attempts to parse it as a matrix. If point and mark
|
|
are both in the leftmost column, the lines in between are parsed in their
|
|
entirety. Otherwise, point and mark define the corners of a rectangle
|
|
whose contents are parsed.
|
|
|
|
Each line of the grabbed area becomes a row of the matrix. The result
|
|
will actually be a vector of vectors, which Calc will treat as a matrix
|
|
only if every row contains the same number of values.
|
|
|
|
If a line contains a portion surrounded by square brackets (or curly
|
|
braces), that portion is interpreted as a vector which becomes a row
|
|
of the matrix. Any text surrounding the bracketed portion on the line
|
|
is ignored.
|
|
|
|
Otherwise, the entire line is interpreted as a row vector as if it
|
|
were surrounded by square brackets. Leading line numbers (in the
|
|
format used in the Calc stack buffer) are ignored. If you wish to
|
|
force this interpretation (even if the line contains bracketed
|
|
portions), give a negative numeric prefix argument to the
|
|
@kbd{C-x * r} command.
|
|
|
|
If you give a numeric prefix argument of zero or plain @kbd{C-u}, each
|
|
line is instead interpreted as a single formula which is converted into
|
|
a one-element vector. Thus the result of @kbd{C-u C-x * r} will be a
|
|
one-column matrix. For example, suppose one line of the data is the
|
|
expression @samp{2 a}. A plain @w{@kbd{C-x * r}} will interpret this as
|
|
@samp{[2 a]}, which in turn is read as a two-element vector that forms
|
|
one row of the matrix. But a @kbd{C-u C-x * r} will interpret this row
|
|
as @samp{[2*a]}.
|
|
|
|
If you give a positive numeric prefix argument @var{n}, then each line
|
|
will be split up into columns of width @var{n}; each column is parsed
|
|
separately as a matrix element. If a line contained
|
|
@w{@samp{2 +/- 3 4 +/- 5}}, then grabbing with a prefix argument of 8
|
|
would correctly split the line into two error forms.
|
|
|
|
@xref{Matrix Functions}, to see how to pull the matrix apart into its
|
|
constituent rows and columns. (If it is a
|
|
@texline @math{1\times1}
|
|
@infoline 1x1
|
|
matrix, just hit @kbd{v u} (@code{calc-unpack}) twice.)
|
|
|
|
@kindex C-x * :
|
|
@kindex C-x * _
|
|
@pindex calc-grab-sum-across
|
|
@pindex calc-grab-sum-down
|
|
@cindex Summing rows and columns of data
|
|
The @kbd{C-x * :} (@code{calc-grab-sum-down}) command is a handy way to
|
|
grab a rectangle of data and sum its columns. It is equivalent to
|
|
typing @kbd{C-x * r}, followed by @kbd{V R : +} (the vector reduction
|
|
command that sums the columns of a matrix; @pxref{Reducing}). The
|
|
result of the command will be a vector of numbers, one for each column
|
|
in the input data. The @kbd{C-x * _} (@code{calc-grab-sum-across}) command
|
|
similarly grabs a rectangle and sums its rows by executing @w{@kbd{V R _ +}}.
|
|
|
|
As well as being more convenient, @kbd{C-x * :} and @kbd{C-x * _} are also
|
|
much faster because they don't actually place the grabbed vector on
|
|
the stack. In a @kbd{C-x * r V R : +} sequence, formatting the vector
|
|
for display on the stack takes a large fraction of the total time
|
|
(unless you have planned ahead and used @kbd{v .} and @kbd{t .} modes).
|
|
|
|
For example, suppose we have a column of numbers in a file which we
|
|
wish to sum. Go to one corner of the column and press @kbd{C-@@} to
|
|
set the mark; go to the other corner and type @kbd{C-x * :}. Since there
|
|
is only one column, the result will be a vector of one number, the sum.
|
|
(You can type @kbd{v u} to unpack this vector into a plain number if
|
|
you want to do further arithmetic with it.)
|
|
|
|
To compute the product of the column of numbers, we would have to do
|
|
it ``by hand'' since there's no special grab-and-multiply command.
|
|
Use @kbd{C-x * r} to grab the column of numbers into the calculator in
|
|
the form of a column matrix. The statistics command @kbd{u *} is a
|
|
handy way to find the product of a vector or matrix of numbers.
|
|
@xref{Statistical Operations}. Another approach would be to use
|
|
an explicit column reduction command, @kbd{V R : *}.
|
|
|
|
@node Yanking Into Buffers, X Cut and Paste, Grabbing From Buffers, Kill and Yank
|
|
@section Yanking into Other Buffers
|
|
|
|
@noindent
|
|
@kindex y
|
|
@pindex calc-copy-to-buffer
|
|
The plain @kbd{y} (@code{calc-copy-to-buffer}) command inserts the number
|
|
at the top of the stack into the most recently used normal editing buffer.
|
|
(More specifically, this is the most recently used buffer which is displayed
|
|
in a window and whose name does not begin with @samp{*}. If there is no
|
|
such buffer, this is the most recently used buffer except for Calculator
|
|
and Calc Trail buffers.) The number is inserted exactly as it appears and
|
|
without a newline. (If line-numbering is enabled, the line number is
|
|
normally not included.) The number is @emph{not} removed from the stack.
|
|
|
|
With a prefix argument, @kbd{y} inserts several numbers, one per line.
|
|
A positive argument inserts the specified number of values from the top
|
|
of the stack. A negative argument inserts the @expr{n}th value from the
|
|
top of the stack. An argument of zero inserts the entire stack. Note
|
|
that @kbd{y} with an argument of 1 is slightly different from @kbd{y}
|
|
with no argument; the former always copies full lines, whereas the
|
|
latter strips off the trailing newline.
|
|
|
|
With a lone @kbd{C-u} as a prefix argument, @kbd{y} @emph{replaces} the
|
|
region in the other buffer with the yanked text, then quits the
|
|
Calculator, leaving you in that buffer. A typical use would be to use
|
|
@kbd{C-x * g} to read a region of data into the Calculator, operate on the
|
|
data to produce a new matrix, then type @kbd{C-u y} to replace the
|
|
original data with the new data. One might wish to alter the matrix
|
|
display style (@pxref{Vector and Matrix Formats}) or change the current
|
|
display language (@pxref{Language Modes}) before doing this. Also, note
|
|
that this command replaces a linear region of text (as grabbed by
|
|
@kbd{C-x * g}), not a rectangle (as grabbed by @kbd{C-x * r}).
|
|
|
|
If the editing buffer is in overwrite (as opposed to insert) mode,
|
|
and the @kbd{C-u} prefix was not used, then the yanked number will
|
|
overwrite the characters following point rather than being inserted
|
|
before those characters. The usual conventions of overwrite mode
|
|
are observed; for example, characters will be inserted at the end of
|
|
a line rather than overflowing onto the next line. Yanking a multi-line
|
|
object such as a matrix in overwrite mode overwrites the next @var{n}
|
|
lines in the buffer, lengthening or shortening each line as necessary.
|
|
Finally, if the thing being yanked is a simple integer or floating-point
|
|
number (like @samp{-1.2345e-3}) and the characters following point also
|
|
make up such a number, then Calc will replace that number with the new
|
|
number, lengthening or shortening as necessary. The concept of
|
|
``overwrite mode'' has thus been generalized from overwriting characters
|
|
to overwriting one complete number with another.
|
|
|
|
@kindex C-x * y
|
|
The @kbd{C-x * y} key sequence is equivalent to @kbd{y} except that
|
|
it can be typed anywhere, not just in Calc. This provides an easy
|
|
way to guarantee that Calc knows which editing buffer you want to use!
|
|
|
|
@node X Cut and Paste, , Yanking Into Buffers, Kill and Yank
|
|
@section X Cut and Paste
|
|
|
|
@noindent
|
|
If you are using Emacs with the X window system, there is an easier
|
|
way to move small amounts of data into and out of the calculator:
|
|
Use the mouse-oriented cut and paste facilities of X.
|
|
|
|
The default bindings for a three-button mouse cause the left button
|
|
to move the Emacs cursor to the given place, the right button to
|
|
select the text between the cursor and the clicked location, and
|
|
the middle button to yank the selection into the buffer at the
|
|
clicked location. So, if you have a Calc window and an editing
|
|
window on your Emacs screen, you can use left-click/right-click
|
|
to select a number, vector, or formula from one window, then
|
|
middle-click to paste that value into the other window. When you
|
|
paste text into the Calc window, Calc interprets it as an algebraic
|
|
entry. It doesn't matter where you click in the Calc window; the
|
|
new value is always pushed onto the top of the stack.
|
|
|
|
The @code{xterm} program that is typically used for general-purpose
|
|
shell windows in X interprets the mouse buttons in the same way.
|
|
So you can use the mouse to move data between Calc and any other
|
|
Unix program. One nice feature of @code{xterm} is that a double
|
|
left-click selects one word, and a triple left-click selects a
|
|
whole line. So you can usually transfer a single number into Calc
|
|
just by double-clicking on it in the shell, then middle-clicking
|
|
in the Calc window.
|
|
|
|
@node Keypad Mode, Embedded Mode, Kill and Yank, Top
|
|
@chapter Keypad Mode
|
|
|
|
@noindent
|
|
@kindex C-x * k
|
|
@pindex calc-keypad
|
|
The @kbd{C-x * k} (@code{calc-keypad}) command starts the Calculator
|
|
and displays a picture of a calculator-style keypad. If you are using
|
|
the X window system, you can click on any of the ``keys'' in the
|
|
keypad using the left mouse button to operate the calculator.
|
|
The original window remains the selected window; in Keypad mode
|
|
you can type in your file while simultaneously performing
|
|
calculations with the mouse.
|
|
|
|
@pindex full-calc-keypad
|
|
If you have used @kbd{C-x * b} first, @kbd{C-x * k} instead invokes
|
|
the @code{full-calc-keypad} command, which takes over the whole
|
|
Emacs screen and displays the keypad, the Calc stack, and the Calc
|
|
trail all at once. This mode would normally be used when running
|
|
Calc standalone (@pxref{Standalone Operation}).
|
|
|
|
If you aren't using the X window system, you must switch into
|
|
the @samp{*Calc Keypad*} window, place the cursor on the desired
|
|
``key,'' and type @key{SPC} or @key{RET}. If you think this
|
|
is easier than using Calc normally, go right ahead.
|
|
|
|
Calc commands are more or less the same in Keypad mode. Certain
|
|
keypad keys differ slightly from the corresponding normal Calc
|
|
keystrokes; all such deviations are described below.
|
|
|
|
Keypad mode includes many more commands than will fit on the keypad
|
|
at once. Click the right mouse button [@code{calc-keypad-menu}]
|
|
to switch to the next menu. The bottom five rows of the keypad
|
|
stay the same; the top three rows change to a new set of commands.
|
|
To return to earlier menus, click the middle mouse button
|
|
[@code{calc-keypad-menu-back}] or simply advance through the menus
|
|
until you wrap around. Typing @key{TAB} inside the keypad window
|
|
is equivalent to clicking the right mouse button there.
|
|
|
|
You can always click the @key{EXEC} button and type any normal
|
|
Calc key sequence. This is equivalent to switching into the
|
|
Calc buffer, typing the keys, then switching back to your
|
|
original buffer.
|
|
|
|
@menu
|
|
* Keypad Main Menu::
|
|
* Keypad Functions Menu::
|
|
* Keypad Binary Menu::
|
|
* Keypad Vectors Menu::
|
|
* Keypad Modes Menu::
|
|
@end menu
|
|
|
|
@node Keypad Main Menu, Keypad Functions Menu, Keypad Mode, Keypad Mode
|
|
@section Main Menu
|
|
|
|
@smallexample
|
|
@group
|
|
|----+-----Calc 2.1------+----1
|
|
|FLR |CEIL|RND |TRNC|CLN2|FLT |
|
|
|----+----+----+----+----+----|
|
|
| LN |EXP | |ABS |IDIV|MOD |
|
|
|----+----+----+----+----+----|
|
|
|SIN |COS |TAN |SQRT|y^x |1/x |
|
|
|----+----+----+----+----+----|
|
|
| ENTER |+/- |EEX |UNDO| <- |
|
|
|-----+---+-+--+--+-+---++----|
|
|
| INV | 7 | 8 | 9 | / |
|
|
|-----+-----+-----+-----+-----|
|
|
| HYP | 4 | 5 | 6 | * |
|
|
|-----+-----+-----+-----+-----|
|
|
|EXEC | 1 | 2 | 3 | - |
|
|
|-----+-----+-----+-----+-----|
|
|
| OFF | 0 | . | PI | + |
|
|
|-----+-----+-----+-----+-----+
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This is the menu that appears the first time you start Keypad mode.
|
|
It will show up in a vertical window on the right side of your screen.
|
|
Above this menu is the traditional Calc stack display. On a 24-line
|
|
screen you will be able to see the top three stack entries.
|
|
|
|
The ten digit keys, decimal point, and @key{EEX} key are used for
|
|
entering numbers in the obvious way. @key{EEX} begins entry of an
|
|
exponent in scientific notation. Just as with regular Calc, the
|
|
number is pushed onto the stack as soon as you press @key{ENTER}
|
|
or any other function key.
|
|
|
|
The @key{+/-} key corresponds to normal Calc's @kbd{n} key. During
|
|
numeric entry it changes the sign of the number or of the exponent.
|
|
At other times it changes the sign of the number on the top of the
|
|
stack.
|
|
|
|
The @key{INV} and @key{HYP} keys modify other keys. As well as
|
|
having the effects described elsewhere in this manual, Keypad mode
|
|
defines several other ``inverse'' operations. These are described
|
|
below and in the following sections.
|
|
|
|
The @key{ENTER} key finishes the current numeric entry, or otherwise
|
|
duplicates the top entry on the stack.
|
|
|
|
The @key{UNDO} key undoes the most recent Calc operation.
|
|
@kbd{INV UNDO} is the ``redo'' command, and @kbd{HYP UNDO} is
|
|
``last arguments'' (@kbd{M-@key{RET}}).
|
|
|
|
The @key{<-} key acts as a ``backspace'' during numeric entry.
|
|
At other times it removes the top stack entry. @kbd{INV <-}
|
|
clears the entire stack. @kbd{HYP <-} takes an integer from
|
|
the stack, then removes that many additional stack elements.
|
|
|
|
The @key{EXEC} key prompts you to enter any keystroke sequence
|
|
that would normally work in Calc mode. This can include a
|
|
numeric prefix if you wish. It is also possible simply to
|
|
switch into the Calc window and type commands in it; there is
|
|
nothing ``magic'' about this window when Keypad mode is active.
|
|
|
|
The other keys in this display perform their obvious calculator
|
|
functions. @key{CLN2} rounds the top-of-stack by temporarily
|
|
reducing the precision by 2 digits. @key{FLT} converts an
|
|
integer or fraction on the top of the stack to floating-point.
|
|
|
|
The @key{INV} and @key{HYP} keys combined with several of these keys
|
|
give you access to some common functions even if the appropriate menu
|
|
is not displayed. Obviously you don't need to learn these keys
|
|
unless you find yourself wasting time switching among the menus.
|
|
|
|
@table @kbd
|
|
@item INV +/-
|
|
is the same as @key{1/x}.
|
|
@item INV +
|
|
is the same as @key{SQRT}.
|
|
@item INV -
|
|
is the same as @key{CONJ}.
|
|
@item INV *
|
|
is the same as @key{y^x}.
|
|
@item INV /
|
|
is the same as @key{INV y^x} (the @expr{x}th root of @expr{y}).
|
|
@item HYP/INV 1
|
|
are the same as @key{SIN} / @kbd{INV SIN}.
|
|
@item HYP/INV 2
|
|
are the same as @key{COS} / @kbd{INV COS}.
|
|
@item HYP/INV 3
|
|
are the same as @key{TAN} / @kbd{INV TAN}.
|
|
@item INV/HYP 4
|
|
are the same as @key{LN} / @kbd{HYP LN}.
|
|
@item INV/HYP 5
|
|
are the same as @key{EXP} / @kbd{HYP EXP}.
|
|
@item INV 6
|
|
is the same as @key{ABS}.
|
|
@item INV 7
|
|
is the same as @key{RND} (@code{calc-round}).
|
|
@item INV 8
|
|
is the same as @key{CLN2}.
|
|
@item INV 9
|
|
is the same as @key{FLT} (@code{calc-float}).
|
|
@item INV 0
|
|
is the same as @key{IMAG}.
|
|
@item INV .
|
|
is the same as @key{PREC}.
|
|
@item INV ENTER
|
|
is the same as @key{SWAP}.
|
|
@item HYP ENTER
|
|
is the same as @key{RLL3}.
|
|
@item INV HYP ENTER
|
|
is the same as @key{OVER}.
|
|
@item HYP +/-
|
|
packs the top two stack entries as an error form.
|
|
@item HYP EEX
|
|
packs the top two stack entries as a modulo form.
|
|
@item INV EEX
|
|
creates an interval form; this removes an integer which is one
|
|
of 0 @samp{[]}, 1 @samp{[)}, 2 @samp{(]} or 3 @samp{()}, followed
|
|
by the two limits of the interval.
|
|
@end table
|
|
|
|
The @kbd{OFF} key turns Calc off; typing @kbd{C-x * k} or @kbd{C-x * *}
|
|
again has the same effect. This is analogous to typing @kbd{q} or
|
|
hitting @kbd{C-x * c} again in the normal calculator. If Calc is
|
|
running standalone (the @code{full-calc-keypad} command appeared in the
|
|
command line that started Emacs), then @kbd{OFF} is replaced with
|
|
@kbd{EXIT}; clicking on this actually exits Emacs itself.
|
|
|
|
@node Keypad Functions Menu, Keypad Binary Menu, Keypad Main Menu, Keypad Mode
|
|
@section Functions Menu
|
|
|
|
@smallexample
|
|
@group
|
|
|----+----+----+----+----+----2
|
|
|IGAM|BETA|IBET|ERF |BESJ|BESY|
|
|
|----+----+----+----+----+----|
|
|
|IMAG|CONJ| RE |ATN2|RAND|RAGN|
|
|
|----+----+----+----+----+----|
|
|
|GCD |FACT|DFCT|BNOM|PERM|NXTP|
|
|
|----+----+----+----+----+----|
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
This menu provides various operations from the @kbd{f} and @kbd{k}
|
|
prefix keys.
|
|
|
|
@key{IMAG} multiplies the number on the stack by the imaginary
|
|
number @expr{i = (0, 1)}.
|
|
|
|
@key{RE} extracts the real part a complex number. @kbd{INV RE}
|
|
extracts the imaginary part.
|
|
|
|
@key{RAND} takes a number from the top of the stack and computes
|
|
a random number greater than or equal to zero but less than that
|
|
number. (@xref{Random Numbers}.) @key{RAGN} is the ``random
|
|
again'' command; it computes another random number using the
|
|
same limit as last time.
|
|
|
|
@key{INV GCD} computes the LCM (least common multiple) function.
|
|
|
|
@key{INV FACT} is the gamma function.
|
|
@texline @math{\Gamma(x) = (x-1)!}.
|
|
@infoline @expr{gamma(x) = (x-1)!}.
|
|
|
|
@key{PERM} is the number-of-permutations function, which is on the
|
|
@kbd{H k c} key in normal Calc.
|
|
|
|
@key{NXTP} finds the next prime after a number. @kbd{INV NXTP}
|
|
finds the previous prime.
|
|
|
|
@node Keypad Binary Menu, Keypad Vectors Menu, Keypad Functions Menu, Keypad Mode
|
|
@section Binary Menu
|
|
|
|
@smallexample
|
|
@group
|
|
|----+----+----+----+----+----3
|
|
|AND | OR |XOR |NOT |LSH |RSH |
|
|
|----+----+----+----+----+----|
|
|
|DEC |HEX |OCT |BIN |WSIZ|ARSH|
|
|
|----+----+----+----+----+----|
|
|
| A | B | C | D | E | F |
|
|
|----+----+----+----+----+----|
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The keys in this menu perform operations on binary integers.
|
|
Note that both logical and arithmetic right-shifts are provided.
|
|
@key{INV LSH} rotates one bit to the left.
|
|
|
|
The ``difference'' function (normally on @kbd{b d}) is on @key{INV AND}.
|
|
The ``clip'' function (normally on @w{@kbd{b c}}) is on @key{INV NOT}.
|
|
|
|
The @key{DEC}, @key{HEX}, @key{OCT}, and @key{BIN} keys select the
|
|
current radix for display and entry of numbers: Decimal, hexadecimal,
|
|
octal, or binary. The six letter keys @key{A} through @key{F} are used
|
|
for entering hexadecimal numbers.
|
|
|
|
The @key{WSIZ} key displays the current word size for binary operations
|
|
and allows you to enter a new word size. You can respond to the prompt
|
|
using either the keyboard or the digits and @key{ENTER} from the keypad.
|
|
The initial word size is 32 bits.
|
|
|
|
@node Keypad Vectors Menu, Keypad Modes Menu, Keypad Binary Menu, Keypad Mode
|
|
@section Vectors Menu
|
|
|
|
@smallexample
|
|
@group
|
|
|----+----+----+----+----+----4
|
|
|SUM |PROD|MAX |MAP*|MAP^|MAP$|
|
|
|----+----+----+----+----+----|
|
|
|MINV|MDET|MTRN|IDNT|CRSS|"x" |
|
|
|----+----+----+----+----+----|
|
|
|PACK|UNPK|INDX|BLD |LEN |... |
|
|
|----+----+----+----+----+----|
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The keys in this menu operate on vectors and matrices.
|
|
|
|
@key{PACK} removes an integer @var{n} from the top of the stack;
|
|
the next @var{n} stack elements are removed and packed into a vector,
|
|
which is replaced onto the stack. Thus the sequence
|
|
@kbd{1 ENTER 3 ENTER 5 ENTER 3 PACK} enters the vector
|
|
@samp{[1, 3, 5]} onto the stack. To enter a matrix, build each row
|
|
on the stack as a vector, then use a final @key{PACK} to collect the
|
|
rows into a matrix.
|
|
|
|
@key{UNPK} unpacks the vector on the stack, pushing each of its
|
|
components separately.
|
|
|
|
@key{INDX} removes an integer @var{n}, then builds a vector of
|
|
integers from 1 to @var{n}. @kbd{INV INDX} takes three numbers
|
|
from the stack: The vector size @var{n}, the starting number,
|
|
and the increment. @kbd{BLD} takes an integer @var{n} and any
|
|
value @var{x} and builds a vector of @var{n} copies of @var{x}.
|
|
|
|
@key{IDNT} removes an integer @var{n}, then builds an @var{n}-by-@var{n}
|
|
identity matrix.
|
|
|
|
@key{LEN} replaces a vector by its length, an integer.
|
|
|
|
@key{...} turns on or off ``abbreviated'' display mode for large vectors.
|
|
|
|
@key{MINV}, @key{MDET}, @key{MTRN}, and @key{CROSS} are the matrix
|
|
inverse, determinant, and transpose, and vector cross product.
|
|
|
|
@key{SUM} replaces a vector by the sum of its elements. It is
|
|
equivalent to @kbd{u +} in normal Calc (@pxref{Statistical Operations}).
|
|
@key{PROD} computes the product of the elements of a vector, and
|
|
@key{MAX} computes the maximum of all the elements of a vector.
|
|
|
|
@key{INV SUM} computes the alternating sum of the first element
|
|
minus the second, plus the third, minus the fourth, and so on.
|
|
@key{INV MAX} computes the minimum of the vector elements.
|
|
|
|
@key{HYP SUM} computes the mean of the vector elements.
|
|
@key{HYP PROD} computes the sample standard deviation.
|
|
@key{HYP MAX} computes the median.
|
|
|
|
@key{MAP*} multiplies two vectors elementwise. It is equivalent
|
|
to the @kbd{V M *} command. @key{MAP^} computes powers elementwise.
|
|
The arguments must be vectors of equal length, or one must be a vector
|
|
and the other must be a plain number. For example, @kbd{2 MAP^} squares
|
|
all the elements of a vector.
|
|
|
|
@key{MAP$} maps the formula on the top of the stack across the
|
|
vector in the second-to-top position. If the formula contains
|
|
several variables, Calc takes that many vectors starting at the
|
|
second-to-top position and matches them to the variables in
|
|
alphabetical order. The result is a vector of the same size as
|
|
the input vectors, whose elements are the formula evaluated with
|
|
the variables set to the various sets of numbers in those vectors.
|
|
For example, you could simulate @key{MAP^} using @key{MAP$} with
|
|
the formula @samp{x^y}.
|
|
|
|
The @kbd{"x"} key pushes the variable name @expr{x} onto the
|
|
stack. To build the formula @expr{x^2 + 6}, you would use the
|
|
key sequence @kbd{"x" 2 y^x 6 +}. This formula would then be
|
|
suitable for use with the @key{MAP$} key described above.
|
|
With @key{INV}, @key{HYP}, or @key{INV} and @key{HYP}, the
|
|
@kbd{"x"} key pushes the variable names @expr{y}, @expr{z}, and
|
|
@expr{t}, respectively.
|
|
|
|
@node Keypad Modes Menu, , Keypad Vectors Menu, Keypad Mode
|
|
@section Modes Menu
|
|
|
|
@smallexample
|
|
@group
|
|
|----+----+----+----+----+----5
|
|
|FLT |FIX |SCI |ENG |GRP | |
|
|
|----+----+----+----+----+----|
|
|
|RAD |DEG |FRAC|POLR|SYMB|PREC|
|
|
|----+----+----+----+----+----|
|
|
|SWAP|RLL3|RLL4|OVER|STO |RCL |
|
|
|----+----+----+----+----+----|
|
|
@end group
|
|
@end smallexample
|
|
|
|
@noindent
|
|
The keys in this menu manipulate modes, variables, and the stack.
|
|
|
|
The @key{FLT}, @key{FIX}, @key{SCI}, and @key{ENG} keys select
|
|
floating-point, fixed-point, scientific, or engineering notation.
|
|
@key{FIX} displays two digits after the decimal by default; the
|
|
others display full precision. With the @key{INV} prefix, these
|
|
keys pop a number-of-digits argument from the stack.
|
|
|
|
The @key{GRP} key turns grouping of digits with commas on or off.
|
|
@kbd{INV GRP} enables grouping to the right of the decimal point as
|
|
well as to the left.
|
|
|
|
The @key{RAD} and @key{DEG} keys switch between radians and degrees
|
|
for trigonometric functions.
|
|
|
|
The @key{FRAC} key turns Fraction mode on or off. This affects
|
|
whether commands like @kbd{/} with integer arguments produce
|
|
fractional or floating-point results.
|
|
|
|
The @key{POLR} key turns Polar mode on or off, determining whether
|
|
polar or rectangular complex numbers are used by default.
|
|
|
|
The @key{SYMB} key turns Symbolic mode on or off, in which
|
|
operations that would produce inexact floating-point results
|
|
are left unevaluated as algebraic formulas.
|
|
|
|
The @key{PREC} key selects the current precision. Answer with
|
|
the keyboard or with the keypad digit and @key{ENTER} keys.
|
|
|
|
The @key{SWAP} key exchanges the top two stack elements.
|
|
The @key{RLL3} key rotates the top three stack elements upwards.
|
|
The @key{RLL4} key rotates the top four stack elements upwards.
|
|
The @key{OVER} key duplicates the second-to-top stack element.
|
|
|
|
The @key{STO} and @key{RCL} keys are analogous to @kbd{s t} and
|
|
@kbd{s r} in regular Calc. @xref{Store and Recall}. Click the
|
|
@key{STO} or @key{RCL} key, then one of the ten digits. (Named
|
|
variables are not available in Keypad mode.) You can also use,
|
|
for example, @kbd{STO + 3} to add to register 3.
|
|
|
|
@node Embedded Mode, Programming, Keypad Mode, Top
|
|
@chapter Embedded Mode
|
|
|
|
@noindent
|
|
Embedded mode in Calc provides an alternative to copying numbers
|
|
and formulas back and forth between editing buffers and the Calc
|
|
stack. In Embedded mode, your editing buffer becomes temporarily
|
|
linked to the stack and this copying is taken care of automatically.
|
|
|
|
@menu
|
|
* Basic Embedded Mode::
|
|
* More About Embedded Mode::
|
|
* Assignments in Embedded Mode::
|
|
* Mode Settings in Embedded Mode::
|
|
* Customizing Embedded Mode::
|
|
@end menu
|
|
|
|
@node Basic Embedded Mode, More About Embedded Mode, Embedded Mode, Embedded Mode
|
|
@section Basic Embedded Mode
|
|
|
|
@noindent
|
|
@kindex C-x * e
|
|
@pindex calc-embedded
|
|
To enter Embedded mode, position the Emacs point (cursor) on a
|
|
formula in any buffer and press @kbd{C-x * e} (@code{calc-embedded}).
|
|
Note that @kbd{C-x * e} is not to be used in the Calc stack buffer
|
|
like most Calc commands, but rather in regular editing buffers that
|
|
are visiting your own files.
|
|
|
|
Calc will try to guess an appropriate language based on the major mode
|
|
of the editing buffer. (@xref{Language Modes}.) If the current buffer is
|
|
in @code{latex-mode}, for example, Calc will set its language to La@TeX{}.
|
|
Similarly, Calc will use @TeX{} language for @code{tex-mode},
|
|
@code{plain-tex-mode} and @code{context-mode}, C language for
|
|
@code{c-mode} and @code{c++-mode}, FORTRAN language for
|
|
@code{fortran-mode} and @code{f90-mode}, Pascal for @code{pascal-mode},
|
|
and eqn for @code{nroff-mode} (@pxref{Customizing Calc}).
|
|
These can be overridden with Calc's mode
|
|
changing commands (@pxref{Mode Settings in Embedded Mode}). If no
|
|
suitable language is available, Calc will continue with its current language.
|
|
|
|
Calc normally scans backward and forward in the buffer for the
|
|
nearest opening and closing @dfn{formula delimiters}. The simplest
|
|
delimiters are blank lines. Other delimiters that Embedded mode
|
|
understands are:
|
|
|
|
@enumerate
|
|
@item
|
|
The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
|
|
@samp{\[ \]}, and @samp{\( \)};
|
|
@item
|
|
Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
|
|
@item
|
|
Lines beginning with @samp{@@} (Texinfo delimiters).
|
|
@item
|
|
Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
|
|
@item
|
|
Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
|
|
@end enumerate
|
|
|
|
@xref{Customizing Embedded Mode}, to see how to make Calc recognize
|
|
your own favorite delimiters. Delimiters like @samp{$ $} can appear
|
|
on their own separate lines or in-line with the formula.
|
|
|
|
If you give a positive or negative numeric prefix argument, Calc
|
|
instead uses the current point as one end of the formula, and includes
|
|
that many lines forward or backward (respectively, including the current
|
|
line). Explicit delimiters are not necessary in this case.
|
|
|
|
With a prefix argument of zero, Calc uses the current region (delimited
|
|
by point and mark) instead of formula delimiters. With a prefix
|
|
argument of @kbd{C-u} only, Calc uses the current line as the formula.
|
|
|
|
@kindex C-x * w
|
|
@pindex calc-embedded-word
|
|
The @kbd{C-x * w} (@code{calc-embedded-word}) command will start Embedded
|
|
mode on the current ``word''; in this case Calc will scan for the first
|
|
non-numeric character (i.e., the first character that is not a digit,
|
|
sign, decimal point, or upper- or lower-case @samp{e}) forward and
|
|
backward to delimit the formula.
|
|
|
|
When you enable Embedded mode for a formula, Calc reads the text
|
|
between the delimiters and tries to interpret it as a Calc formula.
|
|
Calc can generally identify @TeX{} formulas and
|
|
Big-style formulas even if the language mode is wrong. If Calc
|
|
can't make sense of the formula, it beeps and refuses to enter
|
|
Embedded mode. But if the current language is wrong, Calc can
|
|
sometimes parse the formula successfully (but incorrectly);
|
|
for example, the C expression @samp{atan(a[1])} can be parsed
|
|
in Normal language mode, but the @code{atan} won't correspond to
|
|
the built-in @code{arctan} function, and the @samp{a[1]} will be
|
|
interpreted as @samp{a} times the vector @samp{[1]}!
|
|
|
|
If you press @kbd{C-x * e} or @kbd{C-x * w} to activate an embedded
|
|
formula which is blank, say with the cursor on the space between
|
|
the two delimiters @samp{$ $}, Calc will immediately prompt for
|
|
an algebraic entry.
|
|
|
|
Only one formula in one buffer can be enabled at a time. If you
|
|
move to another area of the current buffer and give Calc commands,
|
|
Calc turns Embedded mode off for the old formula and then tries
|
|
to restart Embedded mode at the new position. Other buffers are
|
|
not affected by Embedded mode.
|
|
|
|
When Embedded mode begins, Calc pushes the current formula onto
|
|
the stack. No Calc stack window is created; however, Calc copies
|
|
the top-of-stack position into the original buffer at all times.
|
|
You can create a Calc window by hand with @kbd{C-x * o} if you
|
|
find you need to see the entire stack.
|
|
|
|
For example, typing @kbd{C-x * e} while somewhere in the formula
|
|
@samp{n>2} in the following line enables Embedded mode on that
|
|
inequality:
|
|
|
|
@example
|
|
We define $F_n = F_(n-1)+F_(n-2)$ for all $n>2$.
|
|
@end example
|
|
|
|
@noindent
|
|
The formula @expr{n>2} will be pushed onto the Calc stack, and
|
|
the top of stack will be copied back into the editing buffer.
|
|
This means that spaces will appear around the @samp{>} symbol
|
|
to match Calc's usual display style:
|
|
|
|
@example
|
|
We define $F_n = F_(n-1)+F_(n-2)$ for all $n > 2$.
|
|
@end example
|
|
|
|
@noindent
|
|
No spaces have appeared around the @samp{+} sign because it's
|
|
in a different formula, one which we have not yet touched with
|
|
Embedded mode.
|
|
|
|
Now that Embedded mode is enabled, keys you type in this buffer
|
|
are interpreted as Calc commands. At this point we might use
|
|
the ``commute'' command @kbd{j C} to reverse the inequality.
|
|
This is a selection-based command for which we first need to
|
|
move the cursor onto the operator (@samp{>} in this case) that
|
|
needs to be commuted.
|
|
|
|
@example
|
|
We define $F_n = F_(n-1)+F_(n-2)$ for all $2 < n$.
|
|
@end example
|
|
|
|
The @kbd{C-x * o} command is a useful way to open a Calc window
|
|
without actually selecting that window. Giving this command
|
|
verifies that @samp{2 < n} is also on the Calc stack. Typing
|
|
@kbd{17 @key{RET}} would produce:
|
|
|
|
@example
|
|
We define $F_n = F_(n-1)+F_(n-2)$ for all $17$.
|
|
@end example
|
|
|
|
@noindent
|
|
with @samp{2 < n} and @samp{17} on the stack; typing @key{TAB}
|
|
at this point will exchange the two stack values and restore
|
|
@samp{2 < n} to the embedded formula. Even though you can't
|
|
normally see the stack in Embedded mode, it is still there and
|
|
it still operates in the same way. But, as with old-fashioned
|
|
RPN calculators, you can only see the value at the top of the
|
|
stack at any given time (unless you use @kbd{C-x * o}).
|
|
|
|
Typing @kbd{C-x * e} again turns Embedded mode off. The Calc
|
|
window reveals that the formula @w{@samp{2 < n}} is automatically
|
|
removed from the stack, but the @samp{17} is not. Entering
|
|
Embedded mode always pushes one thing onto the stack, and
|
|
leaving Embedded mode always removes one thing. Anything else
|
|
that happens on the stack is entirely your business as far as
|
|
Embedded mode is concerned.
|
|
|
|
If you press @kbd{C-x * e} in the wrong place by accident, it is
|
|
possible that Calc will be able to parse the nearby text as a
|
|
formula and will mangle that text in an attempt to redisplay it
|
|
``properly'' in the current language mode. If this happens,
|
|
press @kbd{C-x * e} again to exit Embedded mode, then give the
|
|
regular Emacs ``undo'' command (@kbd{C-_} or @kbd{C-x u}) to put
|
|
the text back the way it was before Calc edited it. Note that Calc's
|
|
own Undo command (typed before you turn Embedded mode back off)
|
|
will not do you any good, because as far as Calc is concerned
|
|
you haven't done anything with this formula yet.
|
|
|
|
@node More About Embedded Mode, Assignments in Embedded Mode, Basic Embedded Mode, Embedded Mode
|
|
@section More About Embedded Mode
|
|
|
|
@noindent
|
|
When Embedded mode ``activates'' a formula, i.e., when it examines
|
|
the formula for the first time since the buffer was created or
|
|
loaded, Calc tries to sense the language in which the formula was
|
|
written. If the formula contains any La@TeX{}-like @samp{\} sequences,
|
|
it is parsed (i.e., read) in La@TeX{} mode. If the formula appears to
|
|
be written in multi-line Big mode, it is parsed in Big mode. Otherwise,
|
|
it is parsed according to the current language mode.
|
|
|
|
Note that Calc does not change the current language mode according
|
|
the formula it reads in. Even though it can read a La@TeX{} formula when
|
|
not in La@TeX{} mode, it will immediately rewrite this formula using
|
|
whatever language mode is in effect.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
@kindex d p
|
|
@pindex calc-show-plain
|
|
Calc's parser is unable to read certain kinds of formulas. For
|
|
example, with @kbd{v ]} (@code{calc-matrix-brackets}) you can
|
|
specify matrix display styles which the parser is unable to
|
|
recognize as matrices. The @kbd{d p} (@code{calc-show-plain})
|
|
command turns on a mode in which a ``plain'' version of a
|
|
formula is placed in front of the fully-formatted version.
|
|
When Calc reads a formula that has such a plain version in
|
|
front, it reads the plain version and ignores the formatted
|
|
version.
|
|
|
|
Plain formulas are preceded and followed by @samp{%%%} signs
|
|
by default. This notation has the advantage that the @samp{%}
|
|
character begins a comment in @TeX{} and La@TeX{}, so if your formula is
|
|
embedded in a @TeX{} or La@TeX{} document its plain version will be
|
|
invisible in the final printed copy. Certain major modes have different
|
|
delimiters to ensure that the ``plain'' version will be
|
|
in a comment for those modes, also.
|
|
See @ref{Customizing Embedded Mode} to see how to change the ``plain''
|
|
formula delimiters.
|
|
|
|
There are several notations which Calc's parser for ``big''
|
|
formatted formulas can't yet recognize. In particular, it can't
|
|
read the large symbols for @code{sum}, @code{prod}, and @code{integ},
|
|
and it can't handle @samp{=>} with the righthand argument omitted.
|
|
Also, Calc won't recognize special formats you have defined with
|
|
the @kbd{Z C} command (@pxref{User-Defined Compositions}). In
|
|
these cases it is important to use ``plain'' mode to make sure
|
|
Calc will be able to read your formula later.
|
|
|
|
Another example where ``plain'' mode is important is if you have
|
|
specified a float mode with few digits of precision. Normally
|
|
any digits that are computed but not displayed will simply be
|
|
lost when you save and re-load your embedded buffer, but ``plain''
|
|
mode allows you to make sure that the complete number is present
|
|
in the file as well as the rounded-down number.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
Embedded buffers remember active formulas for as long as they
|
|
exist in Emacs memory. Suppose you have an embedded formula
|
|
which is @cpi{} to the normal 12 decimal places, and then
|
|
type @w{@kbd{C-u 5 d n}} to display only five decimal places.
|
|
If you then type @kbd{d n}, all 12 places reappear because the
|
|
full number is still there on the Calc stack. More surprisingly,
|
|
even if you exit Embedded mode and later re-enter it for that
|
|
formula, typing @kbd{d n} will restore all 12 places because
|
|
each buffer remembers all its active formulas. However, if you
|
|
save the buffer in a file and reload it in a new Emacs session,
|
|
all non-displayed digits will have been lost unless you used
|
|
``plain'' mode.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
In some applications of Embedded mode, you will want to have a
|
|
sequence of copies of a formula that show its evolution as you
|
|
work on it. For example, you might want to have a sequence
|
|
like this in your file (elaborating here on the example from
|
|
the ``Getting Started'' chapter):
|
|
|
|
@smallexample
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
is
|
|
|
|
@r{(the derivative of }ln(ln(x))@r{)}
|
|
|
|
whose value at x = 2 is
|
|
|
|
@r{(the value)}
|
|
|
|
and at x = 3 is
|
|
|
|
@r{(the value)}
|
|
@end smallexample
|
|
|
|
@kindex C-x * d
|
|
@pindex calc-embedded-duplicate
|
|
The @kbd{C-x * d} (@code{calc-embedded-duplicate}) command is a
|
|
handy way to make sequences like this. If you type @kbd{C-x * d},
|
|
the formula under the cursor (which may or may not have Embedded
|
|
mode enabled for it at the time) is copied immediately below and
|
|
Embedded mode is then enabled for that copy.
|
|
|
|
For this example, you would start with just
|
|
|
|
@smallexample
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
and press @kbd{C-x * d} with the cursor on this formula. The result
|
|
is
|
|
|
|
@smallexample
|
|
The derivative of
|
|
|
|
ln(ln(x))
|
|
|
|
|
|
ln(ln(x))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
with the second copy of the formula enabled in Embedded mode.
|
|
You can now press @kbd{a d x @key{RET}} to take the derivative, and
|
|
@kbd{C-x * d C-x * d} to make two more copies of the derivative.
|
|
To complete the computations, type @kbd{3 s l x @key{RET}} to evaluate
|
|
the last formula, then move up to the second-to-last formula
|
|
and type @kbd{2 s l x @key{RET}}.
|
|
|
|
Finally, you would want to press @kbd{C-x * e} to exit Embedded
|
|
mode, then go up and insert the necessary text in between the
|
|
various formulas and numbers.
|
|
|
|
@tex
|
|
\bigskip
|
|
@end tex
|
|
|
|
@kindex C-x * f
|
|
@kindex C-x * '
|
|
@pindex calc-embedded-new-formula
|
|
The @kbd{C-x * f} (@code{calc-embedded-new-formula}) command
|
|
creates a new embedded formula at the current point. It inserts
|
|
some default delimiters, which are usually just blank lines,
|
|
and then does an algebraic entry to get the formula (which is
|
|
then enabled for Embedded mode). This is just shorthand for
|
|
typing the delimiters yourself, positioning the cursor between
|
|
the new delimiters, and pressing @kbd{C-x * e}. The key sequence
|
|
@kbd{C-x * '} is equivalent to @kbd{C-x * f}.
|
|
|
|
@kindex C-x * n
|
|
@kindex C-x * p
|
|
@pindex calc-embedded-next
|
|
@pindex calc-embedded-previous
|
|
The @kbd{C-x * n} (@code{calc-embedded-next}) and @kbd{C-x * p}
|
|
(@code{calc-embedded-previous}) commands move the cursor to the
|
|
next or previous active embedded formula in the buffer. They
|
|
can take positive or negative prefix arguments to move by several
|
|
formulas. Note that these commands do not actually examine the
|
|
text of the buffer looking for formulas; they only see formulas
|
|
which have previously been activated in Embedded mode. In fact,
|
|
@kbd{C-x * n} and @kbd{C-x * p} are a useful way to tell which
|
|
embedded formulas are currently active. Also, note that these
|
|
commands do not enable Embedded mode on the next or previous
|
|
formula, they just move the cursor.
|
|
|
|
@kindex C-x * `
|
|
@pindex calc-embedded-edit
|
|
The @kbd{C-x * `} (@code{calc-embedded-edit}) command edits the
|
|
embedded formula at the current point as if by @kbd{`} (@code{calc-edit}).
|
|
Embedded mode does not have to be enabled for this to work. Press
|
|
@kbd{C-c C-c} to finish the edit, or @kbd{C-x k} to cancel.
|
|
|
|
@node Assignments in Embedded Mode, Mode Settings in Embedded Mode, More About Embedded Mode, Embedded Mode
|
|
@section Assignments in Embedded Mode
|
|
|
|
@noindent
|
|
The @samp{:=} (assignment) and @samp{=>} (``evaluates-to'') operators
|
|
are especially useful in Embedded mode. They allow you to make
|
|
a definition in one formula, then refer to that definition in
|
|
other formulas embedded in the same buffer.
|
|
|
|
An embedded formula which is an assignment to a variable, as in
|
|
|
|
@example
|
|
foo := 5
|
|
@end example
|
|
|
|
@noindent
|
|
records @expr{5} as the stored value of @code{foo} for the
|
|
purposes of Embedded mode operations in the current buffer. It
|
|
does @emph{not} actually store @expr{5} as the ``global'' value
|
|
of @code{foo}, however. Regular Calc operations, and Embedded
|
|
formulas in other buffers, will not see this assignment.
|
|
|
|
One way to use this assigned value is simply to create an
|
|
Embedded formula elsewhere that refers to @code{foo}, and to press
|
|
@kbd{=} in that formula. However, this permanently replaces the
|
|
@code{foo} in the formula with its current value. More interesting
|
|
is to use @samp{=>} elsewhere:
|
|
|
|
@example
|
|
foo + 7 => 12
|
|
@end example
|
|
|
|
@xref{Evaluates-To Operator}, for a general discussion of @samp{=>}.
|
|
|
|
If you move back and change the assignment to @code{foo}, any
|
|
@samp{=>} formulas which refer to it are automatically updated.
|
|
|
|
@example
|
|
foo := 17
|
|
|
|
foo + 7 => 24
|
|
@end example
|
|
|
|
The obvious question then is, @emph{how} can one easily change the
|
|
assignment to @code{foo}? If you simply select the formula in
|
|
Embedded mode and type 17, the assignment itself will be replaced
|
|
by the 17. The effect on the other formula will be that the
|
|
variable @code{foo} becomes unassigned:
|
|
|
|
@example
|
|
17
|
|
|
|
foo + 7 => foo + 7
|
|
@end example
|
|
|
|
The right thing to do is first to use a selection command (@kbd{j 2}
|
|
will do the trick) to select the righthand side of the assignment.
|
|
Then, @kbd{17 @key{TAB} @key{DEL}} will swap the 17 into place (@pxref{Selecting
|
|
Subformulas}, to see how this works).
|
|
|
|
@kindex C-x * j
|
|
@pindex calc-embedded-select
|
|
The @kbd{C-x * j} (@code{calc-embedded-select}) command provides an
|
|
easy way to operate on assignments. It is just like @kbd{C-x * e},
|
|
except that if the enabled formula is an assignment, it uses
|
|
@kbd{j 2} to select the righthand side. If the enabled formula
|
|
is an evaluates-to, it uses @kbd{j 1} to select the lefthand side.
|
|
A formula can also be a combination of both:
|
|
|
|
@example
|
|
bar := foo + 3 => 20
|
|
@end example
|
|
|
|
@noindent
|
|
in which case @kbd{C-x * j} will select the middle part (@samp{foo + 3}).
|
|
|
|
The formula is automatically deselected when you leave Embedded
|
|
mode.
|
|
|
|
@kindex C-x * u
|
|
@pindex calc-embedded-update-formula
|
|
Another way to change the assignment to @code{foo} would simply be
|
|
to edit the number using regular Emacs editing rather than Embedded
|
|
mode. Then, we have to find a way to get Embedded mode to notice
|
|
the change. The @kbd{C-x * u} (@code{calc-embedded-update-formula})
|
|
command is a convenient way to do this.
|
|
|
|
@example
|
|
foo := 6
|
|
|
|
foo + 7 => 13
|
|
@end example
|
|
|
|
Pressing @kbd{C-x * u} is much like pressing @kbd{C-x * e = C-x * e}, that
|
|
is, temporarily enabling Embedded mode for the formula under the
|
|
cursor and then evaluating it with @kbd{=}. But @kbd{C-x * u} does
|
|
not actually use @kbd{C-x * e}, and in fact another formula somewhere
|
|
else can be enabled in Embedded mode while you use @kbd{C-x * u} and
|
|
that formula will not be disturbed.
|
|
|
|
With a numeric prefix argument, @kbd{C-x * u} updates all active
|
|
@samp{=>} formulas in the buffer. Formulas which have not yet
|
|
been activated in Embedded mode, and formulas which do not have
|
|
@samp{=>} as their top-level operator, are not affected by this.
|
|
(This is useful only if you have used @kbd{m C}; see below.)
|
|
|
|
With a plain @kbd{C-u} prefix, @kbd{C-u C-x * u} updates only in the
|
|
region between mark and point rather than in the whole buffer.
|
|
|
|
@kbd{C-x * u} is also a handy way to activate a formula, such as an
|
|
@samp{=>} formula that has freshly been typed in or loaded from a
|
|
file.
|
|
|
|
@kindex C-x * a
|
|
@pindex calc-embedded-activate
|
|
The @kbd{C-x * a} (@code{calc-embedded-activate}) command scans
|
|
through the current buffer and activates all embedded formulas
|
|
that contain @samp{:=} or @samp{=>} symbols. This does not mean
|
|
that Embedded mode is actually turned on, but only that the
|
|
formulas' positions are registered with Embedded mode so that
|
|
the @samp{=>} values can be properly updated as assignments are
|
|
changed.
|
|
|
|
It is a good idea to type @kbd{C-x * a} right after loading a file
|
|
that uses embedded @samp{=>} operators. Emacs includes a nifty
|
|
``buffer-local variables'' feature that you can use to do this
|
|
automatically. The idea is to place near the end of your file
|
|
a few lines that look like this:
|
|
|
|
@example
|
|
--- Local Variables: ---
|
|
--- eval:(calc-embedded-activate) ---
|
|
--- End: ---
|
|
@end example
|
|
|
|
@noindent
|
|
where the leading and trailing @samp{---} can be replaced by
|
|
any suitable strings (which must be the same on all three lines)
|
|
or omitted altogether; in a @TeX{} or La@TeX{} file, @samp{%} would be a good
|
|
leading string and no trailing string would be necessary. In a
|
|
C program, @samp{/*} and @samp{*/} would be good leading and
|
|
trailing strings.
|
|
|
|
When Emacs loads a file into memory, it checks for a Local Variables
|
|
section like this one at the end of the file. If it finds this
|
|
section, it does the specified things (in this case, running
|
|
@kbd{C-x * a} automatically) before editing of the file begins.
|
|
The Local Variables section must be within 3000 characters of the
|
|
end of the file for Emacs to find it, and it must be in the last
|
|
page of the file if the file has any page separators.
|
|
@xref{File Variables, , Local Variables in Files, emacs, the
|
|
Emacs manual}.
|
|
|
|
Note that @kbd{C-x * a} does not update the formulas it finds.
|
|
To do this, type, say, @kbd{M-1 C-x * u} after @w{@kbd{C-x * a}}.
|
|
Generally this should not be a problem, though, because the
|
|
formulas will have been up-to-date already when the file was
|
|
saved.
|
|
|
|
Normally, @kbd{C-x * a} activates all the formulas it finds, but
|
|
any previous active formulas remain active as well. With a
|
|
positive numeric prefix argument, @kbd{C-x * a} first deactivates
|
|
all current active formulas, then actives the ones it finds in
|
|
its scan of the buffer. With a negative prefix argument,
|
|
@kbd{C-x * a} simply deactivates all formulas.
|
|
|
|
Embedded mode has two symbols, @samp{Active} and @samp{~Active},
|
|
which it puts next to the major mode name in a buffer's mode line.
|
|
It puts @samp{Active} if it has reason to believe that all
|
|
formulas in the buffer are active, because you have typed @kbd{C-x * a}
|
|
and Calc has not since had to deactivate any formulas (which can
|
|
happen if Calc goes to update an @samp{=>} formula somewhere because
|
|
a variable changed, and finds that the formula is no longer there
|
|
due to some kind of editing outside of Embedded mode). Calc puts
|
|
@samp{~Active} in the mode line if some, but probably not all,
|
|
formulas in the buffer are active. This happens if you activate
|
|
a few formulas one at a time but never use @kbd{C-x * a}, or if you
|
|
used @kbd{C-x * a} but then Calc had to deactivate a formula
|
|
because it lost track of it. If neither of these symbols appears
|
|
in the mode line, no embedded formulas are active in the buffer
|
|
(e.g., before Embedded mode has been used, or after a @kbd{M-- C-x * a}).
|
|
|
|
Embedded formulas can refer to assignments both before and after them
|
|
in the buffer. If there are several assignments to a variable, the
|
|
nearest preceding assignment is used if there is one, otherwise the
|
|
following assignment is used.
|
|
|
|
@example
|
|
x => 1
|
|
|
|
x := 1
|
|
|
|
x => 1
|
|
|
|
x := 2
|
|
|
|
x => 2
|
|
@end example
|
|
|
|
As well as simple variables, you can also assign to subscript
|
|
expressions of the form @samp{@var{var}_@var{number}} (as in
|
|
@code{x_0}), or @samp{@var{var}_@var{var}} (as in @code{x_max}).
|
|
Assignments to other kinds of objects can be represented by Calc,
|
|
but the automatic linkage between assignments and references works
|
|
only for plain variables and these two kinds of subscript expressions.
|
|
|
|
If there are no assignments to a given variable, the global
|
|
stored value for the variable is used (@pxref{Storing Variables}),
|
|
or, if no value is stored, the variable is left in symbolic form.
|
|
Note that global stored values will be lost when the file is saved
|
|
and loaded in a later Emacs session, unless you have used the
|
|
@kbd{s p} (@code{calc-permanent-variable}) command to save them;
|
|
@pxref{Operations on Variables}.
|
|
|
|
The @kbd{m C} (@code{calc-auto-recompute}) command turns automatic
|
|
recomputation of @samp{=>} forms on and off. If you turn automatic
|
|
recomputation off, you will have to use @kbd{C-x * u} to update these
|
|
formulas manually after an assignment has been changed. If you
|
|
plan to change several assignments at once, it may be more efficient
|
|
to type @kbd{m C}, change all the assignments, then use @kbd{M-1 C-x * u}
|
|
to update the entire buffer afterwards. The @kbd{m C} command also
|
|
controls @samp{=>} formulas on the stack; @pxref{Evaluates-To
|
|
Operator}. When you turn automatic recomputation back on, the
|
|
stack will be updated but the Embedded buffer will not; you must
|
|
use @kbd{C-x * u} to update the buffer by hand.
|
|
|
|
@node Mode Settings in Embedded Mode, Customizing Embedded Mode, Assignments in Embedded Mode, Embedded Mode
|
|
@section Mode Settings in Embedded Mode
|
|
|
|
@kindex m e
|
|
@pindex calc-embedded-preserve-modes
|
|
@noindent
|
|
The mode settings can be changed while Calc is in embedded mode, but
|
|
by default they will revert to their original values when embedded mode
|
|
is ended. However, the modes saved when the mode-recording mode is
|
|
@code{Save} (see below) and the modes in effect when the @kbd{m e}
|
|
(@code{calc-embedded-preserve-modes}) command is given
|
|
will be preserved when embedded mode is ended.
|
|
|
|
Embedded mode has a rather complicated mechanism for handling mode
|
|
settings in Embedded formulas. It is possible to put annotations
|
|
in the file that specify mode settings either global to the entire
|
|
file or local to a particular formula or formulas. In the latter
|
|
case, different modes can be specified for use when a formula
|
|
is the enabled Embedded mode formula.
|
|
|
|
When you give any mode-setting command, like @kbd{m f} (for Fraction
|
|
mode) or @kbd{d s} (for scientific notation), Embedded mode adds
|
|
a line like the following one to the file just before the opening
|
|
delimiter of the formula.
|
|
|
|
@example
|
|
% [calc-mode: fractions: t]
|
|
% [calc-mode: float-format: (sci 0)]
|
|
@end example
|
|
|
|
When Calc interprets an embedded formula, it scans the text before
|
|
the formula for mode-setting annotations like these and sets the
|
|
Calc buffer to match these modes. Modes not explicitly described
|
|
in the file are not changed. Calc scans all the way to the top of
|
|
the file, or up to a line of the form
|
|
|
|
@example
|
|
% [calc-defaults]
|
|
@end example
|
|
|
|
@noindent
|
|
which you can insert at strategic places in the file if this backward
|
|
scan is getting too slow, or just to provide a barrier between one
|
|
``zone'' of mode settings and another.
|
|
|
|
If the file contains several annotations for the same mode, the
|
|
closest one before the formula is used. Annotations after the
|
|
formula are never used (except for global annotations, described
|
|
below).
|
|
|
|
The scan does not look for the leading @samp{% }, only for the
|
|
square brackets and the text they enclose. In fact, the leading
|
|
characters are different for different major modes. You can edit the
|
|
mode annotations to a style that works better in context if you wish.
|
|
@xref{Customizing Embedded Mode}, to see how to change the style
|
|
that Calc uses when it generates the annotations. You can write
|
|
mode annotations into the file yourself if you know the syntax;
|
|
the easiest way to find the syntax for a given mode is to let
|
|
Calc write the annotation for it once and see what it does.
|
|
|
|
If you give a mode-changing command for a mode that already has
|
|
a suitable annotation just above the current formula, Calc will
|
|
modify that annotation rather than generating a new, conflicting
|
|
one.
|
|
|
|
Mode annotations have three parts, separated by colons. (Spaces
|
|
after the colons are optional.) The first identifies the kind
|
|
of mode setting, the second is a name for the mode itself, and
|
|
the third is the value in the form of a Lisp symbol, number,
|
|
or list. Annotations with unrecognizable text in the first or
|
|
second parts are ignored. The third part is not checked to make
|
|
sure the value is of a valid type or range; if you write an
|
|
annotation by hand, be sure to give a proper value or results
|
|
will be unpredictable. Mode-setting annotations are case-sensitive.
|
|
|
|
While Embedded mode is enabled, the word @code{Local} appears in
|
|
the mode line. This is to show that mode setting commands generate
|
|
annotations that are ``local'' to the current formula or set of
|
|
formulas. The @kbd{m R} (@code{calc-mode-record-mode}) command
|
|
causes Calc to generate different kinds of annotations. Pressing
|
|
@kbd{m R} repeatedly cycles through the possible modes.
|
|
|
|
@code{LocEdit} and @code{LocPerm} modes generate annotations
|
|
that look like this, respectively:
|
|
|
|
@example
|
|
% [calc-edit-mode: float-format: (sci 0)]
|
|
% [calc-perm-mode: float-format: (sci 5)]
|
|
@end example
|
|
|
|
The first kind of annotation will be used only while a formula
|
|
is enabled in Embedded mode. The second kind will be used only
|
|
when the formula is @emph{not} enabled. (Whether the formula
|
|
is ``active'' or not, i.e., whether Calc has seen this formula
|
|
yet, is not relevant here.)
|
|
|
|
@code{Global} mode generates an annotation like this at the end
|
|
of the file:
|
|
|
|
@example
|
|
% [calc-global-mode: fractions t]
|
|
@end example
|
|
|
|
Global mode annotations affect all formulas throughout the file,
|
|
and may appear anywhere in the file. This allows you to tuck your
|
|
mode annotations somewhere out of the way, say, on a new page of
|
|
the file, as long as those mode settings are suitable for all
|
|
formulas in the file.
|
|
|
|
Enabling a formula with @kbd{C-x * e} causes a fresh scan for local
|
|
mode annotations; you will have to use this after adding annotations
|
|
above a formula by hand to get the formula to notice them. Updating
|
|
a formula with @kbd{C-x * u} will also re-scan the local modes, but
|
|
global modes are only re-scanned by @kbd{C-x * a}.
|
|
|
|
Another way that modes can get out of date is if you add a local
|
|
mode annotation to a formula that has another formula after it.
|
|
In this example, we have used the @kbd{d s} command while the
|
|
first of the two embedded formulas is active. But the second
|
|
formula has not changed its style to match, even though by the
|
|
rules of reading annotations the @samp{(sci 0)} applies to it, too.
|
|
|
|
@example
|
|
% [calc-mode: float-format: (sci 0)]
|
|
1.23e2
|
|
|
|
456.
|
|
@end example
|
|
|
|
We would have to go down to the other formula and press @kbd{C-x * u}
|
|
on it in order to get it to notice the new annotation.
|
|
|
|
Two more mode-recording modes selectable by @kbd{m R} are available
|
|
which are also available outside of Embedded mode.
|
|
(@pxref{General Mode Commands}.) They are @code{Save}, in which mode
|
|
settings are recorded permanently in your Calc init file (the file given
|
|
by the variable @code{calc-settings-file}, typically @file{~/.calc.el})
|
|
rather than by annotating the current document, and no-recording
|
|
mode (where there is no symbol like @code{Save} or @code{Local} in
|
|
the mode line), in which mode-changing commands do not leave any
|
|
annotations at all.
|
|
|
|
When Embedded mode is not enabled, mode-recording modes except
|
|
for @code{Save} have no effect.
|
|
|
|
@node Customizing Embedded Mode, , Mode Settings in Embedded Mode, Embedded Mode
|
|
@section Customizing Embedded Mode
|
|
|
|
@noindent
|
|
You can modify Embedded mode's behavior by setting various Lisp
|
|
variables described here. These variables are customizable
|
|
(@pxref{Customizing Calc}), or you can use @kbd{M-x set-variable}
|
|
or @kbd{M-x edit-options} to adjust a variable on the fly.
|
|
(Another possibility would be to use a file-local variable annotation at
|
|
the end of the file;
|
|
@pxref{File Variables, , Local Variables in Files, emacs, the Emacs manual}.)
|
|
Many of the variables given mentioned here can be set to depend on the
|
|
major mode of the editing buffer (@pxref{Customizing Calc}).
|
|
|
|
@vindex calc-embedded-open-formula
|
|
The @code{calc-embedded-open-formula} variable holds a regular
|
|
expression for the opening delimiter of a formula. @xref{Regexp Search,
|
|
, Regular Expression Search, emacs, the Emacs manual}, to see
|
|
how regular expressions work. Basically, a regular expression is a
|
|
pattern that Calc can search for. A regular expression that considers
|
|
blank lines, @samp{$}, and @samp{$$} to be opening delimiters is
|
|
@code{"\\`\\|^\n\\|\\$\\$?"}. Just in case the meaning of this
|
|
regular expression is not completely plain, let's go through it
|
|
in detail.
|
|
|
|
The surrounding @samp{" "} marks quote the text between them as a
|
|
Lisp string. If you left them off, @code{set-variable} or
|
|
@code{edit-options} would try to read the regular expression as a
|
|
Lisp program.
|
|
|
|
The most obvious property of this regular expression is that it
|
|
contains indecently many backslashes. There are actually two levels
|
|
of backslash usage going on here. First, when Lisp reads a quoted
|
|
string, all pairs of characters beginning with a backslash are
|
|
interpreted as special characters. Here, @code{\n} changes to a
|
|
new-line character, and @code{\\} changes to a single backslash.
|
|
So the actual regular expression seen by Calc is
|
|
@samp{\`\|^ @r{(newline)} \|\$\$?}.
|
|
|
|
Regular expressions also consider pairs beginning with backslash
|
|
to have special meanings. Sometimes the backslash is used to quote
|
|
a character that otherwise would have a special meaning in a regular
|
|
expression, like @samp{$}, which normally means ``end-of-line,''
|
|
or @samp{?}, which means that the preceding item is optional. So
|
|
@samp{\$\$?} matches either one or two dollar signs.
|
|
|
|
The other codes in this regular expression are @samp{^}, which matches
|
|
``beginning-of-line,'' @samp{\|}, which means ``or,'' and @samp{\`},
|
|
which matches ``beginning-of-buffer.'' So the whole pattern means
|
|
that a formula begins at the beginning of the buffer, or on a newline
|
|
that occurs at the beginning of a line (i.e., a blank line), or at
|
|
one or two dollar signs.
|
|
|
|
The default value of @code{calc-embedded-open-formula} looks just
|
|
like this example, with several more alternatives added on to
|
|
recognize various other common kinds of delimiters.
|
|
|
|
By the way, the reason to use @samp{^\n} rather than @samp{^$}
|
|
or @samp{\n\n}, which also would appear to match blank lines,
|
|
is that the former expression actually ``consumes'' only one
|
|
newline character as @emph{part of} the delimiter, whereas the
|
|
latter expressions consume zero or two newlines, respectively.
|
|
The former choice gives the most natural behavior when Calc
|
|
must operate on a whole formula including its delimiters.
|
|
|
|
See the Emacs manual for complete details on regular expressions.
|
|
But just for your convenience, here is a list of all characters
|
|
which must be quoted with backslash (like @samp{\$}) to avoid
|
|
some special interpretation: @samp{. * + ? [ ] ^ $ \}. (Note
|
|
the backslash in this list; for example, to match @samp{\[} you
|
|
must use @code{"\\\\\\["}. An exercise for the reader is to
|
|
account for each of these six backslashes!)
|
|
|
|
@vindex calc-embedded-close-formula
|
|
The @code{calc-embedded-close-formula} variable holds a regular
|
|
expression for the closing delimiter of a formula. A closing
|
|
regular expression to match the above example would be
|
|
@code{"\\'\\|\n$\\|\\$\\$?"}. This is almost the same as the
|
|
other one, except it now uses @samp{\'} (``end-of-buffer'') and
|
|
@samp{\n$} (newline occurring at end of line, yet another way
|
|
of describing a blank line that is more appropriate for this
|
|
case).
|
|
|
|
@vindex calc-embedded-open-word
|
|
@vindex calc-embedded-close-word
|
|
The @code{calc-embedded-open-word} and @code{calc-embedded-close-word}
|
|
variables are similar expressions used when you type @kbd{C-x * w}
|
|
instead of @kbd{C-x * e} to enable Embedded mode.
|
|
|
|
@vindex calc-embedded-open-plain
|
|
The @code{calc-embedded-open-plain} variable is a string which
|
|
begins a ``plain'' formula written in front of the formatted
|
|
formula when @kbd{d p} mode is turned on. Note that this is an
|
|
actual string, not a regular expression, because Calc must be able
|
|
to write this string into a buffer as well as to recognize it.
|
|
The default string is @code{"%%% "} (note the trailing space), but may
|
|
be different for certain major modes.
|
|
|
|
@vindex calc-embedded-close-plain
|
|
The @code{calc-embedded-close-plain} variable is a string which
|
|
ends a ``plain'' formula. The default is @code{" %%%\n"}, but may be
|
|
different for different major modes. Without
|
|
the trailing newline here, the first line of a Big mode formula
|
|
that followed might be shifted over with respect to the other lines.
|
|
|
|
@vindex calc-embedded-open-new-formula
|
|
The @code{calc-embedded-open-new-formula} variable is a string
|
|
which is inserted at the front of a new formula when you type
|
|
@kbd{C-x * f}. Its default value is @code{"\n\n"}. If this
|
|
string begins with a newline character and the @kbd{C-x * f} is
|
|
typed at the beginning of a line, @kbd{C-x * f} will skip this
|
|
first newline to avoid introducing unnecessary blank lines in
|
|
the file.
|
|
|
|
@vindex calc-embedded-close-new-formula
|
|
The @code{calc-embedded-close-new-formula} variable is the corresponding
|
|
string which is inserted at the end of a new formula. Its default
|
|
value is also @code{"\n\n"}. The final newline is omitted by
|
|
@w{@kbd{C-x * f}} if typed at the end of a line. (It follows that if
|
|
@kbd{C-x * f} is typed on a blank line, both a leading opening
|
|
newline and a trailing closing newline are omitted.)
|
|
|
|
@vindex calc-embedded-announce-formula
|
|
The @code{calc-embedded-announce-formula} variable is a regular
|
|
expression which is sure to be followed by an embedded formula.
|
|
The @kbd{C-x * a} command searches for this pattern as well as for
|
|
@samp{=>} and @samp{:=} operators. Note that @kbd{C-x * a} will
|
|
not activate just anything surrounded by formula delimiters; after
|
|
all, blank lines are considered formula delimiters by default!
|
|
But if your language includes a delimiter which can only occur
|
|
actually in front of a formula, you can take advantage of it here.
|
|
The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, but may be
|
|
different for different major modes.
|
|
This pattern will check for @samp{%Embed} followed by any number of
|
|
lines beginning with @samp{%} and a space. This last is important to
|
|
make Calc consider mode annotations part of the pattern, so that the
|
|
formula's opening delimiter really is sure to follow the pattern.
|
|
|
|
@vindex calc-embedded-open-mode
|
|
The @code{calc-embedded-open-mode} variable is a string (not a
|
|
regular expression) which should precede a mode annotation.
|
|
Calc never scans for this string; Calc always looks for the
|
|
annotation itself. But this is the string that is inserted before
|
|
the opening bracket when Calc adds an annotation on its own.
|
|
The default is @code{"% "}, but may be different for different major
|
|
modes.
|
|
|
|
@vindex calc-embedded-close-mode
|
|
The @code{calc-embedded-close-mode} variable is a string which
|
|
follows a mode annotation written by Calc. Its default value
|
|
is simply a newline, @code{"\n"}, but may be different for different
|
|
major modes. If you change this, it is a good idea still to end with a
|
|
newline so that mode annotations will appear on lines by themselves.
|
|
|
|
@node Programming, Customizing Calc, Embedded Mode, Top
|
|
@chapter Programming
|
|
|
|
@noindent
|
|
There are several ways to ``program'' the Emacs Calculator, depending
|
|
on the nature of the problem you need to solve.
|
|
|
|
@enumerate
|
|
@item
|
|
@dfn{Keyboard macros} allow you to record a sequence of keystrokes
|
|
and play them back at a later time. This is just the standard Emacs
|
|
keyboard macro mechanism, dressed up with a few more features such
|
|
as loops and conditionals.
|
|
|
|
@item
|
|
@dfn{Algebraic definitions} allow you to use any formula to define a
|
|
new function. This function can then be used in algebraic formulas or
|
|
as an interactive command.
|
|
|
|
@item
|
|
@dfn{Rewrite rules} are discussed in the section on algebra commands.
|
|
@xref{Rewrite Rules}. If you put your rewrite rules in the variable
|
|
@code{EvalRules}, they will be applied automatically to all Calc
|
|
results in just the same way as an internal ``rule'' is applied to
|
|
evaluate @samp{sqrt(9)} to 3 and so on. @xref{Automatic Rewrites}.
|
|
|
|
@item
|
|
@dfn{Lisp} is the programming language that Calc (and most of Emacs)
|
|
is written in. If the above techniques aren't powerful enough, you
|
|
can write Lisp functions to do anything that built-in Calc commands
|
|
can do. Lisp code is also somewhat faster than keyboard macros or
|
|
rewrite rules.
|
|
@end enumerate
|
|
|
|
@kindex z
|
|
Programming features are available through the @kbd{z} and @kbd{Z}
|
|
prefix keys. New commands that you define are two-key sequences
|
|
beginning with @kbd{z}. Commands for managing these definitions
|
|
use the shift-@kbd{Z} prefix. (The @kbd{Z T} (@code{calc-timing})
|
|
command is described elsewhere; @pxref{Troubleshooting Commands}.
|
|
The @kbd{Z C} (@code{calc-user-define-composition}) command is also
|
|
described elsewhere; @pxref{User-Defined Compositions}.)
|
|
|
|
@menu
|
|
* Creating User Keys::
|
|
* Keyboard Macros::
|
|
* Invocation Macros::
|
|
* Algebraic Definitions::
|
|
* Lisp Definitions::
|
|
@end menu
|
|
|
|
@node Creating User Keys, Keyboard Macros, Programming, Programming
|
|
@section Creating User Keys
|
|
|
|
@noindent
|
|
@kindex Z D
|
|
@pindex calc-user-define
|
|
Any Calculator command may be bound to a key using the @kbd{Z D}
|
|
(@code{calc-user-define}) command. Actually, it is bound to a two-key
|
|
sequence beginning with the lower-case @kbd{z} prefix.
|
|
|
|
The @kbd{Z D} command first prompts for the key to define. For example,
|
|
press @kbd{Z D a} to define the new key sequence @kbd{z a}. You are then
|
|
prompted for the name of the Calculator command that this key should
|
|
run. For example, the @code{calc-sincos} command is not normally
|
|
available on a key. Typing @kbd{Z D s sincos @key{RET}} programs the
|
|
@kbd{z s} key sequence to run @code{calc-sincos}. This definition will remain
|
|
in effect for the rest of this Emacs session, or until you redefine
|
|
@kbd{z s} to be something else.
|
|
|
|
You can actually bind any Emacs command to a @kbd{z} key sequence by
|
|
backspacing over the @samp{calc-} when you are prompted for the command name.
|
|
|
|
As with any other prefix key, you can type @kbd{z ?} to see a list of
|
|
all the two-key sequences you have defined that start with @kbd{z}.
|
|
Initially, no @kbd{z} sequences (except @kbd{z ?} itself) are defined.
|
|
|
|
User keys are typically letters, but may in fact be any key.
|
|
(@key{META}-keys are not permitted, nor are a terminal's special
|
|
function keys which generate multi-character sequences when pressed.)
|
|
You can define different commands on the shifted and unshifted versions
|
|
of a letter if you wish.
|
|
|
|
@kindex Z U
|
|
@pindex calc-user-undefine
|
|
The @kbd{Z U} (@code{calc-user-undefine}) command unbinds a user key.
|
|
For example, the key sequence @kbd{Z U s} will undefine the @code{sincos}
|
|
key we defined above.
|
|
|
|
@kindex Z P
|
|
@pindex calc-user-define-permanent
|
|
@cindex Storing user definitions
|
|
@cindex Permanent user definitions
|
|
@cindex Calc init file, user-defined commands
|
|
The @kbd{Z P} (@code{calc-user-define-permanent}) command makes a key
|
|
binding permanent so that it will remain in effect even in future Emacs
|
|
sessions. (It does this by adding a suitable bit of Lisp code into
|
|
your Calc init file; that is, the file given by the variable
|
|
@code{calc-settings-file}, typically @file{~/.calc.el}.) For example,
|
|
@kbd{Z P s} would register our @code{sincos} command permanently. If
|
|
you later wish to unregister this command you must edit your Calc init
|
|
file by hand. (@xref{General Mode Commands}, for a way to tell Calc to
|
|
use a different file for the Calc init file.)
|
|
|
|
The @kbd{Z P} command also saves the user definition, if any, for the
|
|
command bound to the key. After @kbd{Z F} and @kbd{Z C}, a given user
|
|
key could invoke a command, which in turn calls an algebraic function,
|
|
which might have one or more special display formats. A single @kbd{Z P}
|
|
command will save all of these definitions.
|
|
To save an algebraic function, type @kbd{'} (the apostrophe)
|
|
when prompted for a key, and type the function name. To save a command
|
|
without its key binding, type @kbd{M-x} and enter a function name. (The
|
|
@samp{calc-} prefix will automatically be inserted for you.)
|
|
(If the command you give implies a function, the function will be saved,
|
|
and if the function has any display formats, those will be saved, but
|
|
not the other way around: Saving a function will not save any commands
|
|
or key bindings associated with the function.)
|
|
|
|
@kindex Z E
|
|
@pindex calc-user-define-edit
|
|
@cindex Editing user definitions
|
|
The @kbd{Z E} (@code{calc-user-define-edit}) command edits the definition
|
|
of a user key. This works for keys that have been defined by either
|
|
keyboard macros or formulas; further details are contained in the relevant
|
|
following sections.
|
|
|
|
@node Keyboard Macros, Invocation Macros, Creating User Keys, Programming
|
|
@section Programming with Keyboard Macros
|
|
|
|
@noindent
|
|
@kindex X
|
|
@cindex Programming with keyboard macros
|
|
@cindex Keyboard macros
|
|
The easiest way to ``program'' the Emacs Calculator is to use standard
|
|
keyboard macros. Press @w{@kbd{C-x (}} to begin recording a macro. From
|
|
this point on, keystrokes you type will be saved away as well as
|
|
performing their usual functions. Press @kbd{C-x )} to end recording.
|
|
Press shift-@kbd{X} (or the standard Emacs key sequence @kbd{C-x e}) to
|
|
execute your keyboard macro by replaying the recorded keystrokes.
|
|
@xref{Keyboard Macros, , , emacs, the Emacs Manual}, for further
|
|
information.
|
|
|
|
When you use @kbd{X} to invoke a keyboard macro, the entire macro is
|
|
treated as a single command by the undo and trail features. The stack
|
|
display buffer is not updated during macro execution, but is instead
|
|
fixed up once the macro completes. Thus, commands defined with keyboard
|
|
macros are convenient and efficient. The @kbd{C-x e} command, on the
|
|
other hand, invokes the keyboard macro with no special treatment: Each
|
|
command in the macro will record its own undo information and trail entry,
|
|
and update the stack buffer accordingly. If your macro uses features
|
|
outside of Calc's control to operate on the contents of the Calc stack
|
|
buffer, or if it includes Undo, Redo, or last-arguments commands, you
|
|
must use @kbd{C-x e} to make sure the buffer and undo list are up-to-date
|
|
at all times. You could also consider using @kbd{K} (@code{calc-keep-args})
|
|
instead of @kbd{M-@key{RET}} (@code{calc-last-args}).
|
|
|
|
Calc extends the standard Emacs keyboard macros in several ways.
|
|
Keyboard macros can be used to create user-defined commands. Keyboard
|
|
macros can include conditional and iteration structures, somewhat
|
|
analogous to those provided by a traditional programmable calculator.
|
|
|
|
@menu
|
|
* Naming Keyboard Macros::
|
|
* Conditionals in Macros::
|
|
* Loops in Macros::
|
|
* Local Values in Macros::
|
|
* Queries in Macros::
|
|
@end menu
|
|
|
|
@node Naming Keyboard Macros, Conditionals in Macros, Keyboard Macros, Keyboard Macros
|
|
@subsection Naming Keyboard Macros
|
|
|
|
@noindent
|
|
@kindex Z K
|
|
@pindex calc-user-define-kbd-macro
|
|
Once you have defined a keyboard macro, you can bind it to a @kbd{z}
|
|
key sequence with the @kbd{Z K} (@code{calc-user-define-kbd-macro}) command.
|
|
This command prompts first for a key, then for a command name. For
|
|
example, if you type @kbd{C-x ( n @key{TAB} n @key{TAB} C-x )} you will
|
|
define a keyboard macro which negates the top two numbers on the stack
|
|
(@key{TAB} swaps the top two stack elements). Now you can type
|
|
@kbd{Z K n @key{RET}} to define this keyboard macro onto the @kbd{z n} key
|
|
sequence. The default command name (if you answer the second prompt with
|
|
just the @key{RET} key as in this example) will be something like
|
|
@samp{calc-User-n}. The keyboard macro will now be available as both
|
|
@kbd{z n} and @kbd{M-x calc-User-n}. You can backspace and enter a more
|
|
descriptive command name if you wish.
|
|
|
|
Macros defined by @kbd{Z K} act like single commands; they are executed
|
|
in the same way as by the @kbd{X} key. If you wish to define the macro
|
|
as a standard no-frills Emacs macro (to be executed as if by @kbd{C-x e}),
|
|
give a negative prefix argument to @kbd{Z K}.
|
|
|
|
Once you have bound your keyboard macro to a key, you can use
|
|
@kbd{Z P} to register it permanently with Emacs. @xref{Creating User Keys}.
|
|
|
|
@cindex Keyboard macros, editing
|
|
The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
|
|
been defined by a keyboard macro tries to use the @code{edmacro} package
|
|
edit the macro. Type @kbd{C-c C-c} to finish editing and update
|
|
the definition stored on the key, or, to cancel the edit, kill the
|
|
buffer with @kbd{C-x k}.
|
|
The special characters @code{RET}, @code{LFD}, @code{TAB}, @code{SPC},
|
|
@code{DEL}, and @code{NUL} must be entered as these three character
|
|
sequences, written in all uppercase, as must the prefixes @code{C-} and
|
|
@code{M-}. Spaces and line breaks are ignored. Other characters are
|
|
copied verbatim into the keyboard macro. Basically, the notation is the
|
|
same as is used in all of this manual's examples, except that the manual
|
|
takes some liberties with spaces: When we say @kbd{' [1 2 3] @key{RET}},
|
|
we take it for granted that it is clear we really mean
|
|
@kbd{' [1 @key{SPC} 2 @key{SPC} 3] @key{RET}}.
|
|
|
|
@kindex C-x * m
|
|
@pindex read-kbd-macro
|
|
The @kbd{C-x * m} (@code{read-kbd-macro}) command reads an Emacs ``region''
|
|
of spelled-out keystrokes and defines it as the current keyboard macro.
|
|
It is a convenient way to define a keyboard macro that has been stored
|
|
in a file, or to define a macro without executing it at the same time.
|
|
|
|
@node Conditionals in Macros, Loops in Macros, Naming Keyboard Macros, Keyboard Macros
|
|
@subsection Conditionals in Keyboard Macros
|
|
|
|
@noindent
|
|
@kindex Z [
|
|
@kindex Z ]
|
|
@pindex calc-kbd-if
|
|
@pindex calc-kbd-else
|
|
@pindex calc-kbd-else-if
|
|
@pindex calc-kbd-end-if
|
|
@cindex Conditional structures
|
|
The @kbd{Z [} (@code{calc-kbd-if}) and @kbd{Z ]} (@code{calc-kbd-end-if})
|
|
commands allow you to put simple tests in a keyboard macro. When Calc
|
|
sees the @kbd{Z [}, it pops an object from the stack and, if the object is
|
|
a non-zero value, continues executing keystrokes. But if the object is
|
|
zero, or if it is not provably nonzero, Calc skips ahead to the matching
|
|
@kbd{Z ]} keystroke. @xref{Logical Operations}, for a set of commands for
|
|
performing tests which conveniently produce 1 for true and 0 for false.
|
|
|
|
For example, @kbd{@key{RET} 0 a < Z [ n Z ]} implements an absolute-value
|
|
function in the form of a keyboard macro. This macro duplicates the
|
|
number on the top of the stack, pushes zero and compares using @kbd{a <}
|
|
(@code{calc-less-than}), then, if the number was less than zero,
|
|
executes @kbd{n} (@code{calc-change-sign}). Otherwise, the change-sign
|
|
command is skipped.
|
|
|
|
To program this macro, type @kbd{C-x (}, type the above sequence of
|
|
keystrokes, then type @kbd{C-x )}. Note that the keystrokes will be
|
|
executed while you are making the definition as well as when you later
|
|
re-execute the macro by typing @kbd{X}. Thus you should make sure a
|
|
suitable number is on the stack before defining the macro so that you
|
|
don't get a stack-underflow error during the definition process.
|
|
|
|
Conditionals can be nested arbitrarily. However, there should be exactly
|
|
one @kbd{Z ]} for each @kbd{Z [} in a keyboard macro.
|
|
|
|
@kindex Z :
|
|
The @kbd{Z :} (@code{calc-kbd-else}) command allows you to choose between
|
|
two keystroke sequences. The general format is @kbd{@var{cond} Z [
|
|
@var{then-part} Z : @var{else-part} Z ]}. If @var{cond} is true
|
|
(i.e., if the top of stack contains a non-zero number after @var{cond}
|
|
has been executed), the @var{then-part} will be executed and the
|
|
@var{else-part} will be skipped. Otherwise, the @var{then-part} will
|
|
be skipped and the @var{else-part} will be executed.
|
|
|
|
@kindex Z |
|
|
The @kbd{Z |} (@code{calc-kbd-else-if}) command allows you to choose
|
|
between any number of alternatives. For example,
|
|
@kbd{@var{cond1} Z [ @var{part1} Z : @var{cond2} Z | @var{part2} Z :
|
|
@var{part3} Z ]} will execute @var{part1} if @var{cond1} is true,
|
|
otherwise it will execute @var{part2} if @var{cond2} is true, otherwise
|
|
it will execute @var{part3}.
|
|
|
|
More precisely, @kbd{Z [} pops a number and conditionally skips to the
|
|
next matching @kbd{Z :} or @kbd{Z ]} key. @w{@kbd{Z ]}} has no effect when
|
|
actually executed. @kbd{Z :} skips to the next matching @kbd{Z ]}.
|
|
@kbd{Z |} pops a number and conditionally skips to the next matching
|
|
@kbd{Z :} or @kbd{Z ]}; thus, @kbd{Z [} and @kbd{Z |} are functionally
|
|
equivalent except that @kbd{Z [} participates in nesting but @kbd{Z |}
|
|
does not.
|
|
|
|
Calc's conditional and looping constructs work by scanning the
|
|
keyboard macro for occurrences of character sequences like @samp{Z:}
|
|
and @samp{Z]}. One side-effect of this is that if you use these
|
|
constructs you must be careful that these character pairs do not
|
|
occur by accident in other parts of the macros. Since Calc rarely
|
|
uses shift-@kbd{Z} for any purpose except as a prefix character, this
|
|
is not likely to be a problem. Another side-effect is that it will
|
|
not work to define your own custom key bindings for these commands.
|
|
Only the standard shift-@kbd{Z} bindings will work correctly.
|
|
|
|
@kindex Z C-g
|
|
If Calc gets stuck while skipping characters during the definition of a
|
|
macro, type @kbd{Z C-g} to cancel the definition. (Typing plain @kbd{C-g}
|
|
actually adds a @kbd{C-g} keystroke to the macro.)
|
|
|
|
@node Loops in Macros, Local Values in Macros, Conditionals in Macros, Keyboard Macros
|
|
@subsection Loops in Keyboard Macros
|
|
|
|
@noindent
|
|
@kindex Z <
|
|
@kindex Z >
|
|
@pindex calc-kbd-repeat
|
|
@pindex calc-kbd-end-repeat
|
|
@cindex Looping structures
|
|
@cindex Iterative structures
|
|
The @kbd{Z <} (@code{calc-kbd-repeat}) and @kbd{Z >}
|
|
(@code{calc-kbd-end-repeat}) commands pop a number from the stack,
|
|
which must be an integer, then repeat the keystrokes between the brackets
|
|
the specified number of times. If the integer is zero or negative, the
|
|
body is skipped altogether. For example, @kbd{1 @key{TAB} Z < 2 * Z >}
|
|
computes two to a nonnegative integer power. First, we push 1 on the
|
|
stack and then swap the integer argument back to the top. The @kbd{Z <}
|
|
pops that argument leaving the 1 back on top of the stack. Then, we
|
|
repeat a multiply-by-two step however many times.
|
|
|
|
Once again, the keyboard macro is executed as it is being entered.
|
|
In this case it is especially important to set up reasonable initial
|
|
conditions before making the definition: Suppose the integer 1000 just
|
|
happened to be sitting on the stack before we typed the above definition!
|
|
Another approach is to enter a harmless dummy definition for the macro,
|
|
then go back and edit in the real one with a @kbd{Z E} command. Yet
|
|
another approach is to type the macro as written-out keystroke names
|
|
in a buffer, then use @kbd{C-x * m} (@code{read-kbd-macro}) to read the
|
|
macro.
|
|
|
|
@kindex Z /
|
|
@pindex calc-break
|
|
The @kbd{Z /} (@code{calc-kbd-break}) command allows you to break out
|
|
of a keyboard macro loop prematurely. It pops an object from the stack;
|
|
if that object is true (a non-zero number), control jumps out of the
|
|
innermost enclosing @kbd{Z <} @dots{} @kbd{Z >} loop and continues
|
|
after the @kbd{Z >}. If the object is false, the @kbd{Z /} has no
|
|
effect. Thus @kbd{@var{cond} Z /} is similar to @samp{if (@var{cond}) break;}
|
|
in the C language.
|
|
|
|
@kindex Z (
|
|
@kindex Z )
|
|
@pindex calc-kbd-for
|
|
@pindex calc-kbd-end-for
|
|
The @kbd{Z (} (@code{calc-kbd-for}) and @kbd{Z )} (@code{calc-kbd-end-for})
|
|
commands are similar to @kbd{Z <} and @kbd{Z >}, except that they make the
|
|
value of the counter available inside the loop. The general layout is
|
|
@kbd{@var{init} @var{final} Z ( @var{body} @var{step} Z )}. The @kbd{Z (}
|
|
command pops initial and final values from the stack. It then creates
|
|
a temporary internal counter and initializes it with the value @var{init}.
|
|
The @kbd{Z (} command then repeatedly pushes the counter value onto the
|
|
stack and executes @var{body} and @var{step}, adding @var{step} to the
|
|
counter each time until the loop finishes.
|
|
|
|
@cindex Summations (by keyboard macros)
|
|
By default, the loop finishes when the counter becomes greater than (or
|
|
less than) @var{final}, assuming @var{initial} is less than (greater
|
|
than) @var{final}. If @var{initial} is equal to @var{final}, the body
|
|
executes exactly once. The body of the loop always executes at least
|
|
once. For example, @kbd{0 1 10 Z ( 2 ^ + 1 Z )} computes the sum of the
|
|
squares of the integers from 1 to 10, in steps of 1.
|
|
|
|
If you give a numeric prefix argument of 1 to @kbd{Z (}, the loop is
|
|
forced to use upward-counting conventions. In this case, if @var{initial}
|
|
is greater than @var{final} the body will not be executed at all.
|
|
Note that @var{step} may still be negative in this loop; the prefix
|
|
argument merely constrains the loop-finished test. Likewise, a prefix
|
|
argument of @mathit{-1} forces downward-counting conventions.
|
|
|
|
@kindex Z @{
|
|
@kindex Z @}
|
|
@pindex calc-kbd-loop
|
|
@pindex calc-kbd-end-loop
|
|
The @kbd{Z @{} (@code{calc-kbd-loop}) and @kbd{Z @}}
|
|
(@code{calc-kbd-end-loop}) commands are similar to @kbd{Z <} and
|
|
@kbd{Z >}, except that they do not pop a count from the stack---they
|
|
effectively create an infinite loop. Every @kbd{Z @{} @dots{} @kbd{Z @}}
|
|
loop ought to include at least one @kbd{Z /} to make sure the loop
|
|
doesn't run forever. (If any error message occurs which causes Emacs
|
|
to beep, the keyboard macro will also be halted; this is a standard
|
|
feature of Emacs. You can also generally press @kbd{C-g} to halt a
|
|
running keyboard macro, although not all versions of Unix support
|
|
this feature.)
|
|
|
|
The conditional and looping constructs are not actually tied to
|
|
keyboard macros, but they are most often used in that context.
|
|
For example, the keystrokes @kbd{10 Z < 23 @key{RET} Z >} push
|
|
ten copies of 23 onto the stack. This can be typed ``live'' just
|
|
as easily as in a macro definition.
|
|
|
|
@xref{Conditionals in Macros}, for some additional notes about
|
|
conditional and looping commands.
|
|
|
|
@node Local Values in Macros, Queries in Macros, Loops in Macros, Keyboard Macros
|
|
@subsection Local Values in Macros
|
|
|
|
@noindent
|
|
@cindex Local variables
|
|
@cindex Restoring saved modes
|
|
Keyboard macros sometimes want to operate under known conditions
|
|
without affecting surrounding conditions. For example, a keyboard
|
|
macro may wish to turn on Fraction mode, or set a particular
|
|
precision, independent of the user's normal setting for those
|
|
modes.
|
|
|
|
@kindex Z `
|
|
@kindex Z '
|
|
@pindex calc-kbd-push
|
|
@pindex calc-kbd-pop
|
|
Macros also sometimes need to use local variables. Assignments to
|
|
local variables inside the macro should not affect any variables
|
|
outside the macro. The @kbd{Z `} (@code{calc-kbd-push}) and @kbd{Z '}
|
|
(@code{calc-kbd-pop}) commands give you both of these capabilities.
|
|
|
|
When you type @kbd{Z `} (with a backquote or accent grave character),
|
|
the values of various mode settings are saved away. The ten ``quick''
|
|
variables @code{q0} through @code{q9} are also saved. When
|
|
you type @w{@kbd{Z '}} (with an apostrophe), these values are restored.
|
|
Pairs of @kbd{Z `} and @kbd{Z '} commands may be nested.
|
|
|
|
If a keyboard macro halts due to an error in between a @kbd{Z `} and
|
|
a @kbd{Z '}, the saved values will be restored correctly even though
|
|
the macro never reaches the @kbd{Z '} command. Thus you can use
|
|
@kbd{Z `} and @kbd{Z '} without having to worry about what happens
|
|
in exceptional conditions.
|
|
|
|
If you type @kbd{Z `} ``live'' (not in a keyboard macro), Calc puts
|
|
you into a ``recursive edit.'' You can tell you are in a recursive
|
|
edit because there will be extra square brackets in the mode line,
|
|
as in @samp{[(Calculator)]}. These brackets will go away when you
|
|
type the matching @kbd{Z '} command. The modes and quick variables
|
|
will be saved and restored in just the same way as if actual keyboard
|
|
macros were involved.
|
|
|
|
The modes saved by @kbd{Z `} and @kbd{Z '} are the current precision
|
|
and binary word size, the angular mode (Deg, Rad, or HMS), the
|
|
simplification mode, Algebraic mode, Symbolic mode, Infinite mode,
|
|
Matrix or Scalar mode, Fraction mode, and the current complex mode
|
|
(Polar or Rectangular). The ten ``quick'' variables' values (or lack
|
|
thereof) are also saved.
|
|
|
|
Most mode-setting commands act as toggles, but with a numeric prefix
|
|
they force the mode either on (positive prefix) or off (negative
|
|
or zero prefix). Since you don't know what the environment might
|
|
be when you invoke your macro, it's best to use prefix arguments
|
|
for all mode-setting commands inside the macro.
|
|
|
|
In fact, @kbd{C-u Z `} is like @kbd{Z `} except that it sets the modes
|
|
listed above to their default values. As usual, the matching @kbd{Z '}
|
|
will restore the modes to their settings from before the @kbd{C-u Z `}.
|
|
Also, @w{@kbd{Z `}} with a negative prefix argument resets the algebraic mode
|
|
to its default (off) but leaves the other modes the same as they were
|
|
outside the construct.
|
|
|
|
The contents of the stack and trail, values of non-quick variables, and
|
|
other settings such as the language mode and the various display modes,
|
|
are @emph{not} affected by @kbd{Z `} and @kbd{Z '}.
|
|
|
|
@node Queries in Macros, , Local Values in Macros, Keyboard Macros
|
|
@subsection Queries in Keyboard Macros
|
|
|
|
@c @noindent
|
|
@c @kindex Z =
|
|
@c @pindex calc-kbd-report
|
|
@c The @kbd{Z =} (@code{calc-kbd-report}) command displays an informative
|
|
@c message including the value on the top of the stack. You are prompted
|
|
@c to enter a string. That string, along with the top-of-stack value,
|
|
@c is displayed unless @kbd{m w} (@code{calc-working}) has been used
|
|
@c to turn such messages off.
|
|
|
|
@noindent
|
|
@kindex Z #
|
|
@pindex calc-kbd-query
|
|
The @kbd{Z #} (@code{calc-kbd-query}) command prompts for an algebraic
|
|
entry which takes its input from the keyboard, even during macro
|
|
execution. All the normal conventions of algebraic input, including the
|
|
use of @kbd{$} characters, are supported. The prompt message itself is
|
|
taken from the top of the stack, and so must be entered (as a string)
|
|
before the @kbd{Z #} command. (Recall, as a string it can be entered by
|
|
pressing the @kbd{"} key and will appear as a vector when it is put on
|
|
the stack. The prompt message is only put on the stack to provide a
|
|
prompt for the @kbd{Z #} command; it will not play any role in any
|
|
subsequent calculations.) This command allows your keyboard macros to
|
|
accept numbers or formulas as interactive input.
|
|
|
|
As an example,
|
|
@kbd{2 @key{RET} "Power: " @key{RET} Z # 3 @key{RET} ^} will prompt for
|
|
input with ``Power: '' in the minibuffer, then return 2 to the provided
|
|
power. (The response to the prompt that's given, 3 in this example,
|
|
will not be part of the macro.)
|
|
|
|
@xref{Keyboard Macro Query, , , emacs, the Emacs Manual}, for a description of
|
|
@kbd{C-x q} (@code{kbd-macro-query}), the standard Emacs way to accept
|
|
keyboard input during a keyboard macro. In particular, you can use
|
|
@kbd{C-x q} to enter a recursive edit, which allows the user to perform
|
|
any Calculator operations interactively before pressing @kbd{C-M-c} to
|
|
return control to the keyboard macro.
|
|
|
|
@node Invocation Macros, Algebraic Definitions, Keyboard Macros, Programming
|
|
@section Invocation Macros
|
|
|
|
@kindex C-x * z
|
|
@kindex Z I
|
|
@pindex calc-user-invocation
|
|
@pindex calc-user-define-invocation
|
|
Calc provides one special keyboard macro, called up by @kbd{C-x * z}
|
|
(@code{calc-user-invocation}), that is intended to allow you to define
|
|
your own special way of starting Calc. To define this ``invocation
|
|
macro,'' create the macro in the usual way with @kbd{C-x (} and
|
|
@kbd{C-x )}, then type @kbd{Z I} (@code{calc-user-define-invocation}).
|
|
There is only one invocation macro, so you don't need to type any
|
|
additional letters after @kbd{Z I}. From now on, you can type
|
|
@kbd{C-x * z} at any time to execute your invocation macro.
|
|
|
|
For example, suppose you find yourself often grabbing rectangles of
|
|
numbers into Calc and multiplying their columns. You can do this
|
|
by typing @kbd{C-x * r} to grab, and @kbd{V R : *} to multiply columns.
|
|
To make this into an invocation macro, just type @kbd{C-x ( C-x * r
|
|
V R : * C-x )}, then @kbd{Z I}. Then, to multiply a rectangle of data,
|
|
just mark the data in its buffer in the usual way and type @kbd{C-x * z}.
|
|
|
|
Invocation macros are treated like regular Emacs keyboard macros;
|
|
all the special features described above for @kbd{Z K}-style macros
|
|
do not apply. @kbd{C-x * z} is just like @kbd{C-x e}, except that it
|
|
uses the macro that was last stored by @kbd{Z I}. (In fact, the
|
|
macro does not even have to have anything to do with Calc!)
|
|
|
|
The @kbd{m m} command saves the last invocation macro defined by
|
|
@kbd{Z I} along with all the other Calc mode settings.
|
|
@xref{General Mode Commands}.
|
|
|
|
@node Algebraic Definitions, Lisp Definitions, Invocation Macros, Programming
|
|
@section Programming with Formulas
|
|
|
|
@noindent
|
|
@kindex Z F
|
|
@pindex calc-user-define-formula
|
|
@cindex Programming with algebraic formulas
|
|
Another way to create a new Calculator command uses algebraic formulas.
|
|
The @kbd{Z F} (@code{calc-user-define-formula}) command stores the
|
|
formula at the top of the stack as the definition for a key. This
|
|
command prompts for five things: The key, the command name, the function
|
|
name, the argument list, and the behavior of the command when given
|
|
non-numeric arguments.
|
|
|
|
For example, suppose we type @kbd{' a+2b @key{RET}} to push the formula
|
|
@samp{a + 2*b} onto the stack. We now type @kbd{Z F m} to define this
|
|
formula on the @kbd{z m} key sequence. The next prompt is for a command
|
|
name, beginning with @samp{calc-}, which should be the long (@kbd{M-x}) form
|
|
for the new command. If you simply press @key{RET}, a default name like
|
|
@code{calc-User-m} will be constructed. In our example, suppose we enter
|
|
@kbd{spam @key{RET}} to define the new command as @code{calc-spam}.
|
|
|
|
If you want to give the formula a long-style name only, you can press
|
|
@key{SPC} or @key{RET} when asked which single key to use. For example
|
|
@kbd{Z F @key{RET} spam @key{RET}} defines the new command as
|
|
@kbd{M-x calc-spam}, with no keyboard equivalent.
|
|
|
|
The third prompt is for an algebraic function name. The default is to
|
|
use the same name as the command name but without the @samp{calc-}
|
|
prefix. (If this is of the form @samp{User-m}, the hyphen is removed so
|
|
it won't be taken for a minus sign in algebraic formulas.)
|
|
This is the name you will use if you want to enter your
|
|
new function in an algebraic formula. Suppose we enter @kbd{yow @key{RET}}.
|
|
Then the new function can be invoked by pushing two numbers on the
|
|
stack and typing @kbd{z m} or @kbd{x spam}, or by entering the algebraic
|
|
formula @samp{yow(x,y)}.
|
|
|
|
The fourth prompt is for the function's argument list. This is used to
|
|
associate values on the stack with the variables that appear in the formula.
|
|
The default is a list of all variables which appear in the formula, sorted
|
|
into alphabetical order. In our case, the default would be @samp{(a b)}.
|
|
This means that, when the user types @kbd{z m}, the Calculator will remove
|
|
two numbers from the stack, substitute these numbers for @samp{a} and
|
|
@samp{b} (respectively) in the formula, then simplify the formula and
|
|
push the result on the stack. In other words, @kbd{10 @key{RET} 100 z m}
|
|
would replace the 10 and 100 on the stack with the number 210, which is
|
|
@expr{a + 2 b} with @expr{a=10} and @expr{b=100}. Likewise, the formula
|
|
@samp{yow(10, 100)} will be evaluated by substituting @expr{a=10} and
|
|
@expr{b=100} in the definition.
|
|
|
|
You can rearrange the order of the names before pressing @key{RET} to
|
|
control which stack positions go to which variables in the formula. If
|
|
you remove a variable from the argument list, that variable will be left
|
|
in symbolic form by the command. Thus using an argument list of @samp{(b)}
|
|
for our function would cause @kbd{10 z m} to replace the 10 on the stack
|
|
with the formula @samp{a + 20}. If we had used an argument list of
|
|
@samp{(b a)}, the result with inputs 10 and 100 would have been 120.
|
|
|
|
You can also put a nameless function on the stack instead of just a
|
|
formula, as in @samp{<a, b : a + 2 b>}. @xref{Specifying Operators}.
|
|
In this example, the command will be defined by the formula @samp{a + 2 b}
|
|
using the argument list @samp{(a b)}.
|
|
|
|
The final prompt is a y-or-n question concerning what to do if symbolic
|
|
arguments are given to your function. If you answer @kbd{y}, then
|
|
executing @kbd{z m} (using the original argument list @samp{(a b)}) with
|
|
arguments @expr{10} and @expr{x} will leave the function in symbolic
|
|
form, i.e., @samp{yow(10,x)}. On the other hand, if you answer @kbd{n},
|
|
then the formula will always be expanded, even for non-constant
|
|
arguments: @samp{10 + 2 x}. If you never plan to feed algebraic
|
|
formulas to your new function, it doesn't matter how you answer this
|
|
question.
|
|
|
|
If you answered @kbd{y} to this question you can still cause a function
|
|
call to be expanded by typing @kbd{a "} (@code{calc-expand-formula}).
|
|
Also, Calc will expand the function if necessary when you take a
|
|
derivative or integral or solve an equation involving the function.
|
|
|
|
@kindex Z G
|
|
@pindex calc-get-user-defn
|
|
Once you have defined a formula on a key, you can retrieve this formula
|
|
with the @kbd{Z G} (@code{calc-user-define-get-defn}) command. Press a
|
|
key, and this command pushes the formula that was used to define that
|
|
key onto the stack. Actually, it pushes a nameless function that
|
|
specifies both the argument list and the defining formula. You will get
|
|
an error message if the key is undefined, or if the key was not defined
|
|
by a @kbd{Z F} command.
|
|
|
|
The @kbd{Z E} (@code{calc-user-define-edit}) command on a key that has
|
|
been defined by a formula uses a variant of the @code{calc-edit} command
|
|
to edit the defining formula. Press @kbd{C-c C-c} to finish editing and
|
|
store the new formula back in the definition, or kill the buffer with
|
|
@kbd{C-x k} to
|
|
cancel the edit. (The argument list and other properties of the
|
|
definition are unchanged; to adjust the argument list, you can use
|
|
@kbd{Z G} to grab the function onto the stack, edit with @kbd{`}, and
|
|
then re-execute the @kbd{Z F} command.)
|
|
|
|
As usual, the @kbd{Z P} command records your definition permanently.
|
|
In this case it will permanently record all three of the relevant
|
|
definitions: the key, the command, and the function.
|
|
|
|
You may find it useful to turn off the default simplifications with
|
|
@kbd{m O} (@code{calc-no-simplify-mode}) when entering a formula to be
|
|
used as a function definition. For example, the formula @samp{deriv(a^2,v)}
|
|
which might be used to define a new function @samp{dsqr(a,v)} will be
|
|
``simplified'' to 0 immediately upon entry since @code{deriv} considers
|
|
@expr{a} to be constant with respect to @expr{v}. Turning off
|
|
default simplifications cures this problem: The definition will be stored
|
|
in symbolic form without ever activating the @code{deriv} function. Press
|
|
@kbd{m D} to turn the default simplifications back on afterwards.
|
|
|
|
@node Lisp Definitions, , Algebraic Definitions, Programming
|
|
@section Programming with Lisp
|
|
|
|
@noindent
|
|
The Calculator can be programmed quite extensively in Lisp. All you
|
|
do is write a normal Lisp function definition, but with @code{defmath}
|
|
in place of @code{defun}. This has the same form as @code{defun}, but it
|
|
automagically replaces calls to standard Lisp functions like @code{+} and
|
|
@code{zerop} with calls to the corresponding functions in Calc's own library.
|
|
Thus you can write natural-looking Lisp code which operates on all of the
|
|
standard Calculator data types. You can then use @kbd{Z D} if you wish to
|
|
bind your new command to a @kbd{z}-prefix key sequence. The @kbd{Z E} command
|
|
will not edit a Lisp-based definition.
|
|
|
|
Emacs Lisp is described in the GNU Emacs Lisp Reference Manual. This section
|
|
assumes a familiarity with Lisp programming concepts; if you do not know
|
|
Lisp, you may find keyboard macros or rewrite rules to be an easier way
|
|
to program the Calculator.
|
|
|
|
This section first discusses ways to write commands, functions, or
|
|
small programs to be executed inside of Calc. Then it discusses how
|
|
your own separate programs are able to call Calc from the outside.
|
|
Finally, there is a list of internal Calc functions and data structures
|
|
for the true Lisp enthusiast.
|
|
|
|
@menu
|
|
* Defining Functions::
|
|
* Defining Simple Commands::
|
|
* Defining Stack Commands::
|
|
* Argument Qualifiers::
|
|
* Example Definitions::
|
|
|
|
* Calling Calc from Your Programs::
|
|
* Internals::
|
|
@end menu
|
|
|
|
@node Defining Functions, Defining Simple Commands, Lisp Definitions, Lisp Definitions
|
|
@subsection Defining New Functions
|
|
|
|
@noindent
|
|
@findex defmath
|
|
The @code{defmath} function (actually a Lisp macro) is like @code{defun}
|
|
except that code in the body of the definition can make use of the full
|
|
range of Calculator data types. The prefix @samp{calcFunc-} is added
|
|
to the specified name to get the actual Lisp function name. As a simple
|
|
example,
|
|
|
|
@example
|
|
(defmath myfact (n)
|
|
(if (> n 0)
|
|
(* n (myfact (1- n)))
|
|
1))
|
|
@end example
|
|
|
|
@noindent
|
|
This actually expands to the code,
|
|
|
|
@example
|
|
(defun calcFunc-myfact (n)
|
|
(if (math-posp n)
|
|
(math-mul n (calcFunc-myfact (math-add n -1)))
|
|
1))
|
|
@end example
|
|
|
|
@noindent
|
|
This function can be used in algebraic expressions, e.g., @samp{myfact(5)}.
|
|
|
|
The @samp{myfact} function as it is defined above has the bug that an
|
|
expression @samp{myfact(a+b)} will be simplified to 1 because the
|
|
formula @samp{a+b} is not considered to be @code{posp}. A robust
|
|
factorial function would be written along the following lines:
|
|
|
|
@smallexample
|
|
(defmath myfact (n)
|
|
(if (> n 0)
|
|
(* n (myfact (1- n)))
|
|
(if (= n 0)
|
|
1
|
|
nil))) ; this could be simplified as: (and (= n 0) 1)
|
|
@end smallexample
|
|
|
|
If a function returns @code{nil}, it is left unsimplified by the Calculator
|
|
(except that its arguments will be simplified). Thus, @samp{myfact(a+1+2)}
|
|
will be simplified to @samp{myfact(a+3)} but no further. Beware that every
|
|
time the Calculator reexamines this formula it will attempt to resimplify
|
|
it, so your function ought to detect the returning-@code{nil} case as
|
|
efficiently as possible.
|
|
|
|
The following standard Lisp functions are treated by @code{defmath}:
|
|
@code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^} or
|
|
@code{expt}, @code{=}, @code{<}, @code{>}, @code{<=}, @code{>=},
|
|
@code{/=}, @code{1+}, @code{1-}, @code{logand}, @code{logior}, @code{logxor},
|
|
@code{logandc2}, @code{lognot}. Also, @code{~=} is an abbreviation for
|
|
@code{math-nearly-equal}, which is useful in implementing Taylor series.
|
|
|
|
For other functions @var{func}, if a function by the name
|
|
@samp{calcFunc-@var{func}} exists it is used, otherwise if a function by the
|
|
name @samp{math-@var{func}} exists it is used, otherwise if @var{func} itself
|
|
is defined as a function it is used, otherwise @samp{calcFunc-@var{func}} is
|
|
used on the assumption that this is a to-be-defined math function. Also, if
|
|
the function name is quoted as in @samp{('integerp a)} the function name is
|
|
always used exactly as written (but not quoted).
|
|
|
|
Variable names have @samp{var-} prepended to them unless they appear in
|
|
the function's argument list or in an enclosing @code{let}, @code{let*},
|
|
@code{for}, or @code{foreach} form,
|
|
or their names already contain a @samp{-} character. Thus a reference to
|
|
@samp{foo} is the same as a reference to @samp{var-foo}.
|
|
|
|
A few other Lisp extensions are available in @code{defmath} definitions:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
The @code{elt} function accepts any number of index variables.
|
|
Note that Calc vectors are stored as Lisp lists whose first
|
|
element is the symbol @code{vec}; thus, @samp{(elt v 2)} yields
|
|
the second element of vector @code{v}, and @samp{(elt m i j)}
|
|
yields one element of a Calc matrix.
|
|
|
|
@item
|
|
The @code{setq} function has been extended to act like the Common
|
|
Lisp @code{setf} function. (The name @code{setf} is recognized as
|
|
a synonym of @code{setq}.) Specifically, the first argument of
|
|
@code{setq} can be an @code{nth}, @code{elt}, @code{car}, or @code{cdr} form,
|
|
in which case the effect is to store into the specified
|
|
element of a list. Thus, @samp{(setq (elt m i j) x)} stores @expr{x}
|
|
into one element of a matrix.
|
|
|
|
@item
|
|
A @code{for} looping construct is available. For example,
|
|
@samp{(for ((i 0 10)) body)} executes @code{body} once for each
|
|
binding of @expr{i} from zero to 10. This is like a @code{let}
|
|
form in that @expr{i} is temporarily bound to the loop count
|
|
without disturbing its value outside the @code{for} construct.
|
|
Nested loops, as in @samp{(for ((i 0 10) (j 0 (1- i) 2)) body)},
|
|
are also available. For each value of @expr{i} from zero to 10,
|
|
@expr{j} counts from 0 to @expr{i-1} in steps of two. Note that
|
|
@code{for} has the same general outline as @code{let*}, except
|
|
that each element of the header is a list of three or four
|
|
things, not just two.
|
|
|
|
@item
|
|
The @code{foreach} construct loops over elements of a list.
|
|
For example, @samp{(foreach ((x (cdr v))) body)} executes
|
|
@code{body} with @expr{x} bound to each element of Calc vector
|
|
@expr{v} in turn. The purpose of @code{cdr} here is to skip over
|
|
the initial @code{vec} symbol in the vector.
|
|
|
|
@item
|
|
The @code{break} function breaks out of the innermost enclosing
|
|
@code{while}, @code{for}, or @code{foreach} loop. If given a
|
|
value, as in @samp{(break x)}, this value is returned by the
|
|
loop. (Lisp loops otherwise always return @code{nil}.)
|
|
|
|
@item
|
|
The @code{return} function prematurely returns from the enclosing
|
|
function. For example, @samp{(return (+ x y))} returns @expr{x+y}
|
|
as the value of a function. You can use @code{return} anywhere
|
|
inside the body of the function.
|
|
@end itemize
|
|
|
|
Non-integer numbers (and extremely large integers) cannot be included
|
|
directly into a @code{defmath} definition. This is because the Lisp
|
|
reader will fail to parse them long before @code{defmath} ever gets control.
|
|
Instead, use the notation, @samp{:"3.1415"}. In fact, any algebraic
|
|
formula can go between the quotes. For example,
|
|
|
|
@smallexample
|
|
(defmath sqexp (x) ; sqexp(x) == sqrt(exp(x)) == exp(x*0.5)
|
|
(and (numberp x)
|
|
(exp :"x * 0.5")))
|
|
@end smallexample
|
|
|
|
expands to
|
|
|
|
@smallexample
|
|
(defun calcFunc-sqexp (x)
|
|
(and (math-numberp x)
|
|
(calcFunc-exp (math-mul x '(float 5 -1)))))
|
|
@end smallexample
|
|
|
|
Note the use of @code{numberp} as a guard to ensure that the argument is
|
|
a number first, returning @code{nil} if not. The exponential function
|
|
could itself have been included in the expression, if we had preferred:
|
|
@samp{:"exp(x * 0.5)"}. As another example, the multiplication-and-recursion
|
|
step of @code{myfact} could have been written
|
|
|
|
@example
|
|
:"n * myfact(n-1)"
|
|
@end example
|
|
|
|
A good place to put your @code{defmath} commands is your Calc init file
|
|
(the file given by @code{calc-settings-file}, typically
|
|
@file{~/.calc.el}), which will not be loaded until Calc starts.
|
|
If a file named @file{.emacs} exists in your home directory, Emacs reads
|
|
and executes the Lisp forms in this file as it starts up. While it may
|
|
seem reasonable to put your favorite @code{defmath} commands there,
|
|
this has the unfortunate side-effect that parts of the Calculator must be
|
|
loaded in to process the @code{defmath} commands whether or not you will
|
|
actually use the Calculator! If you want to put the @code{defmath}
|
|
commands there (for example, if you redefine @code{calc-settings-file}
|
|
to be @file{.emacs}), a better effect can be had by writing
|
|
|
|
@example
|
|
(put 'calc-define 'thing '(progn
|
|
(defmath ... )
|
|
(defmath ... )
|
|
))
|
|
@end example
|
|
|
|
@noindent
|
|
@vindex calc-define
|
|
The @code{put} function adds a @dfn{property} to a symbol. Each Lisp
|
|
symbol has a list of properties associated with it. Here we add a
|
|
property with a name of @code{thing} and a @samp{(progn ...)} form as
|
|
its value. When Calc starts up, and at the start of every Calc command,
|
|
the property list for the symbol @code{calc-define} is checked and the
|
|
values of any properties found are evaluated as Lisp forms. The
|
|
properties are removed as they are evaluated. The property names
|
|
(like @code{thing}) are not used; you should choose something like the
|
|
name of your project so as not to conflict with other properties.
|
|
|
|
The net effect is that you can put the above code in your @file{.emacs}
|
|
file and it will not be executed until Calc is loaded. Or, you can put
|
|
that same code in another file which you load by hand either before or
|
|
after Calc itself is loaded.
|
|
|
|
The properties of @code{calc-define} are evaluated in the same order
|
|
that they were added. They can assume that the Calc modules @file{calc.el},
|
|
@file{calc-ext.el}, and @file{calc-macs.el} have been fully loaded, and
|
|
that the @samp{*Calculator*} buffer will be the current buffer.
|
|
|
|
If your @code{calc-define} property only defines algebraic functions,
|
|
you can be sure that it will have been evaluated before Calc tries to
|
|
call your function, even if the file defining the property is loaded
|
|
after Calc is loaded. But if the property defines commands or key
|
|
sequences, it may not be evaluated soon enough. (Suppose it defines the
|
|
new command @code{tweak-calc}; the user can load your file, then type
|
|
@kbd{M-x tweak-calc} before Calc has had chance to do anything.) To
|
|
protect against this situation, you can put
|
|
|
|
@example
|
|
(run-hooks 'calc-check-defines)
|
|
@end example
|
|
|
|
@findex calc-check-defines
|
|
@noindent
|
|
at the end of your file. The @code{calc-check-defines} function is what
|
|
looks for and evaluates properties on @code{calc-define}; @code{run-hooks}
|
|
has the advantage that it is quietly ignored if @code{calc-check-defines}
|
|
is not yet defined because Calc has not yet been loaded.
|
|
|
|
Examples of things that ought to be enclosed in a @code{calc-define}
|
|
property are @code{defmath} calls, @code{define-key} calls that modify
|
|
the Calc key map, and any calls that redefine things defined inside Calc.
|
|
Ordinary @code{defun}s need not be enclosed with @code{calc-define}.
|
|
|
|
@node Defining Simple Commands, Defining Stack Commands, Defining Functions, Lisp Definitions
|
|
@subsection Defining New Simple Commands
|
|
|
|
@noindent
|
|
@findex interactive
|
|
If a @code{defmath} form contains an @code{interactive} clause, it defines
|
|
a Calculator command. Actually such a @code{defmath} results in @emph{two}
|
|
function definitions: One, a @samp{calcFunc-} function as was just described,
|
|
with the @code{interactive} clause removed. Two, a @samp{calc-} function
|
|
with a suitable @code{interactive} clause and some sort of wrapper to make
|
|
the command work in the Calc environment.
|
|
|
|
In the simple case, the @code{interactive} clause has the same form as
|
|
for normal Emacs Lisp commands:
|
|
|
|
@smallexample
|
|
(defmath increase-precision (delta)
|
|
"Increase precision by DELTA." ; This is the "documentation string"
|
|
(interactive "p") ; Register this as a M-x-able command
|
|
(setq calc-internal-prec (+ calc-internal-prec delta)))
|
|
@end smallexample
|
|
|
|
This expands to the pair of definitions,
|
|
|
|
@smallexample
|
|
(defun calc-increase-precision (delta)
|
|
"Increase precision by DELTA."
|
|
(interactive "p")
|
|
(calc-wrapper
|
|
(setq calc-internal-prec (math-add calc-internal-prec delta))))
|
|
|
|
(defun calcFunc-increase-precision (delta)
|
|
"Increase precision by DELTA."
|
|
(setq calc-internal-prec (math-add calc-internal-prec delta)))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where in this case the latter function would never really be used! Note
|
|
that since the Calculator stores small integers as plain Lisp integers,
|
|
the @code{math-add} function will work just as well as the native
|
|
@code{+} even when the intent is to operate on native Lisp integers.
|
|
|
|
@findex calc-wrapper
|
|
The @samp{calc-wrapper} call invokes a macro which surrounds the body of
|
|
the function with code that looks roughly like this:
|
|
|
|
@smallexample
|
|
(let ((calc-command-flags nil))
|
|
(unwind-protect
|
|
(save-excursion
|
|
(calc-select-buffer)
|
|
@emph{body of function}
|
|
@emph{renumber stack}
|
|
@emph{clear} Working @emph{message})
|
|
@emph{realign cursor and window}
|
|
@emph{clear Inverse, Hyperbolic, and Keep Args flags}
|
|
@emph{update Emacs mode line}))
|
|
@end smallexample
|
|
|
|
@findex calc-select-buffer
|
|
The @code{calc-select-buffer} function selects the @samp{*Calculator*}
|
|
buffer if necessary, say, because the command was invoked from inside
|
|
the @samp{*Calc Trail*} window.
|
|
|
|
@findex calc-set-command-flag
|
|
You can call, for example, @code{(calc-set-command-flag 'no-align)} to
|
|
set the above-mentioned command flags. Calc routines recognize the
|
|
following command flags:
|
|
|
|
@table @code
|
|
@item renum-stack
|
|
Stack line numbers @samp{1:}, @samp{2:}, and so on must be renumbered
|
|
after this command completes. This is set by routines like
|
|
@code{calc-push}.
|
|
|
|
@item clear-message
|
|
Calc should call @samp{(message "")} if this command completes normally
|
|
(to clear a ``Working@dots{}'' message out of the echo area).
|
|
|
|
@item no-align
|
|
Do not move the cursor back to the @samp{.} top-of-stack marker.
|
|
|
|
@item position-point
|
|
Use the variables @code{calc-position-point-line} and
|
|
@code{calc-position-point-column} to position the cursor after
|
|
this command finishes.
|
|
|
|
@item keep-flags
|
|
Do not clear @code{calc-inverse-flag}, @code{calc-hyperbolic-flag},
|
|
and @code{calc-keep-args-flag} at the end of this command.
|
|
|
|
@item do-edit
|
|
Switch to buffer @samp{*Calc Edit*} after this command.
|
|
|
|
@item hold-trail
|
|
Do not move trail pointer to end of trail when something is recorded
|
|
there.
|
|
@end table
|
|
|
|
@kindex Y
|
|
@kindex Y ?
|
|
@vindex calc-Y-help-msgs
|
|
Calc reserves a special prefix key, shift-@kbd{Y}, for user-written
|
|
extensions to Calc. There are no built-in commands that work with
|
|
this prefix key; you must call @code{define-key} from Lisp (probably
|
|
from inside a @code{calc-define} property) to add to it. Initially only
|
|
@kbd{Y ?} is defined; it takes help messages from a list of strings
|
|
(initially @code{nil}) in the variable @code{calc-Y-help-msgs}. All
|
|
other undefined keys except for @kbd{Y} are reserved for use by
|
|
future versions of Calc.
|
|
|
|
If you are writing a Calc enhancement which you expect to give to
|
|
others, it is best to minimize the number of @kbd{Y}-key sequences
|
|
you use. In fact, if you have more than one key sequence you should
|
|
consider defining three-key sequences with a @kbd{Y}, then a key that
|
|
stands for your package, then a third key for the particular command
|
|
within your package.
|
|
|
|
Users may wish to install several Calc enhancements, and it is possible
|
|
that several enhancements will choose to use the same key. In the
|
|
example below, a variable @code{inc-prec-base-key} has been defined
|
|
to contain the key that identifies the @code{inc-prec} package. Its
|
|
value is initially @code{"P"}, but a user can change this variable
|
|
if necessary without having to modify the file.
|
|
|
|
Here is a complete file, @file{inc-prec.el}, which makes a @kbd{Y P I}
|
|
command that increases the precision, and a @kbd{Y P D} command that
|
|
decreases the precision.
|
|
|
|
@smallexample
|
|
;;; Increase and decrease Calc precision. Dave Gillespie, 5/31/91.
|
|
;;; (Include copyright or copyleft stuff here.)
|
|
|
|
(defvar inc-prec-base-key "P"
|
|
"Base key for inc-prec.el commands.")
|
|
|
|
(put 'calc-define 'inc-prec '(progn
|
|
|
|
(define-key calc-mode-map (format "Y%sI" inc-prec-base-key)
|
|
'increase-precision)
|
|
(define-key calc-mode-map (format "Y%sD" inc-prec-base-key)
|
|
'decrease-precision)
|
|
|
|
(setq calc-Y-help-msgs
|
|
(cons (format "%s + Inc-prec, Dec-prec" inc-prec-base-key)
|
|
calc-Y-help-msgs))
|
|
|
|
(defmath increase-precision (delta)
|
|
"Increase precision by DELTA."
|
|
(interactive "p")
|
|
(setq calc-internal-prec (+ calc-internal-prec delta)))
|
|
|
|
(defmath decrease-precision (delta)
|
|
"Decrease precision by DELTA."
|
|
(interactive "p")
|
|
(setq calc-internal-prec (- calc-internal-prec delta)))
|
|
|
|
)) ; end of calc-define property
|
|
|
|
(run-hooks 'calc-check-defines)
|
|
@end smallexample
|
|
|
|
@node Defining Stack Commands, Argument Qualifiers, Defining Simple Commands, Lisp Definitions
|
|
@subsection Defining New Stack-Based Commands
|
|
|
|
@noindent
|
|
To define a new computational command which takes and/or leaves arguments
|
|
on the stack, a special form of @code{interactive} clause is used.
|
|
|
|
@example
|
|
(interactive @var{num} @var{tag})
|
|
@end example
|
|
|
|
@noindent
|
|
where @var{num} is an integer, and @var{tag} is a string. The effect is
|
|
to pop @var{num} values off the stack, resimplify them by calling
|
|
@code{calc-normalize}, and hand them to your function according to the
|
|
function's argument list. Your function may include @code{&optional} and
|
|
@code{&rest} parameters, so long as calling the function with @var{num}
|
|
parameters is valid.
|
|
|
|
Your function must return either a number or a formula in a form
|
|
acceptable to Calc, or a list of such numbers or formulas. These value(s)
|
|
are pushed onto the stack when the function completes. They are also
|
|
recorded in the Calc Trail buffer on a line beginning with @var{tag},
|
|
a string of (normally) four characters or less. If you omit @var{tag}
|
|
or use @code{nil} as a tag, the result is not recorded in the trail.
|
|
|
|
As an example, the definition
|
|
|
|
@smallexample
|
|
(defmath myfact (n)
|
|
"Compute the factorial of the integer at the top of the stack."
|
|
(interactive 1 "fact")
|
|
(if (> n 0)
|
|
(* n (myfact (1- n)))
|
|
(and (= n 0) 1)))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
is a version of the factorial function shown previously which can be used
|
|
as a command as well as an algebraic function. It expands to
|
|
|
|
@smallexample
|
|
(defun calc-myfact ()
|
|
"Compute the factorial of the integer at the top of the stack."
|
|
(interactive)
|
|
(calc-slow-wrapper
|
|
(calc-enter-result 1 "fact"
|
|
(cons 'calcFunc-myfact (calc-top-list-n 1)))))
|
|
|
|
(defun calcFunc-myfact (n)
|
|
"Compute the factorial of the integer at the top of the stack."
|
|
(if (math-posp n)
|
|
(math-mul n (calcFunc-myfact (math-add n -1)))
|
|
(and (math-zerop n) 1)))
|
|
@end smallexample
|
|
|
|
@findex calc-slow-wrapper
|
|
The @code{calc-slow-wrapper} function is a version of @code{calc-wrapper}
|
|
that automatically puts up a @samp{Working...} message before the
|
|
computation begins. (This message can be turned off by the user
|
|
with an @kbd{m w} (@code{calc-working}) command.)
|
|
|
|
@findex calc-top-list-n
|
|
The @code{calc-top-list-n} function returns a list of the specified number
|
|
of values from the top of the stack. It resimplifies each value by
|
|
calling @code{calc-normalize}. If its argument is zero it returns an
|
|
empty list. It does not actually remove these values from the stack.
|
|
|
|
@findex calc-enter-result
|
|
The @code{calc-enter-result} function takes an integer @var{num} and string
|
|
@var{tag} as described above, plus a third argument which is either a
|
|
Calculator data object or a list of such objects. These objects are
|
|
resimplified and pushed onto the stack after popping the specified number
|
|
of values from the stack. If @var{tag} is non-@code{nil}, the values
|
|
being pushed are also recorded in the trail.
|
|
|
|
Note that if @code{calcFunc-myfact} returns @code{nil} this represents
|
|
``leave the function in symbolic form.'' To return an actual empty list,
|
|
in the sense that @code{calc-enter-result} will push zero elements back
|
|
onto the stack, you should return the special value @samp{'(nil)}, a list
|
|
containing the single symbol @code{nil}.
|
|
|
|
The @code{interactive} declaration can actually contain a limited
|
|
Emacs-style code string as well which comes just before @var{num} and
|
|
@var{tag}. Currently the only Emacs code supported is @samp{"p"}, as in
|
|
|
|
@example
|
|
(defmath foo (a b &optional c)
|
|
(interactive "p" 2 "foo")
|
|
@var{body})
|
|
@end example
|
|
|
|
In this example, the command @code{calc-foo} will evaluate the expression
|
|
@samp{foo(a,b)} if executed with no argument, or @samp{foo(a,b,n)} if
|
|
executed with a numeric prefix argument of @expr{n}.
|
|
|
|
The other code string allowed is @samp{"m"} (unrelated to the usual @samp{"m"}
|
|
code as used with @code{defun}). It uses the numeric prefix argument as the
|
|
number of objects to remove from the stack and pass to the function.
|
|
In this case, the integer @var{num} serves as a default number of
|
|
arguments to be used when no prefix is supplied.
|
|
|
|
@node Argument Qualifiers, Example Definitions, Defining Stack Commands, Lisp Definitions
|
|
@subsection Argument Qualifiers
|
|
|
|
@noindent
|
|
Anywhere a parameter name can appear in the parameter list you can also use
|
|
an @dfn{argument qualifier}. Thus the general form of a definition is:
|
|
|
|
@example
|
|
(defmath @var{name} (@var{param} @var{param...}
|
|
&optional @var{param} @var{param...}
|
|
&rest @var{param})
|
|
@var{body})
|
|
@end example
|
|
|
|
@noindent
|
|
where each @var{param} is either a symbol or a list of the form
|
|
|
|
@example
|
|
(@var{qual} @var{param})
|
|
@end example
|
|
|
|
The following qualifiers are recognized:
|
|
|
|
@table @samp
|
|
@item complete
|
|
@findex complete
|
|
The argument must not be an incomplete vector, interval, or complex number.
|
|
(This is rarely needed since the Calculator itself will never call your
|
|
function with an incomplete argument. But there is nothing stopping your
|
|
own Lisp code from calling your function with an incomplete argument.)
|
|
|
|
@item integer
|
|
@findex integer
|
|
The argument must be an integer. If it is an integer-valued float
|
|
it will be accepted but converted to integer form. Non-integers and
|
|
formulas are rejected.
|
|
|
|
@item natnum
|
|
@findex natnum
|
|
Like @samp{integer}, but the argument must be non-negative.
|
|
|
|
@item fixnum
|
|
@findex fixnum
|
|
Like @samp{integer}, but the argument must fit into a native Lisp integer,
|
|
which on most systems means less than 2^23 in absolute value. The
|
|
argument is converted into Lisp-integer form if necessary.
|
|
|
|
@item float
|
|
@findex float
|
|
The argument is converted to floating-point format if it is a number or
|
|
vector. If it is a formula it is left alone. (The argument is never
|
|
actually rejected by this qualifier.)
|
|
|
|
@item @var{pred}
|
|
The argument must satisfy predicate @var{pred}, which is one of the
|
|
standard Calculator predicates. @xref{Predicates}.
|
|
|
|
@item not-@var{pred}
|
|
The argument must @emph{not} satisfy predicate @var{pred}.
|
|
@end table
|
|
|
|
For example,
|
|
|
|
@example
|
|
(defmath foo (a (constp (not-matrixp b)) &optional (float c)
|
|
&rest (integer d))
|
|
@var{body})
|
|
@end example
|
|
|
|
@noindent
|
|
expands to
|
|
|
|
@example
|
|
(defun calcFunc-foo (a b &optional c &rest d)
|
|
(and (math-matrixp b)
|
|
(math-reject-arg b 'not-matrixp))
|
|
(or (math-constp b)
|
|
(math-reject-arg b 'constp))
|
|
(and c (setq c (math-check-float c)))
|
|
(setq d (mapcar 'math-check-integer d))
|
|
@var{body})
|
|
@end example
|
|
|
|
@noindent
|
|
which performs the necessary checks and conversions before executing the
|
|
body of the function.
|
|
|
|
@node Example Definitions, Calling Calc from Your Programs, Argument Qualifiers, Lisp Definitions
|
|
@subsection Example Definitions
|
|
|
|
@noindent
|
|
This section includes some Lisp programming examples on a larger scale.
|
|
These programs make use of some of the Calculator's internal functions;
|
|
@pxref{Internals}.
|
|
|
|
@menu
|
|
* Bit Counting Example::
|
|
* Sine Example::
|
|
@end menu
|
|
|
|
@node Bit Counting Example, Sine Example, Example Definitions, Example Definitions
|
|
@subsubsection Bit-Counting
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex bcount
|
|
Calc does not include a built-in function for counting the number of
|
|
``one'' bits in a binary integer. It's easy to invent one using @kbd{b u}
|
|
to convert the integer to a set, and @kbd{V #} to count the elements of
|
|
that set; let's write a function that counts the bits without having to
|
|
create an intermediate set.
|
|
|
|
@smallexample
|
|
(defmath bcount ((natnum n))
|
|
(interactive 1 "bcnt")
|
|
(let ((count 0))
|
|
(while (> n 0)
|
|
(if (oddp n)
|
|
(setq count (1+ count)))
|
|
(setq n (lsh n -1)))
|
|
count))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
When this is expanded by @code{defmath}, it will become the following
|
|
Emacs Lisp function:
|
|
|
|
@smallexample
|
|
(defun calcFunc-bcount (n)
|
|
(setq n (math-check-natnum n))
|
|
(let ((count 0))
|
|
(while (math-posp n)
|
|
(if (math-oddp n)
|
|
(setq count (math-add count 1)))
|
|
(setq n (calcFunc-lsh n -1)))
|
|
count))
|
|
@end smallexample
|
|
|
|
If the input numbers are large, this function involves a fair amount
|
|
of arithmetic. A binary right shift is essentially a division by two;
|
|
recall that Calc stores integers in decimal form so bit shifts must
|
|
involve actual division.
|
|
|
|
To gain a bit more efficiency, we could divide the integer into
|
|
@var{n}-bit chunks, each of which can be handled quickly because
|
|
they fit into Lisp integers. It turns out that Calc's arithmetic
|
|
routines are especially fast when dividing by an integer less than
|
|
1000, so we can set @var{n = 9} bits and use repeated division by 512:
|
|
|
|
@smallexample
|
|
(defmath bcount ((natnum n))
|
|
(interactive 1 "bcnt")
|
|
(let ((count 0))
|
|
(while (not (fixnump n))
|
|
(let ((qr (idivmod n 512)))
|
|
(setq count (+ count (bcount-fixnum (cdr qr)))
|
|
n (car qr))))
|
|
(+ count (bcount-fixnum n))))
|
|
|
|
(defun bcount-fixnum (n)
|
|
(let ((count 0))
|
|
(while (> n 0)
|
|
(setq count (+ count (logand n 1))
|
|
n (lsh n -1)))
|
|
count))
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Note that the second function uses @code{defun}, not @code{defmath}.
|
|
Because this function deals only with native Lisp integers (``fixnums''),
|
|
it can use the actual Emacs @code{+} and related functions rather
|
|
than the slower but more general Calc equivalents which @code{defmath}
|
|
uses.
|
|
|
|
The @code{idivmod} function does an integer division, returning both
|
|
the quotient and the remainder at once. Again, note that while it
|
|
might seem that @samp{(logand n 511)} and @samp{(lsh n -9)} are
|
|
more efficient ways to split off the bottom nine bits of @code{n},
|
|
actually they are less efficient because each operation is really
|
|
a division by 512 in disguise; @code{idivmod} allows us to do the
|
|
same thing with a single division by 512.
|
|
|
|
@node Sine Example, , Bit Counting Example, Example Definitions
|
|
@subsubsection The Sine Function
|
|
|
|
@noindent
|
|
@ignore
|
|
@starindex
|
|
@end ignore
|
|
@tindex mysin
|
|
A somewhat limited sine function could be defined as follows, using the
|
|
well-known Taylor series expansion for
|
|
@texline @math{\sin x}:
|
|
@infoline @samp{sin(x)}:
|
|
|
|
@smallexample
|
|
(defmath mysin ((float (anglep x)))
|
|
(interactive 1 "mysn")
|
|
(setq x (to-radians x)) ; Convert from current angular mode.
|
|
(let ((sum x) ; Initial term of Taylor expansion of sin.
|
|
newsum
|
|
(nfact 1) ; "nfact" equals "n" factorial at all times.
|
|
(xnegsqr :"-(x^2)")) ; "xnegsqr" equals -x^2.
|
|
(for ((n 3 100 2)) ; Upper limit of 100 is a good precaution.
|
|
(working "mysin" sum) ; Display "Working" message, if enabled.
|
|
(setq nfact (* nfact (1- n) n)
|
|
x (* x xnegsqr)
|
|
newsum (+ sum (/ x nfact)))
|
|
(if (~= newsum sum) ; If newsum is "nearly equal to" sum,
|
|
(break)) ; then we are done.
|
|
(setq sum newsum))
|
|
sum))
|
|
@end smallexample
|
|
|
|
The actual @code{sin} function in Calc works by first reducing the problem
|
|
to a sine or cosine of a nonnegative number less than @cpiover{4}. This
|
|
ensures that the Taylor series will converge quickly. Also, the calculation
|
|
is carried out with two extra digits of precision to guard against cumulative
|
|
round-off in @samp{sum}. Finally, complex arguments are allowed and handled
|
|
by a separate algorithm.
|
|
|
|
@smallexample
|
|
(defmath mysin ((float (scalarp x)))
|
|
(interactive 1 "mysn")
|
|
(setq x (to-radians x)) ; Convert from current angular mode.
|
|
(with-extra-prec 2 ; Evaluate with extra precision.
|
|
(cond ((complexp x)
|
|
(mysin-complex x))
|
|
((< x 0)
|
|
(- (mysin-raw (- x))) ; Always call mysin-raw with x >= 0.
|
|
(t (mysin-raw x))))))
|
|
|
|
(defmath mysin-raw (x)
|
|
(cond ((>= x 7)
|
|
(mysin-raw (% x (two-pi)))) ; Now x < 7.
|
|
((> x (pi-over-2))
|
|
(- (mysin-raw (- x (pi))))) ; Now -pi/2 <= x <= pi/2.
|
|
((> x (pi-over-4))
|
|
(mycos-raw (- x (pi-over-2)))) ; Now -pi/2 <= x <= pi/4.
|
|
((< x (- (pi-over-4)))
|
|
(- (mycos-raw (+ x (pi-over-2))))) ; Now -pi/4 <= x <= pi/4,
|
|
(t (mysin-series x)))) ; so the series will be efficient.
|
|
@end smallexample
|
|
|
|
@noindent
|
|
where @code{mysin-complex} is an appropriate function to handle complex
|
|
numbers, @code{mysin-series} is the routine to compute the sine Taylor
|
|
series as before, and @code{mycos-raw} is a function analogous to
|
|
@code{mysin-raw} for cosines.
|
|
|
|
The strategy is to ensure that @expr{x} is nonnegative before calling
|
|
@code{mysin-raw}. This function then recursively reduces its argument
|
|
to a suitable range, namely, plus-or-minus @cpiover{4}. Note that each
|
|
test, and particularly the first comparison against 7, is designed so
|
|
that small roundoff errors cannot produce an infinite loop. (Suppose
|
|
we compared with @samp{(two-pi)} instead; if due to roundoff problems
|
|
the modulo operator ever returned @samp{(two-pi)} exactly, an infinite
|
|
recursion could result!) We use modulo only for arguments that will
|
|
clearly get reduced, knowing that the next rule will catch any reductions
|
|
that this rule misses.
|
|
|
|
If a program is being written for general use, it is important to code
|
|
it carefully as shown in this second example. For quick-and-dirty programs,
|
|
when you know that your own use of the sine function will never encounter
|
|
a large argument, a simpler program like the first one shown is fine.
|
|
|
|
@node Calling Calc from Your Programs, Internals, Example Definitions, Lisp Definitions
|
|
@subsection Calling Calc from Your Lisp Programs
|
|
|
|
@noindent
|
|
A later section (@pxref{Internals}) gives a full description of
|
|
Calc's internal Lisp functions. It's not hard to call Calc from
|
|
inside your programs, but the number of these functions can be daunting.
|
|
So Calc provides one special ``programmer-friendly'' function called
|
|
@code{calc-eval} that can be made to do just about everything you
|
|
need. It's not as fast as the low-level Calc functions, but it's
|
|
much simpler to use!
|
|
|
|
It may seem that @code{calc-eval} itself has a daunting number of
|
|
options, but they all stem from one simple operation.
|
|
|
|
In its simplest manifestation, @samp{(calc-eval "1+2")} parses the
|
|
string @code{"1+2"} as if it were a Calc algebraic entry and returns
|
|
the result formatted as a string: @code{"3"}.
|
|
|
|
Since @code{calc-eval} is on the list of recommended @code{autoload}
|
|
functions, you don't need to make any special preparations to load
|
|
Calc before calling @code{calc-eval} the first time. Calc will be
|
|
loaded and initialized for you.
|
|
|
|
All the Calc modes that are currently in effect will be used when
|
|
evaluating the expression and formatting the result.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Additional Arguments to @code{calc-eval}
|
|
|
|
@noindent
|
|
If the input string parses to a list of expressions, Calc returns
|
|
the results separated by @code{", "}. You can specify a different
|
|
separator by giving a second string argument to @code{calc-eval}:
|
|
@samp{(calc-eval "1+2,3+4" ";")} returns @code{"3;7"}.
|
|
|
|
The ``separator'' can also be any of several Lisp symbols which
|
|
request other behaviors from @code{calc-eval}. These are discussed
|
|
one by one below.
|
|
|
|
You can give additional arguments to be substituted for
|
|
@samp{$}, @samp{$$}, and so on in the main expression. For
|
|
example, @samp{(calc-eval "$/$$" nil "7" "1+1")} evaluates the
|
|
expression @code{"7/(1+1)"} to yield the result @code{"3.5"}
|
|
(assuming Fraction mode is not in effect). Note the @code{nil}
|
|
used as a placeholder for the item-separator argument.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Error Handling
|
|
|
|
@noindent
|
|
If @code{calc-eval} encounters an error, it returns a list containing
|
|
the character position of the error, plus a suitable message as a
|
|
string. Note that @samp{1 / 0} is @emph{not} an error by Calc's
|
|
standards; it simply returns the string @code{"1 / 0"} which is the
|
|
division left in symbolic form. But @samp{(calc-eval "1/")} will
|
|
return the list @samp{(2 "Expected a number")}.
|
|
|
|
If you bind the variable @code{calc-eval-error} to @code{t}
|
|
using a @code{let} form surrounding the call to @code{calc-eval},
|
|
errors instead call the Emacs @code{error} function which aborts
|
|
to the Emacs command loop with a beep and an error message.
|
|
|
|
If you bind this variable to the symbol @code{string}, error messages
|
|
are returned as strings instead of lists. The character position is
|
|
ignored.
|
|
|
|
As a courtesy to other Lisp code which may be using Calc, be sure
|
|
to bind @code{calc-eval-error} using @code{let} rather than changing
|
|
it permanently with @code{setq}.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Numbers Only
|
|
|
|
@noindent
|
|
Sometimes it is preferable to treat @samp{1 / 0} as an error
|
|
rather than returning a symbolic result. If you pass the symbol
|
|
@code{num} as the second argument to @code{calc-eval}, results
|
|
that are not constants are treated as errors. The error message
|
|
reported is the first @code{calc-why} message if there is one,
|
|
or otherwise ``Number expected.''
|
|
|
|
A result is ``constant'' if it is a number, vector, or other
|
|
object that does not include variables or function calls. If it
|
|
is a vector, the components must themselves be constants.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Default Modes
|
|
|
|
@noindent
|
|
If the first argument to @code{calc-eval} is a list whose first
|
|
element is a formula string, then @code{calc-eval} sets all the
|
|
various Calc modes to their default values while the formula is
|
|
evaluated and formatted. For example, the precision is set to 12
|
|
digits, digit grouping is turned off, and the Normal language
|
|
mode is used.
|
|
|
|
This same principle applies to the other options discussed below.
|
|
If the first argument would normally be @var{x}, then it can also
|
|
be the list @samp{(@var{x})} to use the default mode settings.
|
|
|
|
If there are other elements in the list, they are taken as
|
|
variable-name/value pairs which override the default mode
|
|
settings. Look at the documentation at the front of the
|
|
@file{calc.el} file to find the names of the Lisp variables for
|
|
the various modes. The mode settings are restored to their
|
|
original values when @code{calc-eval} is done.
|
|
|
|
For example, @samp{(calc-eval '("$+$$" calc-internal-prec 8) 'num a b)}
|
|
computes the sum of two numbers, requiring a numeric result, and
|
|
using default mode settings except that the precision is 8 instead
|
|
of the default of 12.
|
|
|
|
It's usually best to use this form of @code{calc-eval} unless your
|
|
program actually considers the interaction with Calc's mode settings
|
|
to be a feature. This will avoid all sorts of potential ``gotchas'';
|
|
consider what happens with @samp{(calc-eval "sqrt(2)" 'num)}
|
|
when the user has left Calc in Symbolic mode or No-Simplify mode.
|
|
|
|
As another example, @samp{(equal (calc-eval '("$<$$") nil a b) "1")}
|
|
checks if the number in string @expr{a} is less than the one in
|
|
string @expr{b}. Without using a list, the integer 1 might
|
|
come out in a variety of formats which would be hard to test for
|
|
conveniently: @code{"1"}, @code{"8#1"}, @code{"00001"}. (But
|
|
see ``Predicates'' mode, below.)
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Raw Numbers
|
|
|
|
@noindent
|
|
Normally all input and output for @code{calc-eval} is done with strings.
|
|
You can do arithmetic with, say, @samp{(calc-eval "$+$$" nil a b)}
|
|
in place of @samp{(+ a b)}, but this is very inefficient since the
|
|
numbers must be converted to and from string format as they are passed
|
|
from one @code{calc-eval} to the next.
|
|
|
|
If the separator is the symbol @code{raw}, the result will be returned
|
|
as a raw Calc data structure rather than a string. You can read about
|
|
how these objects look in the following sections, but usually you can
|
|
treat them as ``black box'' objects with no important internal
|
|
structure.
|
|
|
|
There is also a @code{rawnum} symbol, which is a combination of
|
|
@code{raw} (returning a raw Calc object) and @code{num} (signaling
|
|
an error if that object is not a constant).
|
|
|
|
You can pass a raw Calc object to @code{calc-eval} in place of a
|
|
string, either as the formula itself or as one of the @samp{$}
|
|
arguments. Thus @samp{(calc-eval "$+$$" 'raw a b)} is an
|
|
addition function that operates on raw Calc objects. Of course
|
|
in this case it would be easier to call the low-level @code{math-add}
|
|
function in Calc, if you can remember its name.
|
|
|
|
In particular, note that a plain Lisp integer is acceptable to Calc
|
|
as a raw object. (All Lisp integers are accepted on input, but
|
|
integers of more than six decimal digits are converted to ``big-integer''
|
|
form for output. @xref{Data Type Formats}.)
|
|
|
|
When it comes time to display the object, just use @samp{(calc-eval a)}
|
|
to format it as a string.
|
|
|
|
It is an error if the input expression evaluates to a list of
|
|
values. The separator symbol @code{list} is like @code{raw}
|
|
except that it returns a list of one or more raw Calc objects.
|
|
|
|
Note that a Lisp string is not a valid Calc object, nor is a list
|
|
containing a string. Thus you can still safely distinguish all the
|
|
various kinds of error returns discussed above.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Predicates
|
|
|
|
@noindent
|
|
If the separator symbol is @code{pred}, the result of the formula is
|
|
treated as a true/false value; @code{calc-eval} returns @code{t} or
|
|
@code{nil}, respectively. A value is considered ``true'' if it is a
|
|
non-zero number, or false if it is zero or if it is not a number.
|
|
|
|
For example, @samp{(calc-eval "$<$$" 'pred a b)} tests whether
|
|
one value is less than another.
|
|
|
|
As usual, it is also possible for @code{calc-eval} to return one of
|
|
the error indicators described above. Lisp will interpret such an
|
|
indicator as ``true'' if you don't check for it explicitly. If you
|
|
wish to have an error register as ``false'', use something like
|
|
@samp{(eq (calc-eval ...) t)}.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Variable Values
|
|
|
|
@noindent
|
|
Variables in the formula passed to @code{calc-eval} are not normally
|
|
replaced by their values. If you wish this, you can use the
|
|
@code{evalv} function (@pxref{Algebraic Manipulation}). For example,
|
|
if 4 is stored in Calc variable @code{a} (i.e., in Lisp variable
|
|
@code{var-a}), then @samp{(calc-eval "a+pi")} will return the
|
|
formula @code{"a + pi"}, but @samp{(calc-eval "evalv(a+pi)")}
|
|
will return @code{"7.14159265359"}.
|
|
|
|
To store in a Calc variable, just use @code{setq} to store in the
|
|
corresponding Lisp variable. (This is obtained by prepending
|
|
@samp{var-} to the Calc variable name.) Calc routines will
|
|
understand either string or raw form values stored in variables,
|
|
although raw data objects are much more efficient. For example,
|
|
to increment the Calc variable @code{a}:
|
|
|
|
@example
|
|
(setq var-a (calc-eval "evalv(a+1)" 'raw))
|
|
@end example
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Stack Access
|
|
|
|
@noindent
|
|
If the separator symbol is @code{push}, the formula argument is
|
|
evaluated (with possible @samp{$} expansions, as usual). The
|
|
result is pushed onto the Calc stack. The return value is @code{nil}
|
|
(unless there is an error from evaluating the formula, in which
|
|
case the return value depends on @code{calc-eval-error} in the
|
|
usual way).
|
|
|
|
If the separator symbol is @code{pop}, the first argument to
|
|
@code{calc-eval} must be an integer instead of a string. That
|
|
many values are popped from the stack and thrown away. A negative
|
|
argument deletes the entry at that stack level. The return value
|
|
is the number of elements remaining in the stack after popping;
|
|
@samp{(calc-eval 0 'pop)} is a good way to measure the size of
|
|
the stack.
|
|
|
|
If the separator symbol is @code{top}, the first argument to
|
|
@code{calc-eval} must again be an integer. The value at that
|
|
stack level is formatted as a string and returned. Thus
|
|
@samp{(calc-eval 1 'top)} returns the top-of-stack value. If the
|
|
integer is out of range, @code{nil} is returned.
|
|
|
|
The separator symbol @code{rawtop} is just like @code{top} except
|
|
that the stack entry is returned as a raw Calc object instead of
|
|
as a string.
|
|
|
|
In all of these cases the first argument can be made a list in
|
|
order to force the default mode settings, as described above.
|
|
Thus @samp{(calc-eval '(2 calc-number-radix 16) 'top)} returns the
|
|
second-to-top stack entry, formatted as a string using the default
|
|
instead of current display modes, except that the radix is
|
|
hexadecimal instead of decimal.
|
|
|
|
It is, of course, polite to put the Calc stack back the way you
|
|
found it when you are done, unless the user of your program is
|
|
actually expecting it to affect the stack.
|
|
|
|
Note that you do not actually have to switch into the @samp{*Calculator*}
|
|
buffer in order to use @code{calc-eval}; it temporarily switches into
|
|
the stack buffer if necessary.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Keyboard Macros
|
|
|
|
@noindent
|
|
If the separator symbol is @code{macro}, the first argument must be a
|
|
string of characters which Calc can execute as a sequence of keystrokes.
|
|
This switches into the Calc buffer for the duration of the macro.
|
|
For example, @samp{(calc-eval "vx5\rVR+" 'macro)} pushes the
|
|
vector @samp{[1,2,3,4,5]} on the stack and then replaces it
|
|
with the sum of those numbers. Note that @samp{\r} is the Lisp
|
|
notation for the carriage-return, @key{RET}, character.
|
|
|
|
If your keyboard macro wishes to pop the stack, @samp{\C-d} is
|
|
safer than @samp{\177} (the @key{DEL} character) because some
|
|
installations may have switched the meanings of @key{DEL} and
|
|
@kbd{C-h}. Calc always interprets @kbd{C-d} as a synonym for
|
|
``pop-stack'' regardless of key mapping.
|
|
|
|
If you provide a third argument to @code{calc-eval}, evaluation
|
|
of the keyboard macro will leave a record in the Trail using
|
|
that argument as a tag string. Normally the Trail is unaffected.
|
|
|
|
The return value in this case is always @code{nil}.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Lisp Evaluation
|
|
|
|
@noindent
|
|
Finally, if the separator symbol is @code{eval}, then the Lisp
|
|
@code{eval} function is called on the first argument, which must
|
|
be a Lisp expression rather than a Calc formula. Remember to
|
|
quote the expression so that it is not evaluated until inside
|
|
@code{calc-eval}.
|
|
|
|
The difference from plain @code{eval} is that @code{calc-eval}
|
|
switches to the Calc buffer before evaluating the expression.
|
|
For example, @samp{(calc-eval '(setq calc-internal-prec 17) 'eval)}
|
|
will correctly affect the buffer-local Calc precision variable.
|
|
|
|
An alternative would be @samp{(calc-eval '(calc-precision 17) 'eval)}.
|
|
This is evaluating a call to the function that is normally invoked
|
|
by the @kbd{p} key, giving it 17 as its ``numeric prefix argument.''
|
|
Note that this function will leave a message in the echo area as
|
|
a side effect. Also, all Calc functions switch to the Calc buffer
|
|
automatically if not invoked from there, so the above call is
|
|
also equivalent to @samp{(calc-precision 17)} by itself.
|
|
In all cases, Calc uses @code{save-excursion} to switch back to
|
|
your original buffer when it is done.
|
|
|
|
As usual the first argument can be a list that begins with a Lisp
|
|
expression to use default instead of current mode settings.
|
|
|
|
The result of @code{calc-eval} in this usage is just the result
|
|
returned by the evaluated Lisp expression.
|
|
|
|
@ifinfo
|
|
@example
|
|
|
|
@end example
|
|
@end ifinfo
|
|
@subsubsection Example
|
|
|
|
@noindent
|
|
@findex convert-temp
|
|
Here is a sample Emacs command that uses @code{calc-eval}. Suppose
|
|
you have a document with lots of references to temperatures on the
|
|
Fahrenheit scale, say ``98.6 F'', and you wish to convert these
|
|
references to Centigrade. The following command does this conversion.
|
|
Place the Emacs cursor right after the letter ``F'' and invoke the
|
|
command to change ``98.6 F'' to ``37 C''. Or, if the temperature is
|
|
already in Centigrade form, the command changes it back to Fahrenheit.
|
|
|
|
@example
|
|
(defun convert-temp ()
|
|
(interactive)
|
|
(save-excursion
|
|
(re-search-backward "[^-.0-9]\\([-.0-9]+\\) *\\([FC]\\)")
|
|
(let* ((top1 (match-beginning 1))
|
|
(bot1 (match-end 1))
|
|
(number (buffer-substring top1 bot1))
|
|
(top2 (match-beginning 2))
|
|
(bot2 (match-end 2))
|
|
(type (buffer-substring top2 bot2)))
|
|
(if (equal type "F")
|
|
(setq type "C"
|
|
number (calc-eval "($ - 32)*5/9" nil number))
|
|
(setq type "F"
|
|
number (calc-eval "$*9/5 + 32" nil number)))
|
|
(goto-char top2)
|
|
(delete-region top2 bot2)
|
|
(insert-before-markers type)
|
|
(goto-char top1)
|
|
(delete-region top1 bot1)
|
|
(if (string-match "\\.$" number) ; change "37." to "37"
|
|
(setq number (substring number 0 -1)))
|
|
(insert number))))
|
|
@end example
|
|
|
|
Note the use of @code{insert-before-markers} when changing between
|
|
``F'' and ``C'', so that the character winds up before the cursor
|
|
instead of after it.
|
|
|
|
@node Internals, , Calling Calc from Your Programs, Lisp Definitions
|
|
@subsection Calculator Internals
|
|
|
|
@noindent
|
|
This section describes the Lisp functions defined by the Calculator that
|
|
may be of use to user-written Calculator programs (as described in the
|
|
rest of this chapter). These functions are shown by their names as they
|
|
conventionally appear in @code{defmath}. Their full Lisp names are
|
|
generally gotten by prepending @samp{calcFunc-} or @samp{math-} to their
|
|
apparent names. (Names that begin with @samp{calc-} are already in
|
|
their full Lisp form.) You can use the actual full names instead if you
|
|
prefer them, or if you are calling these functions from regular Lisp.
|
|
|
|
The functions described here are scattered throughout the various
|
|
Calc component files. Note that @file{calc.el} includes @code{autoload}s
|
|
for only a few component files; when Calc wants to call an advanced
|
|
function it calls @samp{(calc-extensions)} first; this function
|
|
autoloads @file{calc-ext.el}, which in turn autoloads all the functions
|
|
in the remaining component files.
|
|
|
|
Because @code{defmath} itself uses the extensions, user-written code
|
|
generally always executes with the extensions already loaded, so
|
|
normally you can use any Calc function and be confident that it will
|
|
be autoloaded for you when necessary. If you are doing something
|
|
special, check carefully to make sure each function you are using is
|
|
from @file{calc.el} or its components, and call @samp{(calc-extensions)}
|
|
before using any function based in @file{calc-ext.el} if you can't
|
|
prove this file will already be loaded.
|
|
|
|
@menu
|
|
* Data Type Formats::
|
|
* Interactive Lisp Functions::
|
|
* Stack Lisp Functions::
|
|
* Predicates::
|
|
* Computational Lisp Functions::
|
|
* Vector Lisp Functions::
|
|
* Symbolic Lisp Functions::
|
|
* Formatting Lisp Functions::
|
|
* Hooks::
|
|
@end menu
|
|
|
|
@node Data Type Formats, Interactive Lisp Functions, Internals, Internals
|
|
@subsubsection Data Type Formats
|
|
|
|
@noindent
|
|
Integers are stored in either of two ways, depending on their magnitude.
|
|
Integers less than one million in absolute value are stored as standard
|
|
Lisp integers. This is the only storage format for Calc data objects
|
|
which is not a Lisp list.
|
|
|
|
Large integers are stored as lists of the form @samp{(bigpos @var{d0}
|
|
@var{d1} @var{d2} @dots{})} for positive integers 1000000 or more, or
|
|
@samp{(bigneg @var{d0} @var{d1} @var{d2} @dots{})} for negative integers
|
|
@mathit{-1000000} or less. Each @var{d} is a base-1000 ``digit,'' a Lisp integer
|
|
from 0 to 999. The least significant digit is @var{d0}; the last digit,
|
|
@var{dn}, which is always nonzero, is the most significant digit. For
|
|
example, the integer @mathit{-12345678} is stored as @samp{(bigneg 678 345 12)}.
|
|
|
|
The distinction between small and large integers is entirely hidden from
|
|
the user. In @code{defmath} definitions, the Lisp predicate @code{integerp}
|
|
returns true for either kind of integer, and in general both big and small
|
|
integers are accepted anywhere the word ``integer'' is used in this manual.
|
|
If the distinction must be made, native Lisp integers are called @dfn{fixnums}
|
|
and large integers are called @dfn{bignums}.
|
|
|
|
Fractions are stored as a list of the form, @samp{(frac @var{n} @var{d})}
|
|
where @var{n} is an integer (big or small) numerator, @var{d} is an
|
|
integer denominator greater than one, and @var{n} and @var{d} are relatively
|
|
prime. Note that fractions where @var{d} is one are automatically converted
|
|
to plain integers by all math routines; fractions where @var{d} is negative
|
|
are normalized by negating the numerator and denominator.
|
|
|
|
Floating-point numbers are stored in the form, @samp{(float @var{mant}
|
|
@var{exp})}, where @var{mant} (the ``mantissa'') is an integer less than
|
|
@samp{10^@var{p}} in absolute value (@var{p} represents the current
|
|
precision), and @var{exp} (the ``exponent'') is a fixnum. The value of
|
|
the float is @samp{@var{mant} * 10^@var{exp}}. For example, the number
|
|
@mathit{-3.14} is stored as @samp{(float -314 -2) = -314*10^-2}. Other constraints
|
|
are that the number 0.0 is always stored as @samp{(float 0 0)}, and,
|
|
except for the 0.0 case, the rightmost base-10 digit of @var{mant} is
|
|
always nonzero. (If the rightmost digit is zero, the number is
|
|
rearranged by dividing @var{mant} by ten and incrementing @var{exp}.)
|
|
|
|
Rectangular complex numbers are stored in the form @samp{(cplx @var{re}
|
|
@var{im})}, where @var{re} and @var{im} are each real numbers, either
|
|
integers, fractions, or floats. The value is @samp{@var{re} + @var{im}i}.
|
|
The @var{im} part is nonzero; complex numbers with zero imaginary
|
|
components are converted to real numbers automatically.
|
|
|
|
Polar complex numbers are stored in the form @samp{(polar @var{r}
|
|
@var{theta})}, where @var{r} is a positive real value and @var{theta}
|
|
is a real value or HMS form representing an angle. This angle is
|
|
usually normalized to lie in the interval @samp{(-180 ..@: 180)} degrees,
|
|
or @samp{(-pi ..@: pi)} radians, according to the current angular mode.
|
|
If the angle is 0 the value is converted to a real number automatically.
|
|
(If the angle is 180 degrees, the value is usually also converted to a
|
|
negative real number.)
|
|
|
|
Hours-minutes-seconds forms are stored as @samp{(hms @var{h} @var{m}
|
|
@var{s})}, where @var{h} is an integer or an integer-valued float (i.e.,
|
|
a float with @samp{@var{exp} >= 0}), @var{m} is an integer or integer-valued
|
|
float in the range @w{@samp{[0 ..@: 60)}}, and @var{s} is any real number
|
|
in the range @samp{[0 ..@: 60)}.
|
|
|
|
Date forms are stored as @samp{(date @var{n})}, where @var{n} is
|
|
a real number that counts days since midnight on the morning of
|
|
January 1, 1 AD. If @var{n} is an integer, this is a pure date
|
|
form. If @var{n} is a fraction or float, this is a date/time form.
|
|
|
|
Modulo forms are stored as @samp{(mod @var{n} @var{m})}, where @var{m} is a
|
|
positive real number or HMS form, and @var{n} is a real number or HMS
|
|
form in the range @samp{[0 ..@: @var{m})}.
|
|
|
|
Error forms are stored as @samp{(sdev @var{x} @var{sigma})}, where @var{x}
|
|
is the mean value and @var{sigma} is the standard deviation. Each
|
|
component is either a number, an HMS form, or a symbolic object
|
|
(a variable or function call). If @var{sigma} is zero, the value is
|
|
converted to a plain real number. If @var{sigma} is negative or
|
|
complex, it is automatically normalized to be a positive real.
|
|
|
|
Interval forms are stored as @samp{(intv @var{mask} @var{lo} @var{hi})},
|
|
where @var{mask} is one of the integers 0, 1, 2, or 3, and @var{lo} and
|
|
@var{hi} are real numbers, HMS forms, or symbolic objects. The @var{mask}
|
|
is a binary integer where 1 represents the fact that the interval is
|
|
closed on the high end, and 2 represents the fact that it is closed on
|
|
the low end. (Thus 3 represents a fully closed interval.) The interval
|
|
@w{@samp{(intv 3 @var{x} @var{x})}} is converted to the plain number @var{x};
|
|
intervals @samp{(intv @var{mask} @var{x} @var{x})} for any other @var{mask}
|
|
represent empty intervals. If @var{hi} is less than @var{lo}, the interval
|
|
is converted to a standard empty interval by replacing @var{hi} with @var{lo}.
|
|
|
|
Vectors are stored as @samp{(vec @var{v1} @var{v2} @dots{})}, where @var{v1}
|
|
is the first element of the vector, @var{v2} is the second, and so on.
|
|
An empty vector is stored as @samp{(vec)}. A matrix is simply a vector
|
|
where all @var{v}'s are themselves vectors of equal lengths. Note that
|
|
Calc vectors are unrelated to the Emacs Lisp ``vector'' type, which is
|
|
generally unused by Calc data structures.
|
|
|
|
Variables are stored as @samp{(var @var{name} @var{sym})}, where
|
|
@var{name} is a Lisp symbol whose print name is used as the visible name
|
|
of the variable, and @var{sym} is a Lisp symbol in which the variable's
|
|
value is actually stored. Thus, @samp{(var pi var-pi)} represents the
|
|
special constant @samp{pi}. Almost always, the form is @samp{(var
|
|
@var{v} var-@var{v})}. If the variable name was entered with @code{#}
|
|
signs (which are converted to hyphens internally), the form is
|
|
@samp{(var @var{u} @var{v})}, where @var{u} is a symbol whose name
|
|
contains @code{#} characters, and @var{v} is a symbol that contains
|
|
@code{-} characters instead. The value of a variable is the Calc
|
|
object stored in its @var{sym} symbol's value cell. If the symbol's
|
|
value cell is void or if it contains @code{nil}, the variable has no
|
|
value. Special constants have the form @samp{(special-const
|
|
@var{value})} stored in their value cell, where @var{value} is a formula
|
|
which is evaluated when the constant's value is requested. Variables
|
|
which represent units are not stored in any special way; they are units
|
|
only because their names appear in the units table. If the value
|
|
cell contains a string, it is parsed to get the variable's value when
|
|
the variable is used.
|
|
|
|
A Lisp list with any other symbol as the first element is a function call.
|
|
The symbols @code{+}, @code{-}, @code{*}, @code{/}, @code{%}, @code{^},
|
|
and @code{|} represent special binary operators; these lists are always
|
|
of the form @samp{(@var{op} @var{lhs} @var{rhs})} where @var{lhs} is the
|
|
sub-formula on the lefthand side and @var{rhs} is the sub-formula on the
|
|
right. The symbol @code{neg} represents unary negation; this list is always
|
|
of the form @samp{(neg @var{arg})}. Any other symbol @var{func} represents a
|
|
function that would be displayed in function-call notation; the symbol
|
|
@var{func} is in general always of the form @samp{calcFunc-@var{name}}.
|
|
The function cell of the symbol @var{func} should contain a Lisp function
|
|
for evaluating a call to @var{func}. This function is passed the remaining
|
|
elements of the list (themselves already evaluated) as arguments; such
|
|
functions should return @code{nil} or call @code{reject-arg} to signify
|
|
that they should be left in symbolic form, or they should return a Calc
|
|
object which represents their value, or a list of such objects if they
|
|
wish to return multiple values. (The latter case is allowed only for
|
|
functions which are the outer-level call in an expression whose value is
|
|
about to be pushed on the stack; this feature is considered obsolete
|
|
and is not used by any built-in Calc functions.)
|
|
|
|
@node Interactive Lisp Functions, Stack Lisp Functions, Data Type Formats, Internals
|
|
@subsubsection Interactive Functions
|
|
|
|
@noindent
|
|
The functions described here are used in implementing interactive Calc
|
|
commands. Note that this list is not exhaustive! If there is an
|
|
existing command that behaves similarly to the one you want to define,
|
|
you may find helpful tricks by checking the source code for that command.
|
|
|
|
@defun calc-set-command-flag flag
|
|
Set the command flag @var{flag}. This is generally a Lisp symbol, but
|
|
may in fact be anything. The effect is to add @var{flag} to the list
|
|
stored in the variable @code{calc-command-flags}, unless it is already
|
|
there. @xref{Defining Simple Commands}.
|
|
@end defun
|
|
|
|
@defun calc-clear-command-flag flag
|
|
If @var{flag} appears among the list of currently-set command flags,
|
|
remove it from that list.
|
|
@end defun
|
|
|
|
@defun calc-record-undo rec
|
|
Add the ``undo record'' @var{rec} to the list of steps to take if the
|
|
current operation should need to be undone. Stack push and pop functions
|
|
automatically call @code{calc-record-undo}, so the kinds of undo records
|
|
you might need to create take the form @samp{(set @var{sym} @var{value})},
|
|
which says that the Lisp variable @var{sym} was changed and had previously
|
|
contained @var{value}; @samp{(store @var{var} @var{value})} which says that
|
|
the Calc variable @var{var} (a string which is the name of the symbol that
|
|
contains the variable's value) was stored and its previous value was
|
|
@var{value} (either a Calc data object, or @code{nil} if the variable was
|
|
previously void); or @samp{(eval @var{undo} @var{redo} @var{args} @dots{})},
|
|
which means that to undo requires calling the function @samp{(@var{undo}
|
|
@var{args} @dots{})} and, if the undo is later redone, calling
|
|
@samp{(@var{redo} @var{args} @dots{})}.
|
|
@end defun
|
|
|
|
@defun calc-record-why msg args
|
|
Record the error or warning message @var{msg}, which is normally a string.
|
|
This message will be replayed if the user types @kbd{w} (@code{calc-why});
|
|
if the message string begins with a @samp{*}, it is considered important
|
|
enough to display even if the user doesn't type @kbd{w}. If one or more
|
|
@var{args} are present, the displayed message will be of the form,
|
|
@samp{@var{msg}: @var{arg1}, @var{arg2}, @dots{}}, where the arguments are
|
|
formatted on the assumption that they are either strings or Calc objects of
|
|
some sort. If @var{msg} is a symbol, it is the name of a Calc predicate
|
|
(such as @code{integerp} or @code{numvecp}) which the arguments did not
|
|
satisfy; it is expanded to a suitable string such as ``Expected an
|
|
integer.'' The @code{reject-arg} function calls @code{calc-record-why}
|
|
automatically; @pxref{Predicates}.
|
|
@end defun
|
|
|
|
@defun calc-is-inverse
|
|
This predicate returns true if the current command is inverse,
|
|
i.e., if the Inverse (@kbd{I} key) flag was set.
|
|
@end defun
|
|
|
|
@defun calc-is-hyperbolic
|
|
This predicate is the analogous function for the @kbd{H} key.
|
|
@end defun
|
|
|
|
@node Stack Lisp Functions, Predicates, Interactive Lisp Functions, Internals
|
|
@subsubsection Stack-Oriented Functions
|
|
|
|
@noindent
|
|
The functions described here perform various operations on the Calc
|
|
stack and trail. They are to be used in interactive Calc commands.
|
|
|
|
@defun calc-push-list vals n
|
|
Push the Calc objects in list @var{vals} onto the stack at stack level
|
|
@var{n}. If @var{n} is omitted it defaults to 1, so that the elements
|
|
are pushed at the top of the stack. If @var{n} is greater than 1, the
|
|
elements will be inserted into the stack so that the last element will
|
|
end up at level @var{n}, the next-to-last at level @var{n}+1, etc.
|
|
The elements of @var{vals} are assumed to be valid Calc objects, and
|
|
are not evaluated, rounded, or renormalized in any way. If @var{vals}
|
|
is an empty list, nothing happens.
|
|
|
|
The stack elements are pushed without any sub-formula selections.
|
|
You can give an optional third argument to this function, which must
|
|
be a list the same size as @var{vals} of selections. Each selection
|
|
must be @code{eq} to some sub-formula of the corresponding formula
|
|
in @var{vals}, or @code{nil} if that formula should have no selection.
|
|
@end defun
|
|
|
|
@defun calc-top-list n m
|
|
Return a list of the @var{n} objects starting at level @var{m} of the
|
|
stack. If @var{m} is omitted it defaults to 1, so that the elements are
|
|
taken from the top of the stack. If @var{n} is omitted, it also
|
|
defaults to 1, so that the top stack element (in the form of a
|
|
one-element list) is returned. If @var{m} is greater than 1, the
|
|
@var{m}th stack element will be at the end of the list, the @var{m}+1st
|
|
element will be next-to-last, etc. If @var{n} or @var{m} are out of
|
|
range, the command is aborted with a suitable error message. If @var{n}
|
|
is zero, the function returns an empty list. The stack elements are not
|
|
evaluated, rounded, or renormalized.
|
|
|
|
If any stack elements contain selections, and selections have not
|
|
been disabled by the @kbd{j e} (@code{calc-enable-selections}) command,
|
|
this function returns the selected portions rather than the entire
|
|
stack elements. It can be given a third ``selection-mode'' argument
|
|
which selects other behaviors. If it is the symbol @code{t}, then
|
|
a selection in any of the requested stack elements produces an
|
|
``invalid operation on selections'' error. If it is the symbol @code{full},
|
|
the whole stack entry is always returned regardless of selections.
|
|
If it is the symbol @code{sel}, the selected portion is always returned,
|
|
or @code{nil} if there is no selection. (This mode ignores the @kbd{j e}
|
|
command.) If the symbol is @code{entry}, the complete stack entry in
|
|
list form is returned; the first element of this list will be the whole
|
|
formula, and the third element will be the selection (or @code{nil}).
|
|
@end defun
|
|
|
|
@defun calc-pop-stack n m
|
|
Remove the specified elements from the stack. The parameters @var{n}
|
|
and @var{m} are defined the same as for @code{calc-top-list}. The return
|
|
value of @code{calc-pop-stack} is uninteresting.
|
|
|
|
If there are any selected sub-formulas among the popped elements, and
|
|
@kbd{j e} has not been used to disable selections, this produces an
|
|
error without changing the stack. If you supply an optional third
|
|
argument of @code{t}, the stack elements are popped even if they
|
|
contain selections.
|
|
@end defun
|
|
|
|
@defun calc-record-list vals tag
|
|
This function records one or more results in the trail. The @var{vals}
|
|
are a list of strings or Calc objects. The @var{tag} is the four-character
|
|
tag string to identify the values. If @var{tag} is omitted, a blank tag
|
|
will be used.
|
|
@end defun
|
|
|
|
@defun calc-normalize n
|
|
This function takes a Calc object and ``normalizes'' it. At the very
|
|
least this involves re-rounding floating-point values according to the
|
|
current precision and other similar jobs. Also, unless the user has
|
|
selected No-Simplify mode (@pxref{Simplification Modes}), this involves
|
|
actually evaluating a formula object by executing the function calls
|
|
it contains, and possibly also doing algebraic simplification, etc.
|
|
@end defun
|
|
|
|
@defun calc-top-list-n n m
|
|
This function is identical to @code{calc-top-list}, except that it calls
|
|
@code{calc-normalize} on the values that it takes from the stack. They
|
|
are also passed through @code{check-complete}, so that incomplete
|
|
objects will be rejected with an error message. All computational
|
|
commands should use this in preference to @code{calc-top-list}; the only
|
|
standard Calc commands that operate on the stack without normalizing
|
|
are stack management commands like @code{calc-enter} and @code{calc-roll-up}.
|
|
This function accepts the same optional selection-mode argument as
|
|
@code{calc-top-list}.
|
|
@end defun
|
|
|
|
@defun calc-top-n m
|
|
This function is a convenient form of @code{calc-top-list-n} in which only
|
|
a single element of the stack is taken and returned, rather than a list
|
|
of elements. This also accepts an optional selection-mode argument.
|
|
@end defun
|
|
|
|
@defun calc-enter-result n tag vals
|
|
This function is a convenient interface to most of the above functions.
|
|
The @var{vals} argument should be either a single Calc object, or a list
|
|
of Calc objects; the object or objects are normalized, and the top @var{n}
|
|
stack entries are replaced by the normalized objects. If @var{tag} is
|
|
non-@code{nil}, the normalized objects are also recorded in the trail.
|
|
A typical stack-based computational command would take the form,
|
|
|
|
@smallexample
|
|
(calc-enter-result @var{n} @var{tag} (cons 'calcFunc-@var{func}
|
|
(calc-top-list-n @var{n})))
|
|
@end smallexample
|
|
|
|
If any of the @var{n} stack elements replaced contain sub-formula
|
|
selections, and selections have not been disabled by @kbd{j e},
|
|
this function takes one of two courses of action. If @var{n} is
|
|
equal to the number of elements in @var{vals}, then each element of
|
|
@var{vals} is spliced into the corresponding selection; this is what
|
|
happens when you use the @key{TAB} key, or when you use a unary
|
|
arithmetic operation like @code{sqrt}. If @var{vals} has only one
|
|
element but @var{n} is greater than one, there must be only one
|
|
selection among the top @var{n} stack elements; the element from
|
|
@var{vals} is spliced into that selection. This is what happens when
|
|
you use a binary arithmetic operation like @kbd{+}. Any other
|
|
combination of @var{n} and @var{vals} is an error when selections
|
|
are present.
|
|
@end defun
|
|
|
|
@defun calc-unary-op tag func arg
|
|
This function implements a unary operator that allows a numeric prefix
|
|
argument to apply the operator over many stack entries. If the prefix
|
|
argument @var{arg} is @code{nil}, this uses @code{calc-enter-result}
|
|
as outlined above. Otherwise, it maps the function over several stack
|
|
elements; @pxref{Prefix Arguments}. For example,
|
|
|
|
@smallexample
|
|
(defun calc-zeta (arg)
|
|
(interactive "P")
|
|
(calc-unary-op "zeta" 'calcFunc-zeta arg))
|
|
@end smallexample
|
|
@end defun
|
|
|
|
@defun calc-binary-op tag func arg ident unary
|
|
This function implements a binary operator, analogously to
|
|
@code{calc-unary-op}. The optional @var{ident} and @var{unary}
|
|
arguments specify the behavior when the prefix argument is zero or
|
|
one, respectively. If the prefix is zero, the value @var{ident}
|
|
is pushed onto the stack, if specified, otherwise an error message
|
|
is displayed. If the prefix is one, the unary function @var{unary}
|
|
is applied to the top stack element, or, if @var{unary} is not
|
|
specified, nothing happens. When the argument is two or more,
|
|
the binary function @var{func} is reduced across the top @var{arg}
|
|
stack elements; when the argument is negative, the function is
|
|
mapped between the next-to-top @mathit{-@var{arg}} stack elements and the
|
|
top element.
|
|
@end defun
|
|
|
|
@defun calc-stack-size
|
|
Return the number of elements on the stack as an integer. This count
|
|
does not include elements that have been temporarily hidden by stack
|
|
truncation; @pxref{Truncating the Stack}.
|
|
@end defun
|
|
|
|
@defun calc-cursor-stack-index n
|
|
Move the point to the @var{n}th stack entry. If @var{n} is zero, this
|
|
will be the @samp{.} line. If @var{n} is from 1 to the current stack size,
|
|
this will be the beginning of the first line of that stack entry's display.
|
|
If line numbers are enabled, this will move to the first character of the
|
|
line number, not the stack entry itself.
|
|
@end defun
|
|
|
|
@defun calc-substack-height n
|
|
Return the number of lines between the beginning of the @var{n}th stack
|
|
entry and the bottom of the buffer. If @var{n} is zero, this
|
|
will be one (assuming no stack truncation). If all stack entries are
|
|
one line long (i.e., no matrices are displayed), the return value will
|
|
be equal @var{n}+1 as long as @var{n} is in range. (Note that in Big
|
|
mode, the return value includes the blank lines that separate stack
|
|
entries.)
|
|
@end defun
|
|
|
|
@defun calc-refresh
|
|
Erase the @code{*Calculator*} buffer and reformat its contents from memory.
|
|
This must be called after changing any parameter, such as the current
|
|
display radix, which might change the appearance of existing stack
|
|
entries. (During a keyboard macro invoked by the @kbd{X} key, refreshing
|
|
is suppressed, but a flag is set so that the entire stack will be refreshed
|
|
rather than just the top few elements when the macro finishes.)
|
|
@end defun
|
|
|
|
@node Predicates, Computational Lisp Functions, Stack Lisp Functions, Internals
|
|
@subsubsection Predicates
|
|
|
|
@noindent
|
|
The functions described here are predicates, that is, they return a
|
|
true/false value where @code{nil} means false and anything else means
|
|
true. These predicates are expanded by @code{defmath}, for example,
|
|
from @code{zerop} to @code{math-zerop}. In many cases they correspond
|
|
to native Lisp functions by the same name, but are extended to cover
|
|
the full range of Calc data types.
|
|
|
|
@defun zerop x
|
|
Returns true if @var{x} is numerically zero, in any of the Calc data
|
|
types. (Note that for some types, such as error forms and intervals,
|
|
it never makes sense to return true.) In @code{defmath}, the expression
|
|
@samp{(= x 0)} will automatically be converted to @samp{(math-zerop x)},
|
|
and @samp{(/= x 0)} will be converted to @samp{(not (math-zerop x))}.
|
|
@end defun
|
|
|
|
@defun negp x
|
|
Returns true if @var{x} is negative. This accepts negative real numbers
|
|
of various types, negative HMS and date forms, and intervals in which
|
|
all included values are negative. In @code{defmath}, the expression
|
|
@samp{(< x 0)} will automatically be converted to @samp{(math-negp x)},
|
|
and @samp{(>= x 0)} will be converted to @samp{(not (math-negp x))}.
|
|
@end defun
|
|
|
|
@defun posp x
|
|
Returns true if @var{x} is positive (and non-zero). For complex
|
|
numbers, none of these three predicates will return true.
|
|
@end defun
|
|
|
|
@defun looks-negp x
|
|
Returns true if @var{x} is ``negative-looking.'' This returns true if
|
|
@var{x} is a negative number, or a formula with a leading minus sign
|
|
such as @samp{-a/b}. In other words, this is an object which can be
|
|
made simpler by calling @code{(- @var{x})}.
|
|
@end defun
|
|
|
|
@defun integerp x
|
|
Returns true if @var{x} is an integer of any size.
|
|
@end defun
|
|
|
|
@defun fixnump x
|
|
Returns true if @var{x} is a native Lisp integer.
|
|
@end defun
|
|
|
|
@defun natnump x
|
|
Returns true if @var{x} is a nonnegative integer of any size.
|
|
@end defun
|
|
|
|
@defun fixnatnump x
|
|
Returns true if @var{x} is a nonnegative Lisp integer.
|
|
@end defun
|
|
|
|
@defun num-integerp x
|
|
Returns true if @var{x} is numerically an integer, i.e., either a
|
|
true integer or a float with no significant digits to the right of
|
|
the decimal point.
|
|
@end defun
|
|
|
|
@defun messy-integerp x
|
|
Returns true if @var{x} is numerically, but not literally, an integer.
|
|
A value is @code{num-integerp} if it is @code{integerp} or
|
|
@code{messy-integerp} (but it is never both at once).
|
|
@end defun
|
|
|
|
@defun num-natnump x
|
|
Returns true if @var{x} is numerically a nonnegative integer.
|
|
@end defun
|
|
|
|
@defun evenp x
|
|
Returns true if @var{x} is an even integer.
|
|
@end defun
|
|
|
|
@defun looks-evenp x
|
|
Returns true if @var{x} is an even integer, or a formula with a leading
|
|
multiplicative coefficient which is an even integer.
|
|
@end defun
|
|
|
|
@defun oddp x
|
|
Returns true if @var{x} is an odd integer.
|
|
@end defun
|
|
|
|
@defun ratp x
|
|
Returns true if @var{x} is a rational number, i.e., an integer or a
|
|
fraction.
|
|
@end defun
|
|
|
|
@defun realp x
|
|
Returns true if @var{x} is a real number, i.e., an integer, fraction,
|
|
or floating-point number.
|
|
@end defun
|
|
|
|
@defun anglep x
|
|
Returns true if @var{x} is a real number or HMS form.
|
|
@end defun
|
|
|
|
@defun floatp x
|
|
Returns true if @var{x} is a float, or a complex number, error form,
|
|
interval, date form, or modulo form in which at least one component
|
|
is a float.
|
|
@end defun
|
|
|
|
@defun complexp x
|
|
Returns true if @var{x} is a rectangular or polar complex number
|
|
(but not a real number).
|
|
@end defun
|
|
|
|
@defun rect-complexp x
|
|
Returns true if @var{x} is a rectangular complex number.
|
|
@end defun
|
|
|
|
@defun polar-complexp x
|
|
Returns true if @var{x} is a polar complex number.
|
|
@end defun
|
|
|
|
@defun numberp x
|
|
Returns true if @var{x} is a real number or a complex number.
|
|
@end defun
|
|
|
|
@defun scalarp x
|
|
Returns true if @var{x} is a real or complex number or an HMS form.
|
|
@end defun
|
|
|
|
@defun vectorp x
|
|
Returns true if @var{x} is a vector (this simply checks if its argument
|
|
is a list whose first element is the symbol @code{vec}).
|
|
@end defun
|
|
|
|
@defun numvecp x
|
|
Returns true if @var{x} is a number or vector.
|
|
@end defun
|
|
|
|
@defun matrixp x
|
|
Returns true if @var{x} is a matrix, i.e., a vector of one or more vectors,
|
|
all of the same size.
|
|
@end defun
|
|
|
|
@defun square-matrixp x
|
|
Returns true if @var{x} is a square matrix.
|
|
@end defun
|
|
|
|
@defun objectp x
|
|
Returns true if @var{x} is any numeric Calc object, including real and
|
|
complex numbers, HMS forms, date forms, error forms, intervals, and
|
|
modulo forms. (Note that error forms and intervals may include formulas
|
|
as their components; see @code{constp} below.)
|
|
@end defun
|
|
|
|
@defun objvecp x
|
|
Returns true if @var{x} is an object or a vector. This also accepts
|
|
incomplete objects, but it rejects variables and formulas (except as
|
|
mentioned above for @code{objectp}).
|
|
@end defun
|
|
|
|
@defun primp x
|
|
Returns true if @var{x} is a ``primitive'' or ``atomic'' Calc object,
|
|
i.e., one whose components cannot be regarded as sub-formulas. This
|
|
includes variables, and all @code{objectp} types except error forms
|
|
and intervals.
|
|
@end defun
|
|
|
|
@defun constp x
|
|
Returns true if @var{x} is constant, i.e., a real or complex number,
|
|
HMS form, date form, or error form, interval, or vector all of whose
|
|
components are @code{constp}.
|
|
@end defun
|
|
|
|
@defun lessp x y
|
|
Returns true if @var{x} is numerically less than @var{y}. Returns false
|
|
if @var{x} is greater than or equal to @var{y}, or if the order is
|
|
undefined or cannot be determined. Generally speaking, this works
|
|
by checking whether @samp{@var{x} - @var{y}} is @code{negp}. In
|
|
@code{defmath}, the expression @samp{(< x y)} will automatically be
|
|
converted to @samp{(lessp x y)}; expressions involving @code{>}, @code{<=},
|
|
and @code{>=} are similarly converted in terms of @code{lessp}.
|
|
@end defun
|
|
|
|
@defun beforep x y
|
|
Returns true if @var{x} comes before @var{y} in a canonical ordering
|
|
of Calc objects. If @var{x} and @var{y} are both real numbers, this
|
|
will be the same as @code{lessp}. But whereas @code{lessp} considers
|
|
other types of objects to be unordered, @code{beforep} puts any two
|
|
objects into a definite, consistent order. The @code{beforep}
|
|
function is used by the @kbd{V S} vector-sorting command, and also
|
|
by @kbd{a s} to put the terms of a product into canonical order:
|
|
This allows @samp{x y + y x} to be simplified easily to @samp{2 x y}.
|
|
@end defun
|
|
|
|
@defun equal x y
|
|
This is the standard Lisp @code{equal} predicate; it returns true if
|
|
@var{x} and @var{y} are structurally identical. This is the usual way
|
|
to compare numbers for equality, but note that @code{equal} will treat
|
|
0 and 0.0 as different.
|
|
@end defun
|
|
|
|
@defun math-equal x y
|
|
Returns true if @var{x} and @var{y} are numerically equal, either because
|
|
they are @code{equal}, or because their difference is @code{zerop}. In
|
|
@code{defmath}, the expression @samp{(= x y)} will automatically be
|
|
converted to @samp{(math-equal x y)}.
|
|
@end defun
|
|
|
|
@defun equal-int x n
|
|
Returns true if @var{x} and @var{n} are numerically equal, where @var{n}
|
|
is a fixnum which is not a multiple of 10. This will automatically be
|
|
used by @code{defmath} in place of the more general @code{math-equal}
|
|
whenever possible.
|
|
@end defun
|
|
|
|
@defun nearly-equal x y
|
|
Returns true if @var{x} and @var{y}, as floating-point numbers, are
|
|
equal except possibly in the last decimal place. For example,
|
|
314.159 and 314.166 are considered nearly equal if the current
|
|
precision is 6 (since they differ by 7 units), but not if the current
|
|
precision is 7 (since they differ by 70 units). Most functions which
|
|
use series expansions use @code{with-extra-prec} to evaluate the
|
|
series with 2 extra digits of precision, then use @code{nearly-equal}
|
|
to decide when the series has converged; this guards against cumulative
|
|
error in the series evaluation without doing extra work which would be
|
|
lost when the result is rounded back down to the current precision.
|
|
In @code{defmath}, this can be written @samp{(~= @var{x} @var{y})}.
|
|
The @var{x} and @var{y} can be numbers of any kind, including complex.
|
|
@end defun
|
|
|
|
@defun nearly-zerop x y
|
|
Returns true if @var{x} is nearly zero, compared to @var{y}. This
|
|
checks whether @var{x} plus @var{y} would by be @code{nearly-equal}
|
|
to @var{y} itself, to within the current precision, in other words,
|
|
if adding @var{x} to @var{y} would have a negligible effect on @var{y}
|
|
due to roundoff error. @var{X} may be a real or complex number, but
|
|
@var{y} must be real.
|
|
@end defun
|
|
|
|
@defun is-true x
|
|
Return true if the formula @var{x} represents a true value in
|
|
Calc, not Lisp, terms. It tests if @var{x} is a non-zero number
|
|
or a provably non-zero formula.
|
|
@end defun
|
|
|
|
@defun reject-arg val pred
|
|
Abort the current function evaluation due to unacceptable argument values.
|
|
This calls @samp{(calc-record-why @var{pred} @var{val})}, then signals a
|
|
Lisp error which @code{normalize} will trap. The net effect is that the
|
|
function call which led here will be left in symbolic form.
|
|
@end defun
|
|
|
|
@defun inexact-value
|
|
If Symbolic mode is enabled, this will signal an error that causes
|
|
@code{normalize} to leave the formula in symbolic form, with the message
|
|
``Inexact result.'' (This function has no effect when not in Symbolic mode.)
|
|
Note that if your function calls @samp{(sin 5)} in Symbolic mode, the
|
|
@code{sin} function will call @code{inexact-value}, which will cause your
|
|
function to be left unsimplified. You may instead wish to call
|
|
@samp{(normalize (list 'calcFunc-sin 5))}, which in Symbolic mode will
|
|
return the formula @samp{sin(5)} to your function.
|
|
@end defun
|
|
|
|
@defun overflow
|
|
This signals an error that will be reported as a floating-point overflow.
|
|
@end defun
|
|
|
|
@defun underflow
|
|
This signals a floating-point underflow.
|
|
@end defun
|
|
|
|
@node Computational Lisp Functions, Vector Lisp Functions, Predicates, Internals
|
|
@subsubsection Computational Functions
|
|
|
|
@noindent
|
|
The functions described here do the actual computational work of the
|
|
Calculator. In addition to these, note that any function described in
|
|
the main body of this manual may be called from Lisp; for example, if
|
|
the documentation refers to the @code{calc-sqrt} [@code{sqrt}] command,
|
|
this means @code{calc-sqrt} is an interactive stack-based square-root
|
|
command and @code{sqrt} (which @code{defmath} expands to @code{calcFunc-sqrt})
|
|
is the actual Lisp function for taking square roots.
|
|
|
|
The functions @code{math-add}, @code{math-sub}, @code{math-mul},
|
|
@code{math-div}, @code{math-mod}, and @code{math-neg} are not included
|
|
in this list, since @code{defmath} allows you to write native Lisp
|
|
@code{+}, @code{-}, @code{*}, @code{/}, @code{%}, and unary @code{-},
|
|
respectively, instead.
|
|
|
|
@defun normalize val
|
|
(Full form: @code{math-normalize}.)
|
|
Reduce the value @var{val} to standard form. For example, if @var{val}
|
|
is a fixnum, it will be converted to a bignum if it is too large, and
|
|
if @var{val} is a bignum it will be normalized by clipping off trailing
|
|
(i.e., most-significant) zero digits and converting to a fixnum if it is
|
|
small. All the various data types are similarly converted to their standard
|
|
forms. Variables are left alone, but function calls are actually evaluated
|
|
in formulas. For example, normalizing @samp{(+ 2 (calcFunc-abs -4))} will
|
|
return 6.
|
|
|
|
If a function call fails, because the function is void or has the wrong
|
|
number of parameters, or because it returns @code{nil} or calls
|
|
@code{reject-arg} or @code{inexact-result}, @code{normalize} returns
|
|
the formula still in symbolic form.
|
|
|
|
If the current simplification mode is ``none'' or ``numeric arguments
|
|
only,'' @code{normalize} will act appropriately. However, the more
|
|
powerful simplification modes (like Algebraic Simplification) are
|
|
not handled by @code{normalize}. They are handled by @code{calc-normalize},
|
|
which calls @code{normalize} and possibly some other routines, such
|
|
as @code{simplify} or @code{simplify-units}. Programs generally will
|
|
never call @code{calc-normalize} except when popping or pushing values
|
|
on the stack.
|
|
@end defun
|
|
|
|
@defun evaluate-expr expr
|
|
Replace all variables in @var{expr} that have values with their values,
|
|
then use @code{normalize} to simplify the result. This is what happens
|
|
when you press the @kbd{=} key interactively.
|
|
@end defun
|
|
|
|
@defmac with-extra-prec n body
|
|
Evaluate the Lisp forms in @var{body} with precision increased by @var{n}
|
|
digits. This is a macro which expands to
|
|
|
|
@smallexample
|
|
(math-normalize
|
|
(let ((calc-internal-prec (+ calc-internal-prec @var{n})))
|
|
@var{body}))
|
|
@end smallexample
|
|
|
|
The surrounding call to @code{math-normalize} causes a floating-point
|
|
result to be rounded down to the original precision afterwards. This
|
|
is important because some arithmetic operations assume a number's
|
|
mantissa contains no more digits than the current precision allows.
|
|
@end defmac
|
|
|
|
@defun make-frac n d
|
|
Build a fraction @samp{@var{n}:@var{d}}. This is equivalent to calling
|
|
@samp{(normalize (list 'frac @var{n} @var{d}))}, but more efficient.
|
|
@end defun
|
|
|
|
@defun make-float mant exp
|
|
Build a floating-point value out of @var{mant} and @var{exp}, both
|
|
of which are arbitrary integers. This function will return a
|
|
properly normalized float value, or signal an overflow or underflow
|
|
if @var{exp} is out of range.
|
|
@end defun
|
|
|
|
@defun make-sdev x sigma
|
|
Build an error form out of @var{x} and the absolute value of @var{sigma}.
|
|
If @var{sigma} is zero, the result is the number @var{x} directly.
|
|
If @var{sigma} is negative or complex, its absolute value is used.
|
|
If @var{x} or @var{sigma} is not a valid type of object for use in
|
|
error forms, this calls @code{reject-arg}.
|
|
@end defun
|
|
|
|
@defun make-intv mask lo hi
|
|
Build an interval form out of @var{mask} (which is assumed to be an
|
|
integer from 0 to 3), and the limits @var{lo} and @var{hi}. If
|
|
@var{lo} is greater than @var{hi}, an empty interval form is returned.
|
|
This calls @code{reject-arg} if @var{lo} or @var{hi} is unsuitable.
|
|
@end defun
|
|
|
|
@defun sort-intv mask lo hi
|
|
Build an interval form, similar to @code{make-intv}, except that if
|
|
@var{lo} is less than @var{hi} they are simply exchanged, and the
|
|
bits of @var{mask} are swapped accordingly.
|
|
@end defun
|
|
|
|
@defun make-mod n m
|
|
Build a modulo form out of @var{n} and the modulus @var{m}. Since modulo
|
|
forms do not allow formulas as their components, if @var{n} or @var{m}
|
|
is not a real number or HMS form the result will be a formula which
|
|
is a call to @code{makemod}, the algebraic version of this function.
|
|
@end defun
|
|
|
|
@defun float x
|
|
Convert @var{x} to floating-point form. Integers and fractions are
|
|
converted to numerically equivalent floats; components of complex
|
|
numbers, vectors, HMS forms, date forms, error forms, intervals, and
|
|
modulo forms are recursively floated. If the argument is a variable
|
|
or formula, this calls @code{reject-arg}.
|
|
@end defun
|
|
|
|
@defun compare x y
|
|
Compare the numbers @var{x} and @var{y}, and return @mathit{-1} if
|
|
@samp{(lessp @var{x} @var{y})}, 1 if @samp{(lessp @var{y} @var{x})},
|
|
0 if @samp{(math-equal @var{x} @var{y})}, or 2 if the order is
|
|
undefined or cannot be determined.
|
|
@end defun
|
|
|
|
@defun numdigs n
|
|
Return the number of digits of integer @var{n}, effectively
|
|
@samp{ceil(log10(@var{n}))}, but much more efficient. Zero is
|
|
considered to have zero digits.
|
|
@end defun
|
|
|
|
@defun scale-int x n
|
|
Shift integer @var{x} left @var{n} decimal digits, or right @mathit{-@var{n}}
|
|
digits with truncation toward zero.
|
|
@end defun
|
|
|
|
@defun scale-rounding x n
|
|
Like @code{scale-int}, except that a right shift rounds to the nearest
|
|
integer rather than truncating.
|
|
@end defun
|
|
|
|
@defun fixnum n
|
|
Return the integer @var{n} as a fixnum, i.e., a native Lisp integer.
|
|
If @var{n} is outside the permissible range for Lisp integers (usually
|
|
24 binary bits) the result is undefined.
|
|
@end defun
|
|
|
|
@defun sqr x
|
|
Compute the square of @var{x}; short for @samp{(* @var{x} @var{x})}.
|
|
@end defun
|
|
|
|
@defun quotient x y
|
|
Divide integer @var{x} by integer @var{y}; return an integer quotient
|
|
and discard the remainder. If @var{x} or @var{y} is negative, the
|
|
direction of rounding is undefined.
|
|
@end defun
|
|
|
|
@defun idiv x y
|
|
Perform an integer division; if @var{x} and @var{y} are both nonnegative
|
|
integers, this uses the @code{quotient} function, otherwise it computes
|
|
@samp{floor(@var{x}/@var{y})}. Thus the result is well-defined but
|
|
slower than for @code{quotient}.
|
|
@end defun
|
|
|
|
@defun imod x y
|
|
Divide integer @var{x} by integer @var{y}; return the integer remainder
|
|
and discard the quotient. Like @code{quotient}, this works only for
|
|
integer arguments and is not well-defined for negative arguments.
|
|
For a more well-defined result, use @samp{(% @var{x} @var{y})}.
|
|
@end defun
|
|
|
|
@defun idivmod x y
|
|
Divide integer @var{x} by integer @var{y}; return a cons cell whose
|
|
@code{car} is @samp{(quotient @var{x} @var{y})} and whose @code{cdr}
|
|
is @samp{(imod @var{x} @var{y})}.
|
|
@end defun
|
|
|
|
@defun pow x y
|
|
Compute @var{x} to the power @var{y}. In @code{defmath} code, this can
|
|
also be written @samp{(^ @var{x} @var{y})} or
|
|
@w{@samp{(expt @var{x} @var{y})}}.
|
|
@end defun
|
|
|
|
@defun abs-approx x
|
|
Compute a fast approximation to the absolute value of @var{x}. For
|
|
example, for a rectangular complex number the result is the sum of
|
|
the absolute values of the components.
|
|
@end defun
|
|
|
|
@findex e
|
|
@findex gamma-const
|
|
@findex ln-2
|
|
@findex ln-10
|
|
@findex phi
|
|
@findex pi-over-2
|
|
@findex pi-over-4
|
|
@findex pi-over-180
|
|
@findex sqrt-two-pi
|
|
@findex sqrt-e
|
|
@findex two-pi
|
|
@defun pi
|
|
The function @samp{(pi)} computes @samp{pi} to the current precision.
|
|
Other related constant-generating functions are @code{two-pi},
|
|
@code{pi-over-2}, @code{pi-over-4}, @code{pi-over-180}, @code{sqrt-two-pi},
|
|
@code{e}, @code{sqrt-e}, @code{ln-2}, @code{ln-10}, @code{phi} and
|
|
@code{gamma-const}. Each function returns a floating-point value in the
|
|
current precision, and each uses caching so that all calls after the
|
|
first are essentially free.
|
|
@end defun
|
|
|
|
@defmac math-defcache @var{func} @var{initial} @var{form}
|
|
This macro, usually used as a top-level call like @code{defun} or
|
|
@code{defvar}, defines a new cached constant analogous to @code{pi}, etc.
|
|
It defines a function @code{func} which returns the requested value;
|
|
if @var{initial} is non-@code{nil} it must be a @samp{(float @dots{})}
|
|
form which serves as an initial value for the cache. If @var{func}
|
|
is called when the cache is empty or does not have enough digits to
|
|
satisfy the current precision, the Lisp expression @var{form} is evaluated
|
|
with the current precision increased by four, and the result minus its
|
|
two least significant digits is stored in the cache. For example,
|
|
calling @samp{(pi)} with a precision of 30 computes @samp{pi} to 34
|
|
digits, rounds it down to 32 digits for future use, then rounds it
|
|
again to 30 digits for use in the present request.
|
|
@end defmac
|
|
|
|
@findex half-circle
|
|
@findex quarter-circle
|
|
@defun full-circle symb
|
|
If the current angular mode is Degrees or HMS, this function returns the
|
|
integer 360. In Radians mode, this function returns either the
|
|
corresponding value in radians to the current precision, or the formula
|
|
@samp{2*pi}, depending on the Symbolic mode. There are also similar
|
|
function @code{half-circle} and @code{quarter-circle}.
|
|
@end defun
|
|
|
|
@defun power-of-2 n
|
|
Compute two to the integer power @var{n}, as a (potentially very large)
|
|
integer. Powers of two are cached, so only the first call for a
|
|
particular @var{n} is expensive.
|
|
@end defun
|
|
|
|
@defun integer-log2 n
|
|
Compute the base-2 logarithm of @var{n}, which must be an integer which
|
|
is a power of two. If @var{n} is not a power of two, this function will
|
|
return @code{nil}.
|
|
@end defun
|
|
|
|
@defun div-mod a b m
|
|
Divide @var{a} by @var{b}, modulo @var{m}. This returns @code{nil} if
|
|
there is no solution, or if any of the arguments are not integers.
|
|
@end defun
|
|
|
|
@defun pow-mod a b m
|
|
Compute @var{a} to the power @var{b}, modulo @var{m}. If @var{a},
|
|
@var{b}, and @var{m} are integers, this uses an especially efficient
|
|
algorithm. Otherwise, it simply computes @samp{(% (^ a b) m)}.
|
|
@end defun
|
|
|
|
@defun isqrt n
|
|
Compute the integer square root of @var{n}. This is the square root
|
|
of @var{n} rounded down toward zero, i.e., @samp{floor(sqrt(@var{n}))}.
|
|
If @var{n} is itself an integer, the computation is especially efficient.
|
|
@end defun
|
|
|
|
@defun to-hms a ang
|
|
Convert the argument @var{a} into an HMS form. If @var{ang} is specified,
|
|
it is the angular mode in which to interpret @var{a}, either @code{deg}
|
|
or @code{rad}. Otherwise, the current angular mode is used. If @var{a}
|
|
is already an HMS form it is returned as-is.
|
|
@end defun
|
|
|
|
@defun from-hms a ang
|
|
Convert the HMS form @var{a} into a real number. If @var{ang} is specified,
|
|
it is the angular mode in which to express the result, otherwise the
|
|
current angular mode is used. If @var{a} is already a real number, it
|
|
is returned as-is.
|
|
@end defun
|
|
|
|
@defun to-radians a
|
|
Convert the number or HMS form @var{a} to radians from the current
|
|
angular mode.
|
|
@end defun
|
|
|
|
@defun from-radians a
|
|
Convert the number @var{a} from radians to the current angular mode.
|
|
If @var{a} is a formula, this returns the formula @samp{deg(@var{a})}.
|
|
@end defun
|
|
|
|
@defun to-radians-2 a
|
|
Like @code{to-radians}, except that in Symbolic mode a degrees to
|
|
radians conversion yields a formula like @samp{@var{a}*pi/180}.
|
|
@end defun
|
|
|
|
@defun from-radians-2 a
|
|
Like @code{from-radians}, except that in Symbolic mode a radians to
|
|
degrees conversion yields a formula like @samp{@var{a}*180/pi}.
|
|
@end defun
|
|
|
|
@defun random-digit
|
|
Produce a random base-1000 digit in the range 0 to 999.
|
|
@end defun
|
|
|
|
@defun random-digits n
|
|
Produce a random @var{n}-digit integer; this will be an integer
|
|
in the interval @samp{[0, 10^@var{n})}.
|
|
@end defun
|
|
|
|
@defun random-float
|
|
Produce a random float in the interval @samp{[0, 1)}.
|
|
@end defun
|
|
|
|
@defun prime-test n iters
|
|
Determine whether the integer @var{n} is prime. Return a list which has
|
|
one of these forms: @samp{(nil @var{f})} means the number is non-prime
|
|
because it was found to be divisible by @var{f}; @samp{(nil)} means it
|
|
was found to be non-prime by table look-up (so no factors are known);
|
|
@samp{(nil unknown)} means it is definitely non-prime but no factors
|
|
are known because @var{n} was large enough that Fermat's probabilistic
|
|
test had to be used; @samp{(t)} means the number is definitely prime;
|
|
and @samp{(maybe @var{i} @var{p})} means that Fermat's test, after @var{i}
|
|
iterations, is @var{p} percent sure that the number is prime. The
|
|
@var{iters} parameter is the number of Fermat iterations to use, in the
|
|
case that this is necessary. If @code{prime-test} returns ``maybe,''
|
|
you can call it again with the same @var{n} to get a greater certainty;
|
|
@code{prime-test} remembers where it left off.
|
|
@end defun
|
|
|
|
@defun to-simple-fraction f
|
|
If @var{f} is a floating-point number which can be represented exactly
|
|
as a small rational number. return that number, else return @var{f}.
|
|
For example, 0.75 would be converted to 3:4. This function is very
|
|
fast.
|
|
@end defun
|
|
|
|
@defun to-fraction f tol
|
|
Find a rational approximation to floating-point number @var{f} to within
|
|
a specified tolerance @var{tol}; this corresponds to the algebraic
|
|
function @code{frac}, and can be rather slow.
|
|
@end defun
|
|
|
|
@defun quarter-integer n
|
|
If @var{n} is an integer or integer-valued float, this function
|
|
returns zero. If @var{n} is a half-integer (i.e., an integer plus
|
|
@mathit{1:2} or 0.5), it returns 2. If @var{n} is a quarter-integer,
|
|
it returns 1 or 3. If @var{n} is anything else, this function
|
|
returns @code{nil}.
|
|
@end defun
|
|
|
|
@node Vector Lisp Functions, Symbolic Lisp Functions, Computational Lisp Functions, Internals
|
|
@subsubsection Vector Functions
|
|
|
|
@noindent
|
|
The functions described here perform various operations on vectors and
|
|
matrices.
|
|
|
|
@defun math-concat x y
|
|
Do a vector concatenation; this operation is written @samp{@var{x} | @var{y}}
|
|
in a symbolic formula. @xref{Building Vectors}.
|
|
@end defun
|
|
|
|
@defun vec-length v
|
|
Return the length of vector @var{v}. If @var{v} is not a vector, the
|
|
result is zero. If @var{v} is a matrix, this returns the number of
|
|
rows in the matrix.
|
|
@end defun
|
|
|
|
@defun mat-dimens m
|
|
Determine the dimensions of vector or matrix @var{m}. If @var{m} is not
|
|
a vector, the result is an empty list. If @var{m} is a plain vector
|
|
but not a matrix, the result is a one-element list containing the length
|
|
of the vector. If @var{m} is a matrix with @var{r} rows and @var{c} columns,
|
|
the result is the list @samp{(@var{r} @var{c})}. Higher-order tensors
|
|
produce lists of more than two dimensions. Note that the object
|
|
@samp{[[1, 2, 3], [4, 5]]} is a vector of vectors not all the same size,
|
|
and is treated by this and other Calc routines as a plain vector of two
|
|
elements.
|
|
@end defun
|
|
|
|
@defun dimension-error
|
|
Abort the current function with a message of ``Dimension error.''
|
|
The Calculator will leave the function being evaluated in symbolic
|
|
form; this is really just a special case of @code{reject-arg}.
|
|
@end defun
|
|
|
|
@defun build-vector args
|
|
Return a Calc vector with @var{args} as elements.
|
|
For example, @samp{(build-vector 1 2 3)} returns the Calc vector
|
|
@samp{[1, 2, 3]}, stored internally as the list @samp{(vec 1 2 3)}.
|
|
@end defun
|
|
|
|
@defun make-vec obj dims
|
|
Return a Calc vector or matrix all of whose elements are equal to
|
|
@var{obj}. For example, @samp{(make-vec 27 3 4)} returns a 3x4 matrix
|
|
filled with 27's.
|
|
@end defun
|
|
|
|
@defun row-matrix v
|
|
If @var{v} is a plain vector, convert it into a row matrix, i.e.,
|
|
a matrix whose single row is @var{v}. If @var{v} is already a matrix,
|
|
leave it alone.
|
|
@end defun
|
|
|
|
@defun col-matrix v
|
|
If @var{v} is a plain vector, convert it into a column matrix, i.e., a
|
|
matrix with each element of @var{v} as a separate row. If @var{v} is
|
|
already a matrix, leave it alone.
|
|
@end defun
|
|
|
|
@defun map-vec f v
|
|
Map the Lisp function @var{f} over the Calc vector @var{v}. For example,
|
|
@samp{(map-vec 'math-floor v)} returns a vector of the floored components
|
|
of vector @var{v}.
|
|
@end defun
|
|
|
|
@defun map-vec-2 f a b
|
|
Map the Lisp function @var{f} over the two vectors @var{a} and @var{b}.
|
|
If @var{a} and @var{b} are vectors of equal length, the result is a
|
|
vector of the results of calling @samp{(@var{f} @var{ai} @var{bi})}
|
|
for each pair of elements @var{ai} and @var{bi}. If either @var{a} or
|
|
@var{b} is a scalar, it is matched with each value of the other vector.
|
|
For example, @samp{(map-vec-2 'math-add v 1)} returns the vector @var{v}
|
|
with each element increased by one. Note that using @samp{'+} would not
|
|
work here, since @code{defmath} does not expand function names everywhere,
|
|
just where they are in the function position of a Lisp expression.
|
|
@end defun
|
|
|
|
@defun reduce-vec f v
|
|
Reduce the function @var{f} over the vector @var{v}. For example, if
|
|
@var{v} is @samp{[10, 20, 30, 40]}, this calls @samp{(f (f (f 10 20) 30) 40)}.
|
|
If @var{v} is a matrix, this reduces over the rows of @var{v}.
|
|
@end defun
|
|
|
|
@defun reduce-cols f m
|
|
Reduce the function @var{f} over the columns of matrix @var{m}. For
|
|
example, if @var{m} is @samp{[[1, 2], [3, 4], [5, 6]]}, the result
|
|
is a vector of the two elements @samp{(f (f 1 3) 5)} and @samp{(f (f 2 4) 6)}.
|
|
@end defun
|
|
|
|
@defun mat-row m n
|
|
Return the @var{n}th row of matrix @var{m}. This is equivalent to
|
|
@samp{(elt m n)}. For a slower but safer version, use @code{mrow}.
|
|
(@xref{Extracting Elements}.)
|
|
@end defun
|
|
|
|
@defun mat-col m n
|
|
Return the @var{n}th column of matrix @var{m}, in the form of a vector.
|
|
The arguments are not checked for correctness.
|
|
@end defun
|
|
|
|
@defun mat-less-row m n
|
|
Return a copy of matrix @var{m} with its @var{n}th row deleted. The
|
|
number @var{n} must be in range from 1 to the number of rows in @var{m}.
|
|
@end defun
|
|
|
|
@defun mat-less-col m n
|
|
Return a copy of matrix @var{m} with its @var{n}th column deleted.
|
|
@end defun
|
|
|
|
@defun transpose m
|
|
Return the transpose of matrix @var{m}.
|
|
@end defun
|
|
|
|
@defun flatten-vector v
|
|
Flatten nested vector @var{v} into a vector of scalars. For example,
|
|
if @var{v} is @samp{[[1, 2, 3], [4, 5]]} the result is @samp{[1, 2, 3, 4, 5]}.
|
|
@end defun
|
|
|
|
@defun copy-matrix m
|
|
If @var{m} is a matrix, return a copy of @var{m}. This maps
|
|
@code{copy-sequence} over the rows of @var{m}; in Lisp terms, each
|
|
element of the result matrix will be @code{eq} to the corresponding
|
|
element of @var{m}, but none of the @code{cons} cells that make up
|
|
the structure of the matrix will be @code{eq}. If @var{m} is a plain
|
|
vector, this is the same as @code{copy-sequence}.
|
|
@end defun
|
|
|
|
@defun swap-rows m r1 r2
|
|
Exchange rows @var{r1} and @var{r2} of matrix @var{m} in-place. In
|
|
other words, unlike most of the other functions described here, this
|
|
function changes @var{m} itself rather than building up a new result
|
|
matrix. The return value is @var{m}, i.e., @samp{(eq (swap-rows m 1 2) m)}
|
|
is true, with the side effect of exchanging the first two rows of
|
|
@var{m}.
|
|
@end defun
|
|
|
|
@node Symbolic Lisp Functions, Formatting Lisp Functions, Vector Lisp Functions, Internals
|
|
@subsubsection Symbolic Functions
|
|
|
|
@noindent
|
|
The functions described here operate on symbolic formulas in the
|
|
Calculator.
|
|
|
|
@defun calc-prepare-selection num
|
|
Prepare a stack entry for selection operations. If @var{num} is
|
|
omitted, the stack entry containing the cursor is used; otherwise,
|
|
it is the number of the stack entry to use. This function stores
|
|
useful information about the current stack entry into a set of
|
|
variables. @code{calc-selection-cache-num} contains the number of
|
|
the stack entry involved (equal to @var{num} if you specified it);
|
|
@code{calc-selection-cache-entry} contains the stack entry as a
|
|
list (such as @code{calc-top-list} would return with @code{entry}
|
|
as the selection mode); and @code{calc-selection-cache-comp} contains
|
|
a special ``tagged'' composition (@pxref{Formatting Lisp Functions})
|
|
which allows Calc to relate cursor positions in the buffer with
|
|
their corresponding sub-formulas.
|
|
|
|
A slight complication arises in the selection mechanism because
|
|
formulas may contain small integers. For example, in the vector
|
|
@samp{[1, 2, 1]} the first and last elements are @code{eq} to each
|
|
other; selections are recorded as the actual Lisp object that
|
|
appears somewhere in the tree of the whole formula, but storing
|
|
@code{1} would falsely select both @code{1}'s in the vector. So
|
|
@code{calc-prepare-selection} also checks the stack entry and
|
|
replaces any plain integers with ``complex number'' lists of the form
|
|
@samp{(cplx @var{n} 0)}. This list will be displayed the same as a
|
|
plain @var{n} and the change will be completely invisible to the
|
|
user, but it will guarantee that no two sub-formulas of the stack
|
|
entry will be @code{eq} to each other. Next time the stack entry
|
|
is involved in a computation, @code{calc-normalize} will replace
|
|
these lists with plain numbers again, again invisibly to the user.
|
|
@end defun
|
|
|
|
@defun calc-encase-atoms x
|
|
This modifies the formula @var{x} to ensure that each part of the
|
|
formula is a unique atom, using the @samp{(cplx @var{n} 0)} trick
|
|
described above. This function may use @code{setcar} to modify
|
|
the formula in-place.
|
|
@end defun
|
|
|
|
@defun calc-find-selected-part
|
|
Find the smallest sub-formula of the current formula that contains
|
|
the cursor. This assumes @code{calc-prepare-selection} has been
|
|
called already. If the cursor is not actually on any part of the
|
|
formula, this returns @code{nil}.
|
|
@end defun
|
|
|
|
@defun calc-change-current-selection selection
|
|
Change the currently prepared stack element's selection to
|
|
@var{selection}, which should be @code{eq} to some sub-formula
|
|
of the stack element, or @code{nil} to unselect the formula.
|
|
The stack element's appearance in the Calc buffer is adjusted
|
|
to reflect the new selection.
|
|
@end defun
|
|
|
|
@defun calc-find-nth-part expr n
|
|
Return the @var{n}th sub-formula of @var{expr}. This function is used
|
|
by the selection commands, and (unless @kbd{j b} has been used) treats
|
|
sums and products as flat many-element formulas. Thus if @var{expr}
|
|
is @samp{((a + b) - c) + d}, calling @code{calc-find-nth-part} with
|
|
@var{n} equal to four will return @samp{d}.
|
|
@end defun
|
|
|
|
@defun calc-find-parent-formula expr part
|
|
Return the sub-formula of @var{expr} which immediately contains
|
|
@var{part}. If @var{expr} is @samp{a*b + (c+1)*d} and @var{part}
|
|
is @code{eq} to the @samp{c+1} term of @var{expr}, then this function
|
|
will return @samp{(c+1)*d}. If @var{part} turns out not to be a
|
|
sub-formula of @var{expr}, the function returns @code{nil}. If
|
|
@var{part} is @code{eq} to @var{expr}, the function returns @code{t}.
|
|
This function does not take associativity into account.
|
|
@end defun
|
|
|
|
@defun calc-find-assoc-parent-formula expr part
|
|
This is the same as @code{calc-find-parent-formula}, except that
|
|
(unless @kbd{j b} has been used) it continues widening the selection
|
|
to contain a complete level of the formula. Given @samp{a} from
|
|
@samp{((a + b) - c) + d}, @code{calc-find-parent-formula} will
|
|
return @samp{a + b} but @code{calc-find-assoc-parent-formula} will
|
|
return the whole expression.
|
|
@end defun
|
|
|
|
@defun calc-grow-assoc-formula expr part
|
|
This expands sub-formula @var{part} of @var{expr} to encompass a
|
|
complete level of the formula. If @var{part} and its immediate
|
|
parent are not compatible associative operators, or if @kbd{j b}
|
|
has been used, this simply returns @var{part}.
|
|
@end defun
|
|
|
|
@defun calc-find-sub-formula expr part
|
|
This finds the immediate sub-formula of @var{expr} which contains
|
|
@var{part}. It returns an index @var{n} such that
|
|
@samp{(calc-find-nth-part @var{expr} @var{n})} would return @var{part}.
|
|
If @var{part} is not a sub-formula of @var{expr}, it returns @code{nil}.
|
|
If @var{part} is @code{eq} to @var{expr}, it returns @code{t}. This
|
|
function does not take associativity into account.
|
|
@end defun
|
|
|
|
@defun calc-replace-sub-formula expr old new
|
|
This function returns a copy of formula @var{expr}, with the
|
|
sub-formula that is @code{eq} to @var{old} replaced by @var{new}.
|
|
@end defun
|
|
|
|
@defun simplify expr
|
|
Simplify the expression @var{expr} by applying various algebraic rules.
|
|
This is what the @w{@kbd{a s}} (@code{calc-simplify}) command uses. This
|
|
always returns a copy of the expression; the structure @var{expr} points
|
|
to remains unchanged in memory.
|
|
|
|
More precisely, here is what @code{simplify} does: The expression is
|
|
first normalized and evaluated by calling @code{normalize}. If any
|
|
@code{AlgSimpRules} have been defined, they are then applied. Then
|
|
the expression is traversed in a depth-first, bottom-up fashion; at
|
|
each level, any simplifications that can be made are made until no
|
|
further changes are possible. Once the entire formula has been
|
|
traversed in this way, it is compared with the original formula (from
|
|
before the call to @code{normalize}) and, if it has changed,
|
|
the entire procedure is repeated (starting with @code{normalize})
|
|
until no further changes occur. Usually only two iterations are
|
|
needed:@: one to simplify the formula, and another to verify that no
|
|
further simplifications were possible.
|
|
@end defun
|
|
|
|
@defun simplify-extended expr
|
|
Simplify the expression @var{expr}, with additional rules enabled that
|
|
help do a more thorough job, while not being entirely ``safe'' in all
|
|
circumstances. (For example, this mode will simplify @samp{sqrt(x^2)}
|
|
to @samp{x}, which is only valid when @var{x} is positive.) This is
|
|
implemented by temporarily binding the variable @code{math-living-dangerously}
|
|
to @code{t} (using a @code{let} form) and calling @code{simplify}.
|
|
Dangerous simplification rules are written to check this variable
|
|
before taking any action.
|
|
@end defun
|
|
|
|
@defun simplify-units expr
|
|
Simplify the expression @var{expr}, treating variable names as units
|
|
whenever possible. This works by binding the variable
|
|
@code{math-simplifying-units} to @code{t} while calling @code{simplify}.
|
|
@end defun
|
|
|
|
@defmac math-defsimplify funcs body
|
|
Register a new simplification rule; this is normally called as a top-level
|
|
form, like @code{defun} or @code{defmath}. If @var{funcs} is a symbol
|
|
(like @code{+} or @code{calcFunc-sqrt}), this simplification rule is
|
|
applied to the formulas which are calls to the specified function. Or,
|
|
@var{funcs} can be a list of such symbols; the rule applies to all
|
|
functions on the list. The @var{body} is written like the body of a
|
|
function with a single argument called @code{expr}. The body will be
|
|
executed with @code{expr} bound to a formula which is a call to one of
|
|
the functions @var{funcs}. If the function body returns @code{nil}, or
|
|
if it returns a result @code{equal} to the original @code{expr}, it is
|
|
ignored and Calc goes on to try the next simplification rule that applies.
|
|
If the function body returns something different, that new formula is
|
|
substituted for @var{expr} in the original formula.
|
|
|
|
At each point in the formula, rules are tried in the order of the
|
|
original calls to @code{math-defsimplify}; the search stops after the
|
|
first rule that makes a change. Thus later rules for that same
|
|
function will not have a chance to trigger until the next iteration
|
|
of the main @code{simplify} loop.
|
|
|
|
Note that, since @code{defmath} is not being used here, @var{body} must
|
|
be written in true Lisp code without the conveniences that @code{defmath}
|
|
provides. If you prefer, you can have @var{body} simply call another
|
|
function (defined with @code{defmath}) which does the real work.
|
|
|
|
The arguments of a function call will already have been simplified
|
|
before any rules for the call itself are invoked. Since a new argument
|
|
list is consed up when this happens, this means that the rule's body is
|
|
allowed to rearrange the function's arguments destructively if that is
|
|
convenient. Here is a typical example of a simplification rule:
|
|
|
|
@smallexample
|
|
(math-defsimplify calcFunc-arcsinh
|
|
(or (and (math-looks-negp (nth 1 expr))
|
|
(math-neg (list 'calcFunc-arcsinh
|
|
(math-neg (nth 1 expr)))))
|
|
(and (eq (car-safe (nth 1 expr)) 'calcFunc-sinh)
|
|
(or math-living-dangerously
|
|
(math-known-realp (nth 1 (nth 1 expr))))
|
|
(nth 1 (nth 1 expr)))))
|
|
@end smallexample
|
|
|
|
This is really a pair of rules written with one @code{math-defsimplify}
|
|
for convenience; the first replaces @samp{arcsinh(-x)} with
|
|
@samp{-arcsinh(x)}, and the second, which is safe only for real @samp{x},
|
|
replaces @samp{arcsinh(sinh(x))} with @samp{x}.
|
|
@end defmac
|
|
|
|
@defun common-constant-factor expr
|
|
Check @var{expr} to see if it is a sum of terms all multiplied by the
|
|
same rational value. If so, return this value. If not, return @code{nil}.
|
|
For example, if called on @samp{6x + 9y + 12z}, it would return 3, since
|
|
3 is a common factor of all the terms.
|
|
@end defun
|
|
|
|
@defun cancel-common-factor expr factor
|
|
Assuming @var{expr} is a sum with @var{factor} as a common factor,
|
|
divide each term of the sum by @var{factor}. This is done by
|
|
destructively modifying parts of @var{expr}, on the assumption that
|
|
it is being used by a simplification rule (where such things are
|
|
allowed; see above). For example, consider this built-in rule for
|
|
square roots:
|
|
|
|
@smallexample
|
|
(math-defsimplify calcFunc-sqrt
|
|
(let ((fac (math-common-constant-factor (nth 1 expr))))
|
|
(and fac (not (eq fac 1))
|
|
(math-mul (math-normalize (list 'calcFunc-sqrt fac))
|
|
(math-normalize
|
|
(list 'calcFunc-sqrt
|
|
(math-cancel-common-factor
|
|
(nth 1 expr) fac)))))))
|
|
@end smallexample
|
|
@end defun
|
|
|
|
@defun frac-gcd a b
|
|
Compute a ``rational GCD'' of @var{a} and @var{b}, which must both be
|
|
rational numbers. This is the fraction composed of the GCD of the
|
|
numerators of @var{a} and @var{b}, over the GCD of the denominators.
|
|
It is used by @code{common-constant-factor}. Note that the standard
|
|
@code{gcd} function uses the LCM to combine the denominators.
|
|
@end defun
|
|
|
|
@defun map-tree func expr many
|
|
Try applying Lisp function @var{func} to various sub-expressions of
|
|
@var{expr}. Initially, call @var{func} with @var{expr} itself as an
|
|
argument. If this returns an expression which is not @code{equal} to
|
|
@var{expr}, apply @var{func} again until eventually it does return
|
|
@var{expr} with no changes. Then, if @var{expr} is a function call,
|
|
recursively apply @var{func} to each of the arguments. This keeps going
|
|
until no changes occur anywhere in the expression; this final expression
|
|
is returned by @code{map-tree}. Note that, unlike simplification rules,
|
|
@var{func} functions may @emph{not} make destructive changes to
|
|
@var{expr}. If a third argument @var{many} is provided, it is an
|
|
integer which says how many times @var{func} may be applied; the
|
|
default, as described above, is infinitely many times.
|
|
@end defun
|
|
|
|
@defun compile-rewrites rules
|
|
Compile the rewrite rule set specified by @var{rules}, which should
|
|
be a formula that is either a vector or a variable name. If the latter,
|
|
the compiled rules are saved so that later @code{compile-rules} calls
|
|
for that same variable can return immediately. If there are problems
|
|
with the rules, this function calls @code{error} with a suitable
|
|
message.
|
|
@end defun
|
|
|
|
@defun apply-rewrites expr crules heads
|
|
Apply the compiled rewrite rule set @var{crules} to the expression
|
|
@var{expr}. This will make only one rewrite and only checks at the
|
|
top level of the expression. The result @code{nil} if no rules
|
|
matched, or if the only rules that matched did not actually change
|
|
the expression. The @var{heads} argument is optional; if is given,
|
|
it should be a list of all function names that (may) appear in
|
|
@var{expr}. The rewrite compiler tags each rule with the
|
|
rarest-looking function name in the rule; if you specify @var{heads},
|
|
@code{apply-rewrites} can use this information to narrow its search
|
|
down to just a few rules in the rule set.
|
|
@end defun
|
|
|
|
@defun rewrite-heads expr
|
|
Compute a @var{heads} list for @var{expr} suitable for use with
|
|
@code{apply-rewrites}, as discussed above.
|
|
@end defun
|
|
|
|
@defun rewrite expr rules many
|
|
This is an all-in-one rewrite function. It compiles the rule set
|
|
specified by @var{rules}, then uses @code{map-tree} to apply the
|
|
rules throughout @var{expr} up to @var{many} (default infinity)
|
|
times.
|
|
@end defun
|
|
|
|
@defun match-patterns pat vec not-flag
|
|
Given a Calc vector @var{vec} and an uncompiled pattern set or
|
|
pattern set variable @var{pat}, this function returns a new vector
|
|
of all elements of @var{vec} which do (or don't, if @var{not-flag} is
|
|
non-@code{nil}) match any of the patterns in @var{pat}.
|
|
@end defun
|
|
|
|
@defun deriv expr var value symb
|
|
Compute the derivative of @var{expr} with respect to variable @var{var}
|
|
(which may actually be any sub-expression). If @var{value} is specified,
|
|
the derivative is evaluated at the value of @var{var}; otherwise, the
|
|
derivative is left in terms of @var{var}. If the expression contains
|
|
functions for which no derivative formula is known, new derivative
|
|
functions are invented by adding primes to the names; @pxref{Calculus}.
|
|
However, if @var{symb} is non-@code{nil}, the presence of undifferentiable
|
|
functions in @var{expr} instead cancels the whole differentiation, and
|
|
@code{deriv} returns @code{nil} instead.
|
|
|
|
Derivatives of an @var{n}-argument function can be defined by
|
|
adding a @code{math-derivative-@var{n}} property to the property list
|
|
of the symbol for the function's derivative, which will be the
|
|
function name followed by an apostrophe. The value of the property
|
|
should be a Lisp function; it is called with the same arguments as the
|
|
original function call that is being differentiated. It should return
|
|
a formula for the derivative. For example, the derivative of @code{ln}
|
|
is defined by
|
|
|
|
@smallexample
|
|
(put 'calcFunc-ln\' 'math-derivative-1
|
|
(function (lambda (u) (math-div 1 u))))
|
|
@end smallexample
|
|
|
|
The two-argument @code{log} function has two derivatives,
|
|
@smallexample
|
|
(put 'calcFunc-log\' 'math-derivative-2 ; d(log(x,b)) / dx
|
|
(function (lambda (x b) ... )))
|
|
(put 'calcFunc-log\'2 'math-derivative-2 ; d(log(x,b)) / db
|
|
(function (lambda (x b) ... )))
|
|
@end smallexample
|
|
@end defun
|
|
|
|
@defun tderiv expr var value symb
|
|
Compute the total derivative of @var{expr}. This is the same as
|
|
@code{deriv}, except that variables other than @var{var} are not
|
|
assumed to be constant with respect to @var{var}.
|
|
@end defun
|
|
|
|
@defun integ expr var low high
|
|
Compute the integral of @var{expr} with respect to @var{var}.
|
|
@xref{Calculus}, for further details.
|
|
@end defun
|
|
|
|
@defmac math-defintegral funcs body
|
|
Define a rule for integrating a function or functions of one argument;
|
|
this macro is very similar in format to @code{math-defsimplify}.
|
|
The main difference is that here @var{body} is the body of a function
|
|
with a single argument @code{u} which is bound to the argument to the
|
|
function being integrated, not the function call itself. Also, the
|
|
variable of integration is available as @code{math-integ-var}. If
|
|
evaluation of the integral requires doing further integrals, the body
|
|
should call @samp{(math-integral @var{x})} to find the integral of
|
|
@var{x} with respect to @code{math-integ-var}; this function returns
|
|
@code{nil} if the integral could not be done. Some examples:
|
|
|
|
@smallexample
|
|
(math-defintegral calcFunc-conj
|
|
(let ((int (math-integral u)))
|
|
(and int
|
|
(list 'calcFunc-conj int))))
|
|
|
|
(math-defintegral calcFunc-cos
|
|
(and (equal u math-integ-var)
|
|
(math-from-radians-2 (list 'calcFunc-sin u))))
|
|
@end smallexample
|
|
|
|
In the @code{cos} example, we define only the integral of @samp{cos(x) dx},
|
|
relying on the general integration-by-substitution facility to handle
|
|
cosines of more complicated arguments. An integration rule should return
|
|
@code{nil} if it can't do the integral; if several rules are defined for
|
|
the same function, they are tried in order until one returns a non-@code{nil}
|
|
result.
|
|
@end defmac
|
|
|
|
@defmac math-defintegral-2 funcs body
|
|
Define a rule for integrating a function or functions of two arguments.
|
|
This is exactly analogous to @code{math-defintegral}, except that @var{body}
|
|
is written as the body of a function with two arguments, @var{u} and
|
|
@var{v}.
|
|
@end defmac
|
|
|
|
@defun solve-for lhs rhs var full
|
|
Attempt to solve the equation @samp{@var{lhs} = @var{rhs}} by isolating
|
|
the variable @var{var} on the lefthand side; return the resulting righthand
|
|
side, or @code{nil} if the equation cannot be solved. The variable
|
|
@var{var} must appear at least once in @var{lhs} or @var{rhs}. Note that
|
|
the return value is a formula which does not contain @var{var}; this is
|
|
different from the user-level @code{solve} and @code{finv} functions,
|
|
which return a rearranged equation or a functional inverse, respectively.
|
|
If @var{full} is non-@code{nil}, a full solution including dummy signs
|
|
and dummy integers will be produced. User-defined inverses are provided
|
|
as properties in a manner similar to derivatives:
|
|
|
|
@smallexample
|
|
(put 'calcFunc-ln 'math-inverse
|
|
(function (lambda (x) (list 'calcFunc-exp x))))
|
|
@end smallexample
|
|
|
|
This function can call @samp{(math-solve-get-sign @var{x})} to create
|
|
a new arbitrary sign variable, returning @var{x} times that sign, and
|
|
@samp{(math-solve-get-int @var{x})} to create a new arbitrary integer
|
|
variable multiplied by @var{x}. These functions simply return @var{x}
|
|
if the caller requested a non-``full'' solution.
|
|
@end defun
|
|
|
|
@defun solve-eqn expr var full
|
|
This version of @code{solve-for} takes an expression which will
|
|
typically be an equation or inequality. (If it is not, it will be
|
|
interpreted as the equation @samp{@var{expr} = 0}.) It returns an
|
|
equation or inequality, or @code{nil} if no solution could be found.
|
|
@end defun
|
|
|
|
@defun solve-system exprs vars full
|
|
This function solves a system of equations. Generally, @var{exprs}
|
|
and @var{vars} will be vectors of equal length.
|
|
@xref{Solving Systems of Equations}, for other options.
|
|
@end defun
|
|
|
|
@defun expr-contains expr var
|
|
Returns a non-@code{nil} value if @var{var} occurs as a subexpression
|
|
of @var{expr}.
|
|
|
|
This function might seem at first to be identical to
|
|
@code{calc-find-sub-formula}. The key difference is that
|
|
@code{expr-contains} uses @code{equal} to test for matches, whereas
|
|
@code{calc-find-sub-formula} uses @code{eq}. In the formula
|
|
@samp{f(a, a)}, the two @samp{a}s will be @code{equal} but not
|
|
@code{eq} to each other.
|
|
@end defun
|
|
|
|
@defun expr-contains-count expr var
|
|
Returns the number of occurrences of @var{var} as a subexpression
|
|
of @var{expr}, or @code{nil} if there are no occurrences.
|
|
@end defun
|
|
|
|
@defun expr-depends expr var
|
|
Returns true if @var{expr} refers to any variable the occurs in @var{var}.
|
|
In other words, it checks if @var{expr} and @var{var} have any variables
|
|
in common.
|
|
@end defun
|
|
|
|
@defun expr-contains-vars expr
|
|
Return true if @var{expr} contains any variables, or @code{nil} if @var{expr}
|
|
contains only constants and functions with constant arguments.
|
|
@end defun
|
|
|
|
@defun expr-subst expr old new
|
|
Returns a copy of @var{expr}, with all occurrences of @var{old} replaced
|
|
by @var{new}. This treats @code{lambda} forms specially with respect
|
|
to the dummy argument variables, so that the effect is always to return
|
|
@var{expr} evaluated at @var{old} = @var{new}.
|
|
@end defun
|
|
|
|
@defun multi-subst expr old new
|
|
This is like @code{expr-subst}, except that @var{old} and @var{new}
|
|
are lists of expressions to be substituted simultaneously. If one
|
|
list is shorter than the other, trailing elements of the longer list
|
|
are ignored.
|
|
@end defun
|
|
|
|
@defun expr-weight expr
|
|
Returns the ``weight'' of @var{expr}, basically a count of the total
|
|
number of objects and function calls that appear in @var{expr}. For
|
|
``primitive'' objects, this will be one.
|
|
@end defun
|
|
|
|
@defun expr-height expr
|
|
Returns the ``height'' of @var{expr}, which is the deepest level to
|
|
which function calls are nested. (Note that @samp{@var{a} + @var{b}}
|
|
counts as a function call.) For primitive objects, this returns zero.
|
|
@end defun
|
|
|
|
@defun polynomial-p expr var
|
|
Check if @var{expr} is a polynomial in variable (or sub-expression)
|
|
@var{var}. If so, return the degree of the polynomial, that is, the
|
|
highest power of @var{var} that appears in @var{expr}. For example,
|
|
for @samp{(x^2 + 3)^3 + 4} this would return 6. This function returns
|
|
@code{nil} unless @var{expr}, when expanded out by @kbd{a x}
|
|
(@code{calc-expand}), would consist of a sum of terms in which @var{var}
|
|
appears only raised to nonnegative integer powers. Note that if
|
|
@var{var} does not occur in @var{expr}, then @var{expr} is considered
|
|
a polynomial of degree 0.
|
|
@end defun
|
|
|
|
@defun is-polynomial expr var degree loose
|
|
Check if @var{expr} is a polynomial in variable or sub-expression
|
|
@var{var}, and, if so, return a list representation of the polynomial
|
|
where the elements of the list are coefficients of successive powers of
|
|
@var{var}: @samp{@var{a} + @var{b} x + @var{c} x^3} would produce the
|
|
list @samp{(@var{a} @var{b} 0 @var{c})}, and @samp{(x + 1)^2} would
|
|
produce the list @samp{(1 2 1)}. The highest element of the list will
|
|
be non-zero, with the special exception that if @var{expr} is the
|
|
constant zero, the returned value will be @samp{(0)}. Return @code{nil}
|
|
if @var{expr} is not a polynomial in @var{var}. If @var{degree} is
|
|
specified, this will not consider polynomials of degree higher than that
|
|
value. This is a good precaution because otherwise an input of
|
|
@samp{(x+1)^1000} will cause a huge coefficient list to be built. If
|
|
@var{loose} is non-@code{nil}, then a looser definition of a polynomial
|
|
is used in which coefficients are no longer required not to depend on
|
|
@var{var}, but are only required not to take the form of polynomials
|
|
themselves. For example, @samp{sin(x) x^2 + cos(x)} is a loose
|
|
polynomial with coefficients @samp{((calcFunc-cos x) 0 (calcFunc-sin
|
|
x))}. The result will never be @code{nil} in loose mode, since any
|
|
expression can be interpreted as a ``constant'' loose polynomial.
|
|
@end defun
|
|
|
|
@defun polynomial-base expr pred
|
|
Check if @var{expr} is a polynomial in any variable that occurs in it;
|
|
if so, return that variable. (If @var{expr} is a multivariate polynomial,
|
|
this chooses one variable arbitrarily.) If @var{pred} is specified, it should
|
|
be a Lisp function which is called as @samp{(@var{pred} @var{subexpr})},
|
|
and which should return true if @code{mpb-top-expr} (a global name for
|
|
the original @var{expr}) is a suitable polynomial in @var{subexpr}.
|
|
The default predicate uses @samp{(polynomial-p mpb-top-expr @var{subexpr})};
|
|
you can use @var{pred} to specify additional conditions. Or, you could
|
|
have @var{pred} build up a list of every suitable @var{subexpr} that
|
|
is found.
|
|
@end defun
|
|
|
|
@defun poly-simplify poly
|
|
Simplify polynomial coefficient list @var{poly} by (destructively)
|
|
clipping off trailing zeros.
|
|
@end defun
|
|
|
|
@defun poly-mix a ac b bc
|
|
Mix two polynomial lists @var{a} and @var{b} (in the form returned by
|
|
@code{is-polynomial}) in a linear combination with coefficient expressions
|
|
@var{ac} and @var{bc}. The result is a (not necessarily simplified)
|
|
polynomial list representing @samp{@var{ac} @var{a} + @var{bc} @var{b}}.
|
|
@end defun
|
|
|
|
@defun poly-mul a b
|
|
Multiply two polynomial coefficient lists @var{a} and @var{b}. The
|
|
result will be in simplified form if the inputs were simplified.
|
|
@end defun
|
|
|
|
@defun build-polynomial-expr poly var
|
|
Construct a Calc formula which represents the polynomial coefficient
|
|
list @var{poly} applied to variable @var{var}. The @kbd{a c}
|
|
(@code{calc-collect}) command uses @code{is-polynomial} to turn an
|
|
expression into a coefficient list, then @code{build-polynomial-expr}
|
|
to turn the list back into an expression in regular form.
|
|
@end defun
|
|
|
|
@defun check-unit-name var
|
|
Check if @var{var} is a variable which can be interpreted as a unit
|
|
name. If so, return the units table entry for that unit. This
|
|
will be a list whose first element is the unit name (not counting
|
|
prefix characters) as a symbol and whose second element is the
|
|
Calc expression which defines the unit. (Refer to the Calc sources
|
|
for details on the remaining elements of this list.) If @var{var}
|
|
is not a variable or is not a unit name, return @code{nil}.
|
|
@end defun
|
|
|
|
@defun units-in-expr-p expr sub-exprs
|
|
Return true if @var{expr} contains any variables which can be
|
|
interpreted as units. If @var{sub-exprs} is @code{t}, the entire
|
|
expression is searched. If @var{sub-exprs} is @code{nil}, this
|
|
checks whether @var{expr} is directly a units expression.
|
|
@end defun
|
|
|
|
@defun single-units-in-expr-p expr
|
|
Check whether @var{expr} contains exactly one units variable. If so,
|
|
return the units table entry for the variable. If @var{expr} does
|
|
not contain any units, return @code{nil}. If @var{expr} contains
|
|
two or more units, return the symbol @code{wrong}.
|
|
@end defun
|
|
|
|
@defun to-standard-units expr which
|
|
Convert units expression @var{expr} to base units. If @var{which}
|
|
is @code{nil}, use Calc's native base units. Otherwise, @var{which}
|
|
can specify a units system, which is a list of two-element lists,
|
|
where the first element is a Calc base symbol name and the second
|
|
is an expression to substitute for it.
|
|
@end defun
|
|
|
|
@defun remove-units expr
|
|
Return a copy of @var{expr} with all units variables replaced by ones.
|
|
This expression is generally normalized before use.
|
|
@end defun
|
|
|
|
@defun extract-units expr
|
|
Return a copy of @var{expr} with everything but units variables replaced
|
|
by ones.
|
|
@end defun
|
|
|
|
@node Formatting Lisp Functions, Hooks, Symbolic Lisp Functions, Internals
|
|
@subsubsection I/O and Formatting Functions
|
|
|
|
@noindent
|
|
The functions described here are responsible for parsing and formatting
|
|
Calc numbers and formulas.
|
|
|
|
@defun calc-eval str sep arg1 arg2 @dots{}
|
|
This is the simplest interface to the Calculator from another Lisp program.
|
|
@xref{Calling Calc from Your Programs}.
|
|
@end defun
|
|
|
|
@defun read-number str
|
|
If string @var{str} contains a valid Calc number, either integer,
|
|
fraction, float, or HMS form, this function parses and returns that
|
|
number. Otherwise, it returns @code{nil}.
|
|
@end defun
|
|
|
|
@defun read-expr str
|
|
Read an algebraic expression from string @var{str}. If @var{str} does
|
|
not have the form of a valid expression, return a list of the form
|
|
@samp{(error @var{pos} @var{msg})} where @var{pos} is an integer index
|
|
into @var{str} of the general location of the error, and @var{msg} is
|
|
a string describing the problem.
|
|
@end defun
|
|
|
|
@defun read-exprs str
|
|
Read a list of expressions separated by commas, and return it as a
|
|
Lisp list. If an error occurs in any expressions, an error list as
|
|
shown above is returned instead.
|
|
@end defun
|
|
|
|
@defun calc-do-alg-entry initial prompt no-norm
|
|
Read an algebraic formula or formulas using the minibuffer. All
|
|
conventions of regular algebraic entry are observed. The return value
|
|
is a list of Calc formulas; there will be more than one if the user
|
|
entered a list of values separated by commas. The result is @code{nil}
|
|
if the user presses Return with a blank line. If @var{initial} is
|
|
given, it is a string which the minibuffer will initially contain.
|
|
If @var{prompt} is given, it is the prompt string to use; the default
|
|
is ``Algebraic:''. If @var{no-norm} is @code{t}, the formulas will
|
|
be returned exactly as parsed; otherwise, they will be passed through
|
|
@code{calc-normalize} first.
|
|
|
|
To support the use of @kbd{$} characters in the algebraic entry, use
|
|
@code{let} to bind @code{calc-dollar-values} to a list of the values
|
|
to be substituted for @kbd{$}, @kbd{$$}, and so on, and bind
|
|
@code{calc-dollar-used} to 0. Upon return, @code{calc-dollar-used}
|
|
will have been changed to the highest number of consecutive @kbd{$}s
|
|
that actually appeared in the input.
|
|
@end defun
|
|
|
|
@defun format-number a
|
|
Convert the real or complex number or HMS form @var{a} to string form.
|
|
@end defun
|
|
|
|
@defun format-flat-expr a prec
|
|
Convert the arbitrary Calc number or formula @var{a} to string form,
|
|
in the style used by the trail buffer and the @code{calc-edit} command.
|
|
This is a simple format designed
|
|
mostly to guarantee the string is of a form that can be re-parsed by
|
|
@code{read-expr}. Most formatting modes, such as digit grouping,
|
|
complex number format, and point character, are ignored to ensure the
|
|
result will be re-readable. The @var{prec} parameter is normally 0; if
|
|
you pass a large integer like 1000 instead, the expression will be
|
|
surrounded by parentheses unless it is a plain number or variable name.
|
|
@end defun
|
|
|
|
@defun format-nice-expr a width
|
|
This is like @code{format-flat-expr} (with @var{prec} equal to 0),
|
|
except that newlines will be inserted to keep lines down to the
|
|
specified @var{width}, and vectors that look like matrices or rewrite
|
|
rules are written in a pseudo-matrix format. The @code{calc-edit}
|
|
command uses this when only one stack entry is being edited.
|
|
@end defun
|
|
|
|
@defun format-value a width
|
|
Convert the Calc number or formula @var{a} to string form, using the
|
|
format seen in the stack buffer. Beware the string returned may
|
|
not be re-readable by @code{read-expr}, for example, because of digit
|
|
grouping. Multi-line objects like matrices produce strings that
|
|
contain newline characters to separate the lines. The @var{w}
|
|
parameter, if given, is the target window size for which to format
|
|
the expressions. If @var{w} is omitted, the width of the Calculator
|
|
window is used.
|
|
@end defun
|
|
|
|
@defun compose-expr a prec
|
|
Format the Calc number or formula @var{a} according to the current
|
|
language mode, returning a ``composition.'' To learn about the
|
|
structure of compositions, see the comments in the Calc source code.
|
|
You can specify the format of a given type of function call by putting
|
|
a @code{math-compose-@var{lang}} property on the function's symbol,
|
|
whose value is a Lisp function that takes @var{a} and @var{prec} as
|
|
arguments and returns a composition. Here @var{lang} is a language
|
|
mode name, one of @code{normal}, @code{big}, @code{c}, @code{pascal},
|
|
@code{fortran}, @code{tex}, @code{eqn}, @code{math}, or @code{maple}.
|
|
In Big mode, Calc actually tries @code{math-compose-big} first, then
|
|
tries @code{math-compose-normal}. If this property does not exist,
|
|
or if the function returns @code{nil}, the function is written in the
|
|
normal function-call notation for that language.
|
|
@end defun
|
|
|
|
@defun composition-to-string c w
|
|
Convert a composition structure returned by @code{compose-expr} into
|
|
a string. Multi-line compositions convert to strings containing
|
|
newline characters. The target window size is given by @var{w}.
|
|
The @code{format-value} function basically calls @code{compose-expr}
|
|
followed by @code{composition-to-string}.
|
|
@end defun
|
|
|
|
@defun comp-width c
|
|
Compute the width in characters of composition @var{c}.
|
|
@end defun
|
|
|
|
@defun comp-height c
|
|
Compute the height in lines of composition @var{c}.
|
|
@end defun
|
|
|
|
@defun comp-ascent c
|
|
Compute the portion of the height of composition @var{c} which is on or
|
|
above the baseline. For a one-line composition, this will be one.
|
|
@end defun
|
|
|
|
@defun comp-descent c
|
|
Compute the portion of the height of composition @var{c} which is below
|
|
the baseline. For a one-line composition, this will be zero.
|
|
@end defun
|
|
|
|
@defun comp-first-char c
|
|
If composition @var{c} is a ``flat'' composition, return the first
|
|
(leftmost) character of the composition as an integer. Otherwise,
|
|
return @code{nil}.
|
|
@end defun
|
|
|
|
@defun comp-last-char c
|
|
If composition @var{c} is a ``flat'' composition, return the last
|
|
(rightmost) character, otherwise return @code{nil}.
|
|
@end defun
|
|
|
|
@comment @node Lisp Variables, Hooks, Formatting Lisp Functions, Internals
|
|
@comment @subsubsection Lisp Variables
|
|
@comment
|
|
@comment @noindent
|
|
@comment (This section is currently unfinished.)
|
|
|
|
@node Hooks, , Formatting Lisp Functions, Internals
|
|
@subsubsection Hooks
|
|
|
|
@noindent
|
|
Hooks are variables which contain Lisp functions (or lists of functions)
|
|
which are called at various times. Calc defines a number of hooks
|
|
that help you to customize it in various ways. Calc uses the Lisp
|
|
function @code{run-hooks} to invoke the hooks shown below. Several
|
|
other customization-related variables are also described here.
|
|
|
|
@defvar calc-load-hook
|
|
This hook is called at the end of @file{calc.el}, after the file has
|
|
been loaded, before any functions in it have been called, but after
|
|
@code{calc-mode-map} and similar variables have been set up.
|
|
@end defvar
|
|
|
|
@defvar calc-ext-load-hook
|
|
This hook is called at the end of @file{calc-ext.el}.
|
|
@end defvar
|
|
|
|
@defvar calc-start-hook
|
|
This hook is called as the last step in a @kbd{M-x calc} command.
|
|
At this point, the Calc buffer has been created and initialized if
|
|
necessary, the Calc window and trail window have been created,
|
|
and the ``Welcome to Calc'' message has been displayed.
|
|
@end defvar
|
|
|
|
@defvar calc-mode-hook
|
|
This hook is called when the Calc buffer is being created. Usually
|
|
this will only happen once per Emacs session. The hook is called
|
|
after Emacs has switched to the new buffer, the mode-settings file
|
|
has been read if necessary, and all other buffer-local variables
|
|
have been set up. After this hook returns, Calc will perform a
|
|
@code{calc-refresh} operation, set up the mode line display, then
|
|
evaluate any deferred @code{calc-define} properties that have not
|
|
been evaluated yet.
|
|
@end defvar
|
|
|
|
@defvar calc-trail-mode-hook
|
|
This hook is called when the Calc Trail buffer is being created.
|
|
It is called as the very last step of setting up the Trail buffer.
|
|
Like @code{calc-mode-hook}, this will normally happen only once
|
|
per Emacs session.
|
|
@end defvar
|
|
|
|
@defvar calc-end-hook
|
|
This hook is called by @code{calc-quit}, generally because the user
|
|
presses @kbd{q} or @kbd{C-x * c} while in Calc. The Calc buffer will
|
|
be the current buffer. The hook is called as the very first
|
|
step, before the Calc window is destroyed.
|
|
@end defvar
|
|
|
|
@defvar calc-window-hook
|
|
If this hook is non-@code{nil}, it is called to create the Calc window.
|
|
Upon return, this new Calc window should be the current window.
|
|
(The Calc buffer will already be the current buffer when the
|
|
hook is called.) If the hook is not defined, Calc will
|
|
generally use @code{split-window}, @code{set-window-buffer},
|
|
and @code{select-window} to create the Calc window.
|
|
@end defvar
|
|
|
|
@defvar calc-trail-window-hook
|
|
If this hook is non-@code{nil}, it is called to create the Calc Trail
|
|
window. The variable @code{calc-trail-buffer} will contain the buffer
|
|
which the window should use. Unlike @code{calc-window-hook}, this hook
|
|
must @emph{not} switch into the new window.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-mode-hook
|
|
This hook is called the first time that Embedded mode is entered.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-new-buffer-hook
|
|
This hook is called each time that Embedded mode is entered in a
|
|
new buffer.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-new-formula-hook
|
|
This hook is called each time that Embedded mode is enabled for a
|
|
new formula.
|
|
@end defvar
|
|
|
|
@defvar calc-edit-mode-hook
|
|
This hook is called by @code{calc-edit} (and the other ``edit''
|
|
commands) when the temporary editing buffer is being created.
|
|
The buffer will have been selected and set up to be in
|
|
@code{calc-edit-mode}, but will not yet have been filled with
|
|
text. (In fact it may still have leftover text from a previous
|
|
@code{calc-edit} command.)
|
|
@end defvar
|
|
|
|
@defvar calc-mode-save-hook
|
|
This hook is called by the @code{calc-save-modes} command,
|
|
after Calc's own mode features have been inserted into the
|
|
Calc init file and just before the ``End of mode settings''
|
|
message is inserted.
|
|
@end defvar
|
|
|
|
@defvar calc-reset-hook
|
|
This hook is called after @kbd{C-x * 0} (@code{calc-reset}) has
|
|
reset all modes. The Calc buffer will be the current buffer.
|
|
@end defvar
|
|
|
|
@defvar calc-other-modes
|
|
This variable contains a list of strings. The strings are
|
|
concatenated at the end of the modes portion of the Calc
|
|
mode line (after standard modes such as ``Deg'', ``Inv'' and
|
|
``Hyp''). Each string should be a short, single word followed
|
|
by a space. The variable is @code{nil} by default.
|
|
@end defvar
|
|
|
|
@defvar calc-mode-map
|
|
This is the keymap that is used by Calc mode. The best time
|
|
to adjust it is probably in a @code{calc-mode-hook}. If the
|
|
Calc extensions package (@file{calc-ext.el}) has not yet been
|
|
loaded, many of these keys will be bound to @code{calc-missing-key},
|
|
which is a command that loads the extensions package and
|
|
``retypes'' the key. If your @code{calc-mode-hook} rebinds
|
|
one of these keys, it will probably be overridden when the
|
|
extensions are loaded.
|
|
@end defvar
|
|
|
|
@defvar calc-digit-map
|
|
This is the keymap that is used during numeric entry. Numeric
|
|
entry uses the minibuffer, but this map binds every non-numeric
|
|
key to @code{calcDigit-nondigit} which generally calls
|
|
@code{exit-minibuffer} and ``retypes'' the key.
|
|
@end defvar
|
|
|
|
@defvar calc-alg-ent-map
|
|
This is the keymap that is used during algebraic entry. This is
|
|
mostly a copy of @code{minibuffer-local-map}.
|
|
@end defvar
|
|
|
|
@defvar calc-store-var-map
|
|
This is the keymap that is used during entry of variable names for
|
|
commands like @code{calc-store} and @code{calc-recall}. This is
|
|
mostly a copy of @code{minibuffer-local-completion-map}.
|
|
@end defvar
|
|
|
|
@defvar calc-edit-mode-map
|
|
This is the (sparse) keymap used by @code{calc-edit} and other
|
|
temporary editing commands. It binds @key{RET}, @key{LFD},
|
|
and @kbd{C-c C-c} to @code{calc-edit-finish}.
|
|
@end defvar
|
|
|
|
@defvar calc-mode-var-list
|
|
This is a list of variables which are saved by @code{calc-save-modes}.
|
|
Each entry is a list of two items, the variable (as a Lisp symbol)
|
|
and its default value. When modes are being saved, each variable
|
|
is compared with its default value (using @code{equal}) and any
|
|
non-default variables are written out.
|
|
@end defvar
|
|
|
|
@defvar calc-local-var-list
|
|
This is a list of variables which should be buffer-local to the
|
|
Calc buffer. Each entry is a variable name (as a Lisp symbol).
|
|
These variables also have their default values manipulated by
|
|
the @code{calc} and @code{calc-quit} commands; @pxref{Multiple Calculators}.
|
|
Since @code{calc-mode-hook} is called after this list has been
|
|
used the first time, your hook should add a variable to the
|
|
list and also call @code{make-local-variable} itself.
|
|
@end defvar
|
|
|
|
@node Customizing Calc, Reporting Bugs, Programming, Top
|
|
@appendix Customizing Calc
|
|
|
|
The usual prefix for Calc is the key sequence @kbd{C-x *}. If you wish
|
|
to use a different prefix, you can put
|
|
|
|
@example
|
|
(global-set-key "NEWPREFIX" 'calc-dispatch)
|
|
@end example
|
|
|
|
@noindent
|
|
in your .emacs file.
|
|
(@xref{Key Bindings,,Customizing Key Bindings,emacs,
|
|
The GNU Emacs Manual}, for more information on binding keys.)
|
|
A convenient way to start Calc is with @kbd{C-x * *}; to make it equally
|
|
convenient for users who use a different prefix, the prefix can be
|
|
followed by @kbd{=}, @kbd{&}, @kbd{#}, @kbd{\}, @kbd{/}, @kbd{+} or
|
|
@kbd{-} as well as @kbd{*} to start Calc, and so in many cases the last
|
|
character of the prefix can simply be typed twice.
|
|
|
|
Calc is controlled by many variables, most of which can be reset
|
|
from within Calc. Some variables are less involved with actual
|
|
calculation, and can be set outside of Calc using Emacs's
|
|
customization facilities. These variables are listed below.
|
|
Typing @kbd{M-x customize-variable RET @var{variable-name} RET}
|
|
will bring up a buffer in which the variable's value can be redefined.
|
|
Typing @kbd{M-x customize-group RET calc RET} will bring up a buffer which
|
|
contains all of Calc's customizable variables. (These variables can
|
|
also be reset by putting the appropriate lines in your .emacs file;
|
|
@xref{Init File, ,Init File, emacs, The GNU Emacs Manual}.)
|
|
|
|
Some of the customizable variables are regular expressions. A regular
|
|
expression is basically a pattern that Calc can search for.
|
|
See @ref{Regexp Search,, Regular Expression Search, emacs, The GNU Emacs Manual}
|
|
to see how regular expressions work.
|
|
|
|
@defvar calc-settings-file
|
|
The variable @code{calc-settings-file} holds the file name in
|
|
which commands like @kbd{m m} and @kbd{Z P} store ``permanent''
|
|
definitions.
|
|
If @code{calc-settings-file} is not your user init file (typically
|
|
@file{~/.emacs}) and if the variable @code{calc-loaded-settings-file} is
|
|
@code{nil}, then Calc will automatically load your settings file (if it
|
|
exists) the first time Calc is invoked.
|
|
|
|
The default value for this variable is @code{"~/.calc.el"}.
|
|
@end defvar
|
|
|
|
@defvar calc-gnuplot-name
|
|
See @ref{Graphics}.@*
|
|
The variable @code{calc-gnuplot-name} should be the name of the
|
|
GNUPLOT program (a string). If you have GNUPLOT installed on your
|
|
system but Calc is unable to find it, you may need to set this
|
|
variable. (@pxref{Customizing Calc})
|
|
You may also need to set some Lisp variables to show Calc how to run
|
|
GNUPLOT on your system, see @ref{Devices, ,Graphical Devices} . The default value
|
|
of @code{calc-gnuplot-name} is @code{"gnuplot"}.
|
|
@end defvar
|
|
|
|
@defvar calc-gnuplot-plot-command
|
|
@defvarx calc-gnuplot-print-command
|
|
See @ref{Devices, ,Graphical Devices}.@*
|
|
The variables @code{calc-gnuplot-plot-command} and
|
|
@code{calc-gnuplot-print-command} represent system commands to
|
|
display and print the output of GNUPLOT, respectively. These may be
|
|
@code{nil} if no command is necessary, or strings which can include
|
|
@samp{%s} to signify the name of the file to be displayed or printed.
|
|
Or, these variables may contain Lisp expressions which are evaluated
|
|
to display or print the output.
|
|
|
|
The default value of @code{calc-gnuplot-plot-command} is @code{nil},
|
|
and the default value of @code{calc-gnuplot-print-command} is
|
|
@code{"lp %s"}.
|
|
@end defvar
|
|
|
|
@defvar calc-language-alist
|
|
See @ref{Basic Embedded Mode}.@*
|
|
The variable @code{calc-language-alist} controls the languages that
|
|
Calc will associate with major modes. When Calc embedded mode is
|
|
enabled, it will try to use the current major mode to
|
|
determine what language should be used. (This can be overridden using
|
|
Calc's mode changing commands, @xref{Mode Settings in Embedded Mode}.)
|
|
The variable @code{calc-language-alist} consists of a list of pairs of
|
|
the form @code{(@var{MAJOR-MODE} . @var{LANGUAGE})}; for example,
|
|
@code{(latex-mode . latex)} is one such pair. If Calc embedded is
|
|
activated in a buffer whose major mode is @var{MAJOR-MODE}, it will set itself
|
|
to use the language @var{LANGUAGE}.
|
|
|
|
The default value of @code{calc-language-alist} is
|
|
@example
|
|
((latex-mode . latex)
|
|
(tex-mode . tex)
|
|
(plain-tex-mode . tex)
|
|
(context-mode . tex)
|
|
(nroff-mode . eqn)
|
|
(pascal-mode . pascal)
|
|
(c-mode . c)
|
|
(c++-mode . c)
|
|
(fortran-mode . fortran)
|
|
(f90-mode . fortran))
|
|
@end example
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-announce-formula
|
|
@defvarx calc-embedded-announce-formula-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variable @code{calc-embedded-announce-formula} helps determine
|
|
what formulas @kbd{C-x * a} will activate in a buffer. It is a
|
|
regular expression, and when activating embedded formulas with
|
|
@kbd{C-x * a}, it will tell Calc that what follows is a formula to be
|
|
activated. (Calc also uses other patterns to find formulas, such as
|
|
@samp{=>} and @samp{:=}.)
|
|
|
|
The default pattern is @code{"%Embed\n\\(% .*\n\\)*"}, which checks
|
|
for @samp{%Embed} followed by any number of lines beginning with
|
|
@samp{%} and a space.
|
|
|
|
The variable @code{calc-embedded-announce-formula-alist} is used to
|
|
set @code{calc-embedded-announce-formula} to different regular
|
|
expressions depending on the major mode of the editing buffer.
|
|
It consists of a list of pairs of the form @code{(@var{MAJOR-MODE} .
|
|
@var{REGEXP})}, and its default value is
|
|
@example
|
|
((c++-mode . "//Embed\n\\(// .*\n\\)*")
|
|
(c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*")
|
|
(f90-mode . "!Embed\n\\(! .*\n\\)*")
|
|
(fortran-mode . "C Embed\n\\(C .*\n\\)*")
|
|
(html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
|
|
(html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
|
|
(nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*")
|
|
(pascal-mode . "@{Embed@}\n\\(@{.*@}\n\\)*")
|
|
(sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
|
|
(xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*")
|
|
(texinfo-mode . "@@c Embed\n\\(@@c .*\n\\)*"))
|
|
@end example
|
|
Any major modes added to @code{calc-embedded-announce-formula-alist}
|
|
should also be added to @code{calc-embedded-open-close-plain-alist}
|
|
and @code{calc-embedded-open-close-mode-alist}.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-open-formula
|
|
@defvarx calc-embedded-close-formula
|
|
@defvarx calc-embedded-open-close-formula-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variables @code{calc-embedded-open-formula} and
|
|
@code{calc-embedded-open-formula} control the region that Calc will
|
|
activate as a formula when Embedded mode is entered with @kbd{C-x * e}.
|
|
They are regular expressions;
|
|
Calc normally scans backward and forward in the buffer for the
|
|
nearest text matching these regular expressions to be the ``formula
|
|
delimiters''.
|
|
|
|
The simplest delimiters are blank lines. Other delimiters that
|
|
Embedded mode understands by default are:
|
|
@enumerate
|
|
@item
|
|
The @TeX{} and La@TeX{} math delimiters @samp{$ $}, @samp{$$ $$},
|
|
@samp{\[ \]}, and @samp{\( \)};
|
|
@item
|
|
Lines beginning with @samp{\begin} and @samp{\end} (except matrix delimiters);
|
|
@item
|
|
Lines beginning with @samp{@@} (Texinfo delimiters).
|
|
@item
|
|
Lines beginning with @samp{.EQ} and @samp{.EN} (@dfn{eqn} delimiters);
|
|
@item
|
|
Lines containing a single @samp{%} or @samp{.\"} symbol and nothing else.
|
|
@end enumerate
|
|
|
|
The variable @code{calc-embedded-open-close-formula-alist} is used to
|
|
set @code{calc-embedded-open-formula} and
|
|
@code{calc-embedded-close-formula} to different regular
|
|
expressions depending on the major mode of the editing buffer.
|
|
It consists of a list of lists of the form
|
|
@code{(@var{MAJOR-MODE} @var{OPEN-FORMULA-REGEXP}
|
|
@var{CLOSE-FORMULA-REGEXP})}, and its default value is
|
|
@code{nil}.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-open-word
|
|
@defvarx calc-embedded-close-word
|
|
@defvarx calc-embedded-open-close-word-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variables @code{calc-embedded-open-word} and
|
|
@code{calc-embedded-close-word} control the region that Calc will
|
|
activate when Embedded mode is entered with @kbd{C-x * w}. They are
|
|
regular expressions.
|
|
|
|
The default values of @code{calc-embedded-open-word} and
|
|
@code{calc-embedded-close-word} are @code{"^\\|[^-+0-9.eE]"} and
|
|
@code{"$\\|[^-+0-9.eE]"} respectively.
|
|
|
|
The variable @code{calc-embedded-open-close-word-alist} is used to
|
|
set @code{calc-embedded-open-word} and
|
|
@code{calc-embedded-close-word} to different regular
|
|
expressions depending on the major mode of the editing buffer.
|
|
It consists of a list of lists of the form
|
|
@code{(@var{MAJOR-MODE} @var{OPEN-WORD-REGEXP}
|
|
@var{CLOSE-WORD-REGEXP})}, and its default value is
|
|
@code{nil}.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-open-plain
|
|
@defvarx calc-embedded-close-plain
|
|
@defvarx calc-embedded-open-close-plain-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variables @code{calc-embedded-open-plain} and
|
|
@code{calc-embedded-open-plain} are used to delimit ``plain''
|
|
formulas. Note that these are actual strings, not regular
|
|
expressions, because Calc must be able to write these string into a
|
|
buffer as well as to recognize them.
|
|
|
|
The default string for @code{calc-embedded-open-plain} is
|
|
@code{"%%% "}, note the trailing space. The default string for
|
|
@code{calc-embedded-close-plain} is @code{" %%%\n"}, without
|
|
the trailing newline here, the first line of a Big mode formula
|
|
that followed might be shifted over with respect to the other lines.
|
|
|
|
The variable @code{calc-embedded-open-close-plain-alist} is used to
|
|
set @code{calc-embedded-open-plain} and
|
|
@code{calc-embedded-close-plain} to different strings
|
|
depending on the major mode of the editing buffer.
|
|
It consists of a list of lists of the form
|
|
@code{(@var{MAJOR-MODE} @var{OPEN-PLAIN-STRING}
|
|
@var{CLOSE-PLAIN-STRING})}, and its default value is
|
|
@example
|
|
((c++-mode "// %% " " %%\n")
|
|
(c-mode "/* %% " " %% */\n")
|
|
(f90-mode "! %% " " %%\n")
|
|
(fortran-mode "C %% " " %%\n")
|
|
(html-helper-mode "<!-- %% " " %% -->\n")
|
|
(html-mode "<!-- %% " " %% -->\n")
|
|
(nroff-mode "\\\" %% " " %%\n")
|
|
(pascal-mode "@{%% " " %%@}\n")
|
|
(sgml-mode "<!-- %% " " %% -->\n")
|
|
(xml-mode "<!-- %% " " %% -->\n")
|
|
(texinfo-mode "@@c %% " " %%\n"))
|
|
@end example
|
|
Any major modes added to @code{calc-embedded-open-close-plain-alist}
|
|
should also be added to @code{calc-embedded-announce-formula-alist}
|
|
and @code{calc-embedded-open-close-mode-alist}.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-open-new-formula
|
|
@defvarx calc-embedded-close-new-formula
|
|
@defvarx calc-embedded-open-close-new-formula-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variables @code{calc-embedded-open-new-formula} and
|
|
@code{calc-embedded-close-new-formula} are strings which are
|
|
inserted before and after a new formula when you type @kbd{C-x * f}.
|
|
|
|
The default value of @code{calc-embedded-open-new-formula} is
|
|
@code{"\n\n"}. If this string begins with a newline character and the
|
|
@kbd{C-x * f} is typed at the beginning of a line, @kbd{C-x * f} will skip
|
|
this first newline to avoid introducing unnecessary blank lines in the
|
|
file. The default value of @code{calc-embedded-close-new-formula} is
|
|
also @code{"\n\n"}. The final newline is omitted by @w{@kbd{C-x * f}}
|
|
if typed at the end of a line. (It follows that if @kbd{C-x * f} is
|
|
typed on a blank line, both a leading opening newline and a trailing
|
|
closing newline are omitted.)
|
|
|
|
The variable @code{calc-embedded-open-close-new-formula-alist} is used to
|
|
set @code{calc-embedded-open-new-formula} and
|
|
@code{calc-embedded-close-new-formula} to different strings
|
|
depending on the major mode of the editing buffer.
|
|
It consists of a list of lists of the form
|
|
@code{(@var{MAJOR-MODE} @var{OPEN-NEW-FORMULA-STRING}
|
|
@var{CLOSE-NEW-FORMULA-STRING})}, and its default value is
|
|
@code{nil}.
|
|
@end defvar
|
|
|
|
@defvar calc-embedded-open-mode
|
|
@defvarx calc-embedded-close-mode
|
|
@defvarx calc-embedded-open-close-mode-alist
|
|
See @ref{Customizing Embedded Mode}.@*
|
|
The variables @code{calc-embedded-open-mode} and
|
|
@code{calc-embedded-close-mode} are strings which Calc will place before
|
|
and after any mode annotations that it inserts. Calc never scans for
|
|
these strings; Calc always looks for the annotation itself, so it is not
|
|
necessary to add them to user-written annotations.
|
|
|
|
The default value of @code{calc-embedded-open-mode} is @code{"% "}
|
|
and the default value of @code{calc-embedded-close-mode} is
|
|
@code{"\n"}.
|
|
If you change the value of @code{calc-embedded-close-mode}, it is a good
|
|
idea still to end with a newline so that mode annotations will appear on
|
|
lines by themselves.
|
|
|
|
The variable @code{calc-embedded-open-close-mode-alist} is used to
|
|
set @code{calc-embedded-open-mode} and
|
|
@code{calc-embedded-close-mode} to different strings
|
|
expressions depending on the major mode of the editing buffer.
|
|
It consists of a list of lists of the form
|
|
@code{(@var{MAJOR-MODE} @var{OPEN-MODE-STRING}
|
|
@var{CLOSE-MODE-STRING})}, and its default value is
|
|
@example
|
|
((c++-mode "// " "\n")
|
|
(c-mode "/* " " */\n")
|
|
(f90-mode "! " "\n")
|
|
(fortran-mode "C " "\n")
|
|
(html-helper-mode "<!-- " " -->\n")
|
|
(html-mode "<!-- " " -->\n")
|
|
(nroff-mode "\\\" " "\n")
|
|
(pascal-mode "@{ " " @}\n")
|
|
(sgml-mode "<!-- " " -->\n")
|
|
(xml-mode "<!-- " " -->\n")
|
|
(texinfo-mode "@@c " "\n"))
|
|
@end example
|
|
Any major modes added to @code{calc-embedded-open-close-mode-alist}
|
|
should also be added to @code{calc-embedded-announce-formula-alist}
|
|
and @code{calc-embedded-open-close-plain-alist}.
|
|
@end defvar
|
|
|
|
@node Reporting Bugs, Summary, Customizing Calc, Top
|
|
@appendix Reporting Bugs
|
|
|
|
@noindent
|
|
If you find a bug in Calc, send e-mail to Jay Belanger,
|
|
|
|
@example
|
|
belanger@@truman.edu
|
|
@end example
|
|
|
|
@noindent
|
|
There is an automatic command @kbd{M-x report-calc-bug} which helps
|
|
you to report bugs. This command prompts you for a brief subject
|
|
line, then leaves you in a mail editing buffer. Type @kbd{C-c C-c} to
|
|
send your mail. Make sure your subject line indicates that you are
|
|
reporting a Calc bug; this command sends mail to the maintainer's
|
|
regular mailbox.
|
|
|
|
If you have suggestions for additional features for Calc, please send
|
|
them. Some have dared to suggest that Calc is already top-heavy with
|
|
features; this obviously cannot be the case, so if you have ideas, send
|
|
them right in.
|
|
|
|
At the front of the source file, @file{calc.el}, is a list of ideas for
|
|
future work. If any enthusiastic souls wish to take it upon themselves
|
|
to work on these, please send a message (using @kbd{M-x report-calc-bug})
|
|
so any efforts can be coordinated.
|
|
|
|
The latest version of Calc is available from Savannah, in the Emacs
|
|
CVS tree. See @uref{http://savannah.gnu.org/projects/emacs}.
|
|
|
|
@c [summary]
|
|
@node Summary, Key Index, Reporting Bugs, Top
|
|
@appendix Calc Summary
|
|
|
|
@noindent
|
|
This section includes a complete list of Calc 2.1 keystroke commands.
|
|
Each line lists the stack entries used by the command (top-of-stack
|
|
last), the keystrokes themselves, the prompts asked by the command,
|
|
and the result of the command (also with top-of-stack last).
|
|
The result is expressed using the equivalent algebraic function.
|
|
Commands which put no results on the stack show the full @kbd{M-x}
|
|
command name in that position. Numbers preceding the result or
|
|
command name refer to notes at the end.
|
|
|
|
Algebraic functions and @kbd{M-x} commands that don't have corresponding
|
|
keystrokes are not listed in this summary.
|
|
@xref{Command Index}. @xref{Function Index}.
|
|
|
|
@iftex
|
|
@begingroup
|
|
@tex
|
|
\vskip-2\baselineskip \null
|
|
\gdef\sumrow#1{\sumrowx#1\relax}%
|
|
\gdef\sumrowx#1\:#2\:#3\:#4\:#5\:#6\relax{%
|
|
\leavevmode%
|
|
{\smallfonts
|
|
\hbox to5em{\sl\hss#1}%
|
|
\hbox to5em{\tt#2\hss}%
|
|
\hbox to4em{\sl#3\hss}%
|
|
\hbox to5em{\rm\hss#4}%
|
|
\thinspace%
|
|
{\tt#5}%
|
|
{\sl#6}%
|
|
}}%
|
|
\gdef\sumlpar{{\rm(}}%
|
|
\gdef\sumrpar{{\rm)}}%
|
|
\gdef\sumcomma{{\rm,\thinspace}}%
|
|
\gdef\sumexcl{{\rm!}}%
|
|
\gdef\sumbreak{\vskip-2.5\baselineskip\goodbreak}%
|
|
\gdef\minus#1{{\tt-}}%
|
|
@end tex
|
|
@let@:=@sumsep
|
|
@let@r=@sumrow
|
|
@catcode`@(=@active @let(=@sumlpar
|
|
@catcode`@)=@active @let)=@sumrpar
|
|
@catcode`@,=@active @let,=@sumcomma
|
|
@catcode`@!=@active @let!=@sumexcl
|
|
@end iftex
|
|
@format
|
|
@iftex
|
|
@advance@baselineskip-2.5pt
|
|
@let@c@sumbreak
|
|
@end iftex
|
|
@r{ @: C-x * a @: @: 33 @:calc-embedded-activate@:}
|
|
@r{ @: C-x * b @: @: @:calc-big-or-small@:}
|
|
@r{ @: C-x * c @: @: @:calc@:}
|
|
@r{ @: C-x * d @: @: @:calc-embedded-duplicate@:}
|
|
@r{ @: C-x * e @: @: 34 @:calc-embedded@:}
|
|
@r{ @: C-x * f @:formula @: @:calc-embedded-new-formula@:}
|
|
@r{ @: C-x * g @: @: 35 @:calc-grab-region@:}
|
|
@r{ @: C-x * i @: @: @:calc-info@:}
|
|
@r{ @: C-x * j @: @: @:calc-embedded-select@:}
|
|
@r{ @: C-x * k @: @: @:calc-keypad@:}
|
|
@r{ @: C-x * l @: @: @:calc-load-everything@:}
|
|
@r{ @: C-x * m @: @: @:read-kbd-macro@:}
|
|
@r{ @: C-x * n @: @: 4 @:calc-embedded-next@:}
|
|
@r{ @: C-x * o @: @: @:calc-other-window@:}
|
|
@r{ @: C-x * p @: @: 4 @:calc-embedded-previous@:}
|
|
@r{ @: C-x * q @:formula @: @:quick-calc@:}
|
|
@r{ @: C-x * r @: @: 36 @:calc-grab-rectangle@:}
|
|
@r{ @: C-x * s @: @: @:calc-info-summary@:}
|
|
@r{ @: C-x * t @: @: @:calc-tutorial@:}
|
|
@r{ @: C-x * u @: @: @:calc-embedded-update-formula@:}
|
|
@r{ @: C-x * w @: @: @:calc-embedded-word@:}
|
|
@r{ @: C-x * x @: @: @:calc-quit@:}
|
|
@r{ @: C-x * y @: @:1,28,49 @:calc-copy-to-buffer@:}
|
|
@r{ @: C-x * z @: @: @:calc-user-invocation@:}
|
|
@r{ @: C-x * : @: @: 36 @:calc-grab-sum-down@:}
|
|
@r{ @: C-x * _ @: @: 36 @:calc-grab-sum-across@:}
|
|
@r{ @: C-x * ` @:editing @: 30 @:calc-embedded-edit@:}
|
|
@r{ @: C-x * 0 @:(zero) @: @:calc-reset@:}
|
|
|
|
@c
|
|
@r{ @: 0-9 @:number @: @:@:number}
|
|
@r{ @: . @:number @: @:@:0.number}
|
|
@r{ @: _ @:number @: @:-@:number}
|
|
@r{ @: e @:number @: @:@:1e number}
|
|
@r{ @: # @:number @: @:@:current-radix@tfn{#}number}
|
|
@r{ @: P @:(in number) @: @:+/-@:}
|
|
@r{ @: M @:(in number) @: @:mod@:}
|
|
@r{ @: @@ ' " @: (in number)@: @:@:HMS form}
|
|
@r{ @: h m s @: (in number)@: @:@:HMS form}
|
|
|
|
@c
|
|
@r{ @: ' @:formula @: 37,46 @:@:formula}
|
|
@r{ @: $ @:formula @: 37,46 @:$@:formula}
|
|
@r{ @: " @:string @: 37,46 @:@:string}
|
|
|
|
@c
|
|
@r{ a b@: + @: @: 2 @:add@:(a,b) a+b}
|
|
@r{ a b@: - @: @: 2 @:sub@:(a,b) a@minus{}b}
|
|
@r{ a b@: * @: @: 2 @:mul@:(a,b) a b, a*b}
|
|
@r{ a b@: / @: @: 2 @:div@:(a,b) a/b}
|
|
@r{ a b@: ^ @: @: 2 @:pow@:(a,b) a^b}
|
|
@r{ a b@: I ^ @: @: 2 @:nroot@:(a,b) a^(1/b)}
|
|
@r{ a b@: % @: @: 2 @:mod@:(a,b) a%b}
|
|
@r{ a b@: \ @: @: 2 @:idiv@:(a,b) a\b}
|
|
@r{ a b@: : @: @: 2 @:fdiv@:(a,b)}
|
|
@r{ a b@: | @: @: 2 @:vconcat@:(a,b) a|b}
|
|
@r{ a b@: I | @: @: @:vconcat@:(b,a) b|a}
|
|
@r{ a b@: H | @: @: 2 @:append@:(a,b)}
|
|
@r{ a b@: I H | @: @: @:append@:(b,a)}
|
|
@r{ a@: & @: @: 1 @:inv@:(a) 1/a}
|
|
@r{ a@: ! @: @: 1 @:fact@:(a) a!}
|
|
@r{ a@: = @: @: 1 @:evalv@:(a)}
|
|
@r{ a@: M-% @: @: @:percent@:(a) a%}
|
|
|
|
@c
|
|
@r{ ... a@: @key{RET} @: @: 1 @:@:... a a}
|
|
@r{ ... a@: @key{SPC} @: @: 1 @:@:... a a}
|
|
@r{... a b@: @key{TAB} @: @: 3 @:@:... b a}
|
|
@r{. a b c@: M-@key{TAB} @: @: 3 @:@:... b c a}
|
|
@r{... a b@: @key{LFD} @: @: 1 @:@:... a b a}
|
|
@r{ ... a@: @key{DEL} @: @: 1 @:@:...}
|
|
@r{... a b@: M-@key{DEL} @: @: 1 @:@:... b}
|
|
@r{ @: M-@key{RET} @: @: 4 @:calc-last-args@:}
|
|
@r{ a@: ` @:editing @: 1,30 @:calc-edit@:}
|
|
|
|
@c
|
|
@r{ ... a@: C-d @: @: 1 @:@:...}
|
|
@r{ @: C-k @: @: 27 @:calc-kill@:}
|
|
@r{ @: C-w @: @: 27 @:calc-kill-region@:}
|
|
@r{ @: C-y @: @: @:calc-yank@:}
|
|
@r{ @: C-_ @: @: 4 @:calc-undo@:}
|
|
@r{ @: M-k @: @: 27 @:calc-copy-as-kill@:}
|
|
@r{ @: M-w @: @: 27 @:calc-copy-region-as-kill@:}
|
|
|
|
@c
|
|
@r{ @: [ @: @: @:@:[...}
|
|
@r{[.. a b@: ] @: @: @:@:[a,b]}
|
|
@r{ @: ( @: @: @:@:(...}
|
|
@r{(.. a b@: ) @: @: @:@:(a,b)}
|
|
@r{ @: , @: @: @:@:vector or rect complex}
|
|
@r{ @: ; @: @: @:@:matrix or polar complex}
|
|
@r{ @: .. @: @: @:@:interval}
|
|
|
|
@c
|
|
@r{ @: ~ @: @: @:calc-num-prefix@:}
|
|
@r{ @: < @: @: 4 @:calc-scroll-left@:}
|
|
@r{ @: > @: @: 4 @:calc-scroll-right@:}
|
|
@r{ @: @{ @: @: 4 @:calc-scroll-down@:}
|
|
@r{ @: @} @: @: 4 @:calc-scroll-up@:}
|
|
@r{ @: ? @: @: @:calc-help@:}
|
|
|
|
@c
|
|
@r{ a@: n @: @: 1 @:neg@:(a) @minus{}a}
|
|
@r{ @: o @: @: 4 @:calc-realign@:}
|
|
@r{ @: p @:precision @: 31 @:calc-precision@:}
|
|
@r{ @: q @: @: @:calc-quit@:}
|
|
@r{ @: w @: @: @:calc-why@:}
|
|
@r{ @: x @:command @: @:M-x calc-@:command}
|
|
@r{ a@: y @: @:1,28,49 @:calc-copy-to-buffer@:}
|
|
|
|
@c
|
|
@r{ a@: A @: @: 1 @:abs@:(a)}
|
|
@r{ a b@: B @: @: 2 @:log@:(a,b)}
|
|
@r{ a b@: I B @: @: 2 @:alog@:(a,b) b^a}
|
|
@r{ a@: C @: @: 1 @:cos@:(a)}
|
|
@r{ a@: I C @: @: 1 @:arccos@:(a)}
|
|
@r{ a@: H C @: @: 1 @:cosh@:(a)}
|
|
@r{ a@: I H C @: @: 1 @:arccosh@:(a)}
|
|
@r{ @: D @: @: 4 @:calc-redo@:}
|
|
@r{ a@: E @: @: 1 @:exp@:(a)}
|
|
@r{ a@: H E @: @: 1 @:exp10@:(a) 10.^a}
|
|
@r{ a@: F @: @: 1,11 @:floor@:(a,d)}
|
|
@r{ a@: I F @: @: 1,11 @:ceil@:(a,d)}
|
|
@r{ a@: H F @: @: 1,11 @:ffloor@:(a,d)}
|
|
@r{ a@: I H F @: @: 1,11 @:fceil@:(a,d)}
|
|
@r{ a@: G @: @: 1 @:arg@:(a)}
|
|
@r{ @: H @:command @: 32 @:@:Hyperbolic}
|
|
@r{ @: I @:command @: 32 @:@:Inverse}
|
|
@r{ a@: J @: @: 1 @:conj@:(a)}
|
|
@r{ @: K @:command @: 32 @:@:Keep-args}
|
|
@r{ a@: L @: @: 1 @:ln@:(a)}
|
|
@r{ a@: H L @: @: 1 @:log10@:(a)}
|
|
@r{ @: M @: @: @:calc-more-recursion-depth@:}
|
|
@r{ @: I M @: @: @:calc-less-recursion-depth@:}
|
|
@r{ a@: N @: @: 5 @:evalvn@:(a)}
|
|
@r{ @: P @: @: @:@:pi}
|
|
@r{ @: I P @: @: @:@:gamma}
|
|
@r{ @: H P @: @: @:@:e}
|
|
@r{ @: I H P @: @: @:@:phi}
|
|
@r{ a@: Q @: @: 1 @:sqrt@:(a)}
|
|
@r{ a@: I Q @: @: 1 @:sqr@:(a) a^2}
|
|
@r{ a@: R @: @: 1,11 @:round@:(a,d)}
|
|
@r{ a@: I R @: @: 1,11 @:trunc@:(a,d)}
|
|
@r{ a@: H R @: @: 1,11 @:fround@:(a,d)}
|
|
@r{ a@: I H R @: @: 1,11 @:ftrunc@:(a,d)}
|
|
@r{ a@: S @: @: 1 @:sin@:(a)}
|
|
@r{ a@: I S @: @: 1 @:arcsin@:(a)}
|
|
@r{ a@: H S @: @: 1 @:sinh@:(a)}
|
|
@r{ a@: I H S @: @: 1 @:arcsinh@:(a)}
|
|
@r{ a@: T @: @: 1 @:tan@:(a)}
|
|
@r{ a@: I T @: @: 1 @:arctan@:(a)}
|
|
@r{ a@: H T @: @: 1 @:tanh@:(a)}
|
|
@r{ a@: I H T @: @: 1 @:arctanh@:(a)}
|
|
@r{ @: U @: @: 4 @:calc-undo@:}
|
|
@r{ @: X @: @: 4 @:calc-call-last-kbd-macro@:}
|
|
|
|
@c
|
|
@r{ a b@: a = @: @: 2 @:eq@:(a,b) a=b}
|
|
@r{ a b@: a # @: @: 2 @:neq@:(a,b) a!=b}
|
|
@r{ a b@: a < @: @: 2 @:lt@:(a,b) a<b}
|
|
@r{ a b@: a > @: @: 2 @:gt@:(a,b) a>b}
|
|
@r{ a b@: a [ @: @: 2 @:leq@:(a,b) a<=b}
|
|
@r{ a b@: a ] @: @: 2 @:geq@:(a,b) a>=b}
|
|
@r{ a b@: a @{ @: @: 2 @:in@:(a,b)}
|
|
@r{ a b@: a & @: @: 2,45 @:land@:(a,b) a&&b}
|
|
@r{ a b@: a | @: @: 2,45 @:lor@:(a,b) a||b}
|
|
@r{ a@: a ! @: @: 1,45 @:lnot@:(a) !a}
|
|
@r{ a b c@: a : @: @: 45 @:if@:(a,b,c) a?b:c}
|
|
@r{ a@: a . @: @: 1 @:rmeq@:(a)}
|
|
@r{ a@: a " @: @: 7,8 @:calc-expand-formula@:}
|
|
|
|
@c
|
|
@r{ a@: a + @:i, l, h @: 6,38 @:sum@:(a,i,l,h)}
|
|
@r{ a@: a - @:i, l, h @: 6,38 @:asum@:(a,i,l,h)}
|
|
@r{ a@: a * @:i, l, h @: 6,38 @:prod@:(a,i,l,h)}
|
|
@r{ a b@: a _ @: @: 2 @:subscr@:(a,b) a_b}
|
|
|
|
@c
|
|
@r{ a b@: a \ @: @: 2 @:pdiv@:(a,b)}
|
|
@r{ a b@: a % @: @: 2 @:prem@:(a,b)}
|
|
@r{ a b@: a / @: @: 2 @:pdivrem@:(a,b) [q,r]}
|
|
@r{ a b@: H a / @: @: 2 @:pdivide@:(a,b) q+r/b}
|
|
|
|
@c
|
|
@r{ a@: a a @: @: 1 @:apart@:(a)}
|
|
@r{ a@: a b @:old, new @: 38 @:subst@:(a,old,new)}
|
|
@r{ a@: a c @:v @: 38 @:collect@:(a,v)}
|
|
@r{ a@: a d @:v @: 4,38 @:deriv@:(a,v)}
|
|
@r{ a@: H a d @:v @: 4,38 @:tderiv@:(a,v)}
|
|
@r{ a@: a e @: @: @:esimplify@:(a)}
|
|
@r{ a@: a f @: @: 1 @:factor@:(a)}
|
|
@r{ a@: H a f @: @: 1 @:factors@:(a)}
|
|
@r{ a b@: a g @: @: 2 @:pgcd@:(a,b)}
|
|
@r{ a@: a i @:v @: 38 @:integ@:(a,v)}
|
|
@r{ a@: a m @:pats @: 38 @:match@:(a,pats)}
|
|
@r{ a@: I a m @:pats @: 38 @:matchnot@:(a,pats)}
|
|
@r{ data x@: a p @: @: 28 @:polint@:(data,x)}
|
|
@r{ data x@: H a p @: @: 28 @:ratint@:(data,x)}
|
|
@r{ a@: a n @: @: 1 @:nrat@:(a)}
|
|
@r{ a@: a r @:rules @:4,8,38 @:rewrite@:(a,rules,n)}
|
|
@r{ a@: a s @: @: @:simplify@:(a)}
|
|
@r{ a@: a t @:v, n @: 31,39 @:taylor@:(a,v,n)}
|
|
@r{ a@: a v @: @: 7,8 @:calc-alg-evaluate@:}
|
|
@r{ a@: a x @: @: 4,8 @:expand@:(a)}
|
|
|
|
@c
|
|
@r{ data@: a F @:model, vars @: 48 @:fit@:(m,iv,pv,data)}
|
|
@r{ data@: I a F @:model, vars @: 48 @:xfit@:(m,iv,pv,data)}
|
|
@r{ data@: H a F @:model, vars @: 48 @:efit@:(m,iv,pv,data)}
|
|
@r{ a@: a I @:v, l, h @: 38 @:ninteg@:(a,v,l,h)}
|
|
@r{ a b@: a M @:op @: 22 @:mapeq@:(op,a,b)}
|
|
@r{ a b@: I a M @:op @: 22 @:mapeqr@:(op,a,b)}
|
|
@r{ a b@: H a M @:op @: 22 @:mapeqp@:(op,a,b)}
|
|
@r{ a g@: a N @:v @: 38 @:minimize@:(a,v,g)}
|
|
@r{ a g@: H a N @:v @: 38 @:wminimize@:(a,v,g)}
|
|
@r{ a@: a P @:v @: 38 @:roots@:(a,v)}
|
|
@r{ a g@: a R @:v @: 38 @:root@:(a,v,g)}
|
|
@r{ a g@: H a R @:v @: 38 @:wroot@:(a,v,g)}
|
|
@r{ a@: a S @:v @: 38 @:solve@:(a,v)}
|
|
@r{ a@: I a S @:v @: 38 @:finv@:(a,v)}
|
|
@r{ a@: H a S @:v @: 38 @:fsolve@:(a,v)}
|
|
@r{ a@: I H a S @:v @: 38 @:ffinv@:(a,v)}
|
|
@r{ a@: a T @:i, l, h @: 6,38 @:table@:(a,i,l,h)}
|
|
@r{ a g@: a X @:v @: 38 @:maximize@:(a,v,g)}
|
|
@r{ a g@: H a X @:v @: 38 @:wmaximize@:(a,v,g)}
|
|
|
|
@c
|
|
@r{ a b@: b a @: @: 9 @:and@:(a,b,w)}
|
|
@r{ a@: b c @: @: 9 @:clip@:(a,w)}
|
|
@r{ a b@: b d @: @: 9 @:diff@:(a,b,w)}
|
|
@r{ a@: b l @: @: 10 @:lsh@:(a,n,w)}
|
|
@r{ a n@: H b l @: @: 9 @:lsh@:(a,n,w)}
|
|
@r{ a@: b n @: @: 9 @:not@:(a,w)}
|
|
@r{ a b@: b o @: @: 9 @:or@:(a,b,w)}
|
|
@r{ v@: b p @: @: 1 @:vpack@:(v)}
|
|
@r{ a@: b r @: @: 10 @:rsh@:(a,n,w)}
|
|
@r{ a n@: H b r @: @: 9 @:rsh@:(a,n,w)}
|
|
@r{ a@: b t @: @: 10 @:rot@:(a,n,w)}
|
|
@r{ a n@: H b t @: @: 9 @:rot@:(a,n,w)}
|
|
@r{ a@: b u @: @: 1 @:vunpack@:(a)}
|
|
@r{ @: b w @:w @: 9,50 @:calc-word-size@:}
|
|
@r{ a b@: b x @: @: 9 @:xor@:(a,b,w)}
|
|
|
|
@c
|
|
@r{c s l p@: b D @: @: @:ddb@:(c,s,l,p)}
|
|
@r{ r n p@: b F @: @: @:fv@:(r,n,p)}
|
|
@r{ r n p@: I b F @: @: @:fvb@:(r,n,p)}
|
|
@r{ r n p@: H b F @: @: @:fvl@:(r,n,p)}
|
|
@r{ v@: b I @: @: 19 @:irr@:(v)}
|
|
@r{ v@: I b I @: @: 19 @:irrb@:(v)}
|
|
@r{ a@: b L @: @: 10 @:ash@:(a,n,w)}
|
|
@r{ a n@: H b L @: @: 9 @:ash@:(a,n,w)}
|
|
@r{ r n a@: b M @: @: @:pmt@:(r,n,a)}
|
|
@r{ r n a@: I b M @: @: @:pmtb@:(r,n,a)}
|
|
@r{ r n a@: H b M @: @: @:pmtl@:(r,n,a)}
|
|
@r{ r v@: b N @: @: 19 @:npv@:(r,v)}
|
|
@r{ r v@: I b N @: @: 19 @:npvb@:(r,v)}
|
|
@r{ r n p@: b P @: @: @:pv@:(r,n,p)}
|
|
@r{ r n p@: I b P @: @: @:pvb@:(r,n,p)}
|
|
@r{ r n p@: H b P @: @: @:pvl@:(r,n,p)}
|
|
@r{ a@: b R @: @: 10 @:rash@:(a,n,w)}
|
|
@r{ a n@: H b R @: @: 9 @:rash@:(a,n,w)}
|
|
@r{ c s l@: b S @: @: @:sln@:(c,s,l)}
|
|
@r{ n p a@: b T @: @: @:rate@:(n,p,a)}
|
|
@r{ n p a@: I b T @: @: @:rateb@:(n,p,a)}
|
|
@r{ n p a@: H b T @: @: @:ratel@:(n,p,a)}
|
|
@r{c s l p@: b Y @: @: @:syd@:(c,s,l,p)}
|
|
|
|
@r{ r p a@: b # @: @: @:nper@:(r,p,a)}
|
|
@r{ r p a@: I b # @: @: @:nperb@:(r,p,a)}
|
|
@r{ r p a@: H b # @: @: @:nperl@:(r,p,a)}
|
|
@r{ a b@: b % @: @: @:relch@:(a,b)}
|
|
|
|
@c
|
|
@r{ a@: c c @: @: 5 @:pclean@:(a,p)}
|
|
@r{ a@: c 0-9 @: @: @:pclean@:(a,p)}
|
|
@r{ a@: H c c @: @: 5 @:clean@:(a,p)}
|
|
@r{ a@: H c 0-9 @: @: @:clean@:(a,p)}
|
|
@r{ a@: c d @: @: 1 @:deg@:(a)}
|
|
@r{ a@: c f @: @: 1 @:pfloat@:(a)}
|
|
@r{ a@: H c f @: @: 1 @:float@:(a)}
|
|
@r{ a@: c h @: @: 1 @:hms@:(a)}
|
|
@r{ a@: c p @: @: @:polar@:(a)}
|
|
@r{ a@: I c p @: @: @:rect@:(a)}
|
|
@r{ a@: c r @: @: 1 @:rad@:(a)}
|
|
|
|
@c
|
|
@r{ a@: c F @: @: 5 @:pfrac@:(a,p)}
|
|
@r{ a@: H c F @: @: 5 @:frac@:(a,p)}
|
|
|
|
@c
|
|
@r{ a@: c % @: @: @:percent@:(a*100)}
|
|
|
|
@c
|
|
@r{ @: d . @:char @: 50 @:calc-point-char@:}
|
|
@r{ @: d , @:char @: 50 @:calc-group-char@:}
|
|
@r{ @: d < @: @: 13,50 @:calc-left-justify@:}
|
|
@r{ @: d = @: @: 13,50 @:calc-center-justify@:}
|
|
@r{ @: d > @: @: 13,50 @:calc-right-justify@:}
|
|
@r{ @: d @{ @:label @: 50 @:calc-left-label@:}
|
|
@r{ @: d @} @:label @: 50 @:calc-right-label@:}
|
|
@r{ @: d [ @: @: 4 @:calc-truncate-up@:}
|
|
@r{ @: d ] @: @: 4 @:calc-truncate-down@:}
|
|
@r{ @: d " @: @: 12,50 @:calc-display-strings@:}
|
|
@r{ @: d @key{SPC} @: @: @:calc-refresh@:}
|
|
@r{ @: d @key{RET} @: @: 1 @:calc-refresh-top@:}
|
|
|
|
@c
|
|
@r{ @: d 0 @: @: 50 @:calc-decimal-radix@:}
|
|
@r{ @: d 2 @: @: 50 @:calc-binary-radix@:}
|
|
@r{ @: d 6 @: @: 50 @:calc-hex-radix@:}
|
|
@r{ @: d 8 @: @: 50 @:calc-octal-radix@:}
|
|
|
|
@c
|
|
@r{ @: d b @: @:12,13,50 @:calc-line-breaking@:}
|
|
@r{ @: d c @: @: 50 @:calc-complex-notation@:}
|
|
@r{ @: d d @:format @: 50 @:calc-date-notation@:}
|
|
@r{ @: d e @: @: 5,50 @:calc-eng-notation@:}
|
|
@r{ @: d f @:num @: 31,50 @:calc-fix-notation@:}
|
|
@r{ @: d g @: @:12,13,50 @:calc-group-digits@:}
|
|
@r{ @: d h @:format @: 50 @:calc-hms-notation@:}
|
|
@r{ @: d i @: @: 50 @:calc-i-notation@:}
|
|
@r{ @: d j @: @: 50 @:calc-j-notation@:}
|
|
@r{ @: d l @: @: 12,50 @:calc-line-numbering@:}
|
|
@r{ @: d n @: @: 5,50 @:calc-normal-notation@:}
|
|
@r{ @: d o @:format @: 50 @:calc-over-notation@:}
|
|
@r{ @: d p @: @: 12,50 @:calc-show-plain@:}
|
|
@r{ @: d r @:radix @: 31,50 @:calc-radix@:}
|
|
@r{ @: d s @: @: 5,50 @:calc-sci-notation@:}
|
|
@r{ @: d t @: @: 27 @:calc-truncate-stack@:}
|
|
@r{ @: d w @: @: 12,13 @:calc-auto-why@:}
|
|
@r{ @: d z @: @: 12,50 @:calc-leading-zeros@:}
|
|
|
|
@c
|
|
@r{ @: d B @: @: 50 @:calc-big-language@:}
|
|
@r{ @: d C @: @: 50 @:calc-c-language@:}
|
|
@r{ @: d E @: @: 50 @:calc-eqn-language@:}
|
|
@r{ @: d F @: @: 50 @:calc-fortran-language@:}
|
|
@r{ @: d M @: @: 50 @:calc-mathematica-language@:}
|
|
@r{ @: d N @: @: 50 @:calc-normal-language@:}
|
|
@r{ @: d O @: @: 50 @:calc-flat-language@:}
|
|
@r{ @: d P @: @: 50 @:calc-pascal-language@:}
|
|
@r{ @: d T @: @: 50 @:calc-tex-language@:}
|
|
@r{ @: d L @: @: 50 @:calc-latex-language@:}
|
|
@r{ @: d U @: @: 50 @:calc-unformatted-language@:}
|
|
@r{ @: d W @: @: 50 @:calc-maple-language@:}
|
|
|
|
@c
|
|
@r{ a@: f [ @: @: 4 @:decr@:(a,n)}
|
|
@r{ a@: f ] @: @: 4 @:incr@:(a,n)}
|
|
|
|
@c
|
|
@r{ a b@: f b @: @: 2 @:beta@:(a,b)}
|
|
@r{ a@: f e @: @: 1 @:erf@:(a)}
|
|
@r{ a@: I f e @: @: 1 @:erfc@:(a)}
|
|
@r{ a@: f g @: @: 1 @:gamma@:(a)}
|
|
@r{ a b@: f h @: @: 2 @:hypot@:(a,b)}
|
|
@r{ a@: f i @: @: 1 @:im@:(a)}
|
|
@r{ n a@: f j @: @: 2 @:besJ@:(n,a)}
|
|
@r{ a b@: f n @: @: 2 @:min@:(a,b)}
|
|
@r{ a@: f r @: @: 1 @:re@:(a)}
|
|
@r{ a@: f s @: @: 1 @:sign@:(a)}
|
|
@r{ a b@: f x @: @: 2 @:max@:(a,b)}
|
|
@r{ n a@: f y @: @: 2 @:besY@:(n,a)}
|
|
|
|
@c
|
|
@r{ a@: f A @: @: 1 @:abssqr@:(a)}
|
|
@r{ x a b@: f B @: @: @:betaI@:(x,a,b)}
|
|
@r{ x a b@: H f B @: @: @:betaB@:(x,a,b)}
|
|
@r{ a@: f E @: @: 1 @:expm1@:(a)}
|
|
@r{ a x@: f G @: @: 2 @:gammaP@:(a,x)}
|
|
@r{ a x@: I f G @: @: 2 @:gammaQ@:(a,x)}
|
|
@r{ a x@: H f G @: @: 2 @:gammag@:(a,x)}
|
|
@r{ a x@: I H f G @: @: 2 @:gammaG@:(a,x)}
|
|
@r{ a b@: f I @: @: 2 @:ilog@:(a,b)}
|
|
@r{ a b@: I f I @: @: 2 @:alog@:(a,b) b^a}
|
|
@r{ a@: f L @: @: 1 @:lnp1@:(a)}
|
|
@r{ a@: f M @: @: 1 @:mant@:(a)}
|
|
@r{ a@: f Q @: @: 1 @:isqrt@:(a)}
|
|
@r{ a@: I f Q @: @: 1 @:sqr@:(a) a^2}
|
|
@r{ a n@: f S @: @: 2 @:scf@:(a,n)}
|
|
@r{ y x@: f T @: @: @:arctan2@:(y,x)}
|
|
@r{ a@: f X @: @: 1 @:xpon@:(a)}
|
|
|
|
@c
|
|
@r{ x y@: g a @: @: 28,40 @:calc-graph-add@:}
|
|
@r{ @: g b @: @: 12 @:calc-graph-border@:}
|
|
@r{ @: g c @: @: @:calc-graph-clear@:}
|
|
@r{ @: g d @: @: 41 @:calc-graph-delete@:}
|
|
@r{ x y@: g f @: @: 28,40 @:calc-graph-fast@:}
|
|
@r{ @: g g @: @: 12 @:calc-graph-grid@:}
|
|
@r{ @: g h @:title @: @:calc-graph-header@:}
|
|
@r{ @: g j @: @: 4 @:calc-graph-juggle@:}
|
|
@r{ @: g k @: @: 12 @:calc-graph-key@:}
|
|
@r{ @: g l @: @: 12 @:calc-graph-log-x@:}
|
|
@r{ @: g n @:name @: @:calc-graph-name@:}
|
|
@r{ @: g p @: @: 42 @:calc-graph-plot@:}
|
|
@r{ @: g q @: @: @:calc-graph-quit@:}
|
|
@r{ @: g r @:range @: @:calc-graph-range-x@:}
|
|
@r{ @: g s @: @: 12,13 @:calc-graph-line-style@:}
|
|
@r{ @: g t @:title @: @:calc-graph-title-x@:}
|
|
@r{ @: g v @: @: @:calc-graph-view-commands@:}
|
|
@r{ @: g x @:display @: @:calc-graph-display@:}
|
|
@r{ @: g z @: @: 12 @:calc-graph-zero-x@:}
|
|
|
|
@c
|
|
@r{ x y z@: g A @: @: 28,40 @:calc-graph-add-3d@:}
|
|
@r{ @: g C @:command @: @:calc-graph-command@:}
|
|
@r{ @: g D @:device @: 43,44 @:calc-graph-device@:}
|
|
@r{ x y z@: g F @: @: 28,40 @:calc-graph-fast-3d@:}
|
|
@r{ @: g H @: @: 12 @:calc-graph-hide@:}
|
|
@r{ @: g K @: @: @:calc-graph-kill@:}
|
|
@r{ @: g L @: @: 12 @:calc-graph-log-y@:}
|
|
@r{ @: g N @:number @: 43,51 @:calc-graph-num-points@:}
|
|
@r{ @: g O @:filename @: 43,44 @:calc-graph-output@:}
|
|
@r{ @: g P @: @: 42 @:calc-graph-print@:}
|
|
@r{ @: g R @:range @: @:calc-graph-range-y@:}
|
|
@r{ @: g S @: @: 12,13 @:calc-graph-point-style@:}
|
|
@r{ @: g T @:title @: @:calc-graph-title-y@:}
|
|
@r{ @: g V @: @: @:calc-graph-view-trail@:}
|
|
@r{ @: g X @:format @: @:calc-graph-geometry@:}
|
|
@r{ @: g Z @: @: 12 @:calc-graph-zero-y@:}
|
|
|
|
@c
|
|
@r{ @: g C-l @: @: 12 @:calc-graph-log-z@:}
|
|
@r{ @: g C-r @:range @: @:calc-graph-range-z@:}
|
|
@r{ @: g C-t @:title @: @:calc-graph-title-z@:}
|
|
|
|
@c
|
|
@r{ @: h b @: @: @:calc-describe-bindings@:}
|
|
@r{ @: h c @:key @: @:calc-describe-key-briefly@:}
|
|
@r{ @: h f @:function @: @:calc-describe-function@:}
|
|
@r{ @: h h @: @: @:calc-full-help@:}
|
|
@r{ @: h i @: @: @:calc-info@:}
|
|
@r{ @: h k @:key @: @:calc-describe-key@:}
|
|
@r{ @: h n @: @: @:calc-view-news@:}
|
|
@r{ @: h s @: @: @:calc-info-summary@:}
|
|
@r{ @: h t @: @: @:calc-tutorial@:}
|
|
@r{ @: h v @:var @: @:calc-describe-variable@:}
|
|
|
|
@c
|
|
@r{ @: j 1-9 @: @: @:calc-select-part@:}
|
|
@r{ @: j @key{RET} @: @: 27 @:calc-copy-selection@:}
|
|
@r{ @: j @key{DEL} @: @: 27 @:calc-del-selection@:}
|
|
@r{ @: j ' @:formula @: 27 @:calc-enter-selection@:}
|
|
@r{ @: j ` @:editing @: 27,30 @:calc-edit-selection@:}
|
|
@r{ @: j " @: @: 7,27 @:calc-sel-expand-formula@:}
|
|
|
|
@c
|
|
@r{ @: j + @:formula @: 27 @:calc-sel-add-both-sides@:}
|
|
@r{ @: j - @:formula @: 27 @:calc-sel-sub-both-sides@:}
|
|
@r{ @: j * @:formula @: 27 @:calc-sel-mul-both-sides@:}
|
|
@r{ @: j / @:formula @: 27 @:calc-sel-div-both-sides@:}
|
|
@r{ @: j & @: @: 27 @:calc-sel-invert@:}
|
|
|
|
@c
|
|
@r{ @: j a @: @: 27 @:calc-select-additional@:}
|
|
@r{ @: j b @: @: 12 @:calc-break-selections@:}
|
|
@r{ @: j c @: @: @:calc-clear-selections@:}
|
|
@r{ @: j d @: @: 12,50 @:calc-show-selections@:}
|
|
@r{ @: j e @: @: 12 @:calc-enable-selections@:}
|
|
@r{ @: j l @: @: 4,27 @:calc-select-less@:}
|
|
@r{ @: j m @: @: 4,27 @:calc-select-more@:}
|
|
@r{ @: j n @: @: 4 @:calc-select-next@:}
|
|
@r{ @: j o @: @: 4,27 @:calc-select-once@:}
|
|
@r{ @: j p @: @: 4 @:calc-select-previous@:}
|
|
@r{ @: j r @:rules @:4,8,27 @:calc-rewrite-selection@:}
|
|
@r{ @: j s @: @: 4,27 @:calc-select-here@:}
|
|
@r{ @: j u @: @: 27 @:calc-unselect@:}
|
|
@r{ @: j v @: @: 7,27 @:calc-sel-evaluate@:}
|
|
|
|
@c
|
|
@r{ @: j C @: @: 27 @:calc-sel-commute@:}
|
|
@r{ @: j D @: @: 4,27 @:calc-sel-distribute@:}
|
|
@r{ @: j E @: @: 27 @:calc-sel-jump-equals@:}
|
|
@r{ @: j I @: @: 27 @:calc-sel-isolate@:}
|
|
@r{ @: H j I @: @: 27 @:calc-sel-isolate@: (full)}
|
|
@r{ @: j L @: @: 4,27 @:calc-commute-left@:}
|
|
@r{ @: j M @: @: 27 @:calc-sel-merge@:}
|
|
@r{ @: j N @: @: 27 @:calc-sel-negate@:}
|
|
@r{ @: j O @: @: 4,27 @:calc-select-once-maybe@:}
|
|
@r{ @: j R @: @: 4,27 @:calc-commute-right@:}
|
|
@r{ @: j S @: @: 4,27 @:calc-select-here-maybe@:}
|
|
@r{ @: j U @: @: 27 @:calc-sel-unpack@:}
|
|
|
|
@c
|
|
@r{ @: k a @: @: @:calc-random-again@:}
|
|
@r{ n@: k b @: @: 1 @:bern@:(n)}
|
|
@r{ n x@: H k b @: @: 2 @:bern@:(n,x)}
|
|
@r{ n m@: k c @: @: 2 @:choose@:(n,m)}
|
|
@r{ n m@: H k c @: @: 2 @:perm@:(n,m)}
|
|
@r{ n@: k d @: @: 1 @:dfact@:(n) n!!}
|
|
@r{ n@: k e @: @: 1 @:euler@:(n)}
|
|
@r{ n x@: H k e @: @: 2 @:euler@:(n,x)}
|
|
@r{ n@: k f @: @: 4 @:prfac@:(n)}
|
|
@r{ n m@: k g @: @: 2 @:gcd@:(n,m)}
|
|
@r{ m n@: k h @: @: 14 @:shuffle@:(n,m)}
|
|
@r{ n m@: k l @: @: 2 @:lcm@:(n,m)}
|
|
@r{ n@: k m @: @: 1 @:moebius@:(n)}
|
|
@r{ n@: k n @: @: 4 @:nextprime@:(n)}
|
|
@r{ n@: I k n @: @: 4 @:prevprime@:(n)}
|
|
@r{ n@: k p @: @: 4,28 @:calc-prime-test@:}
|
|
@r{ m@: k r @: @: 14 @:random@:(m)}
|
|
@r{ n m@: k s @: @: 2 @:stir1@:(n,m)}
|
|
@r{ n m@: H k s @: @: 2 @:stir2@:(n,m)}
|
|
@r{ n@: k t @: @: 1 @:totient@:(n)}
|
|
|
|
@c
|
|
@r{ n p x@: k B @: @: @:utpb@:(x,n,p)}
|
|
@r{ n p x@: I k B @: @: @:ltpb@:(x,n,p)}
|
|
@r{ v x@: k C @: @: @:utpc@:(x,v)}
|
|
@r{ v x@: I k C @: @: @:ltpc@:(x,v)}
|
|
@r{ n m@: k E @: @: @:egcd@:(n,m)}
|
|
@r{v1 v2 x@: k F @: @: @:utpf@:(x,v1,v2)}
|
|
@r{v1 v2 x@: I k F @: @: @:ltpf@:(x,v1,v2)}
|
|
@r{ m s x@: k N @: @: @:utpn@:(x,m,s)}
|
|
@r{ m s x@: I k N @: @: @:ltpn@:(x,m,s)}
|
|
@r{ m x@: k P @: @: @:utpp@:(x,m)}
|
|
@r{ m x@: I k P @: @: @:ltpp@:(x,m)}
|
|
@r{ v x@: k T @: @: @:utpt@:(x,v)}
|
|
@r{ v x@: I k T @: @: @:ltpt@:(x,v)}
|
|
|
|
@c
|
|
@r{ @: m a @: @: 12,13 @:calc-algebraic-mode@:}
|
|
@r{ @: m d @: @: @:calc-degrees-mode@:}
|
|
@r{ @: m e @: @: @:calc-embedded-preserve-modes@:}
|
|
@r{ @: m f @: @: 12 @:calc-frac-mode@:}
|
|
@r{ @: m g @: @: 52 @:calc-get-modes@:}
|
|
@r{ @: m h @: @: @:calc-hms-mode@:}
|
|
@r{ @: m i @: @: 12,13 @:calc-infinite-mode@:}
|
|
@r{ @: m m @: @: @:calc-save-modes@:}
|
|
@r{ @: m p @: @: 12 @:calc-polar-mode@:}
|
|
@r{ @: m r @: @: @:calc-radians-mode@:}
|
|
@r{ @: m s @: @: 12 @:calc-symbolic-mode@:}
|
|
@r{ @: m t @: @: 12 @:calc-total-algebraic-mode@:}
|
|
@r{ @: m v @: @: 12,13 @:calc-matrix-mode@:}
|
|
@r{ @: m w @: @: 13 @:calc-working@:}
|
|
@r{ @: m x @: @: @:calc-always-load-extensions@:}
|
|
|
|
@c
|
|
@r{ @: m A @: @: 12 @:calc-alg-simplify-mode@:}
|
|
@r{ @: m B @: @: 12 @:calc-bin-simplify-mode@:}
|
|
@r{ @: m C @: @: 12 @:calc-auto-recompute@:}
|
|
@r{ @: m D @: @: @:calc-default-simplify-mode@:}
|
|
@r{ @: m E @: @: 12 @:calc-ext-simplify-mode@:}
|
|
@r{ @: m F @:filename @: 13 @:calc-settings-file-name@:}
|
|
@r{ @: m N @: @: 12 @:calc-num-simplify-mode@:}
|
|
@r{ @: m O @: @: 12 @:calc-no-simplify-mode@:}
|
|
@r{ @: m R @: @: 12,13 @:calc-mode-record-mode@:}
|
|
@r{ @: m S @: @: 12 @:calc-shift-prefix@:}
|
|
@r{ @: m U @: @: 12 @:calc-units-simplify-mode@:}
|
|
|
|
@c
|
|
@r{ @: s c @:var1, var2 @: 29 @:calc-copy-variable@:}
|
|
@r{ @: s d @:var, decl @: @:calc-declare-variable@:}
|
|
@r{ @: s e @:var, editing @: 29,30 @:calc-edit-variable@:}
|
|
@r{ @: s i @:buffer @: @:calc-insert-variables@:}
|
|
@r{ @: s k @:const, var @: 29 @:calc-copy-special-constant@:}
|
|
@r{ a b@: s l @:var @: 29 @:@:a (letting var=b)}
|
|
@r{ a ...@: s m @:op, var @: 22,29 @:calc-store-map@:}
|
|
@r{ @: s n @:var @: 29,47 @:calc-store-neg@: (v/-1)}
|
|
@r{ @: s p @:var @: 29 @:calc-permanent-variable@:}
|
|
@r{ @: s r @:var @: 29 @:@:v (recalled value)}
|
|
@r{ @: r 0-9 @: @: @:calc-recall-quick@:}
|
|
@r{ a@: s s @:var @: 28,29 @:calc-store@:}
|
|
@r{ a@: s 0-9 @: @: @:calc-store-quick@:}
|
|
@r{ a@: s t @:var @: 29 @:calc-store-into@:}
|
|
@r{ a@: t 0-9 @: @: @:calc-store-into-quick@:}
|
|
@r{ @: s u @:var @: 29 @:calc-unstore@:}
|
|
@r{ a@: s x @:var @: 29 @:calc-store-exchange@:}
|
|
|
|
@c
|
|
@r{ @: s A @:editing @: 30 @:calc-edit-AlgSimpRules@:}
|
|
@r{ @: s D @:editing @: 30 @:calc-edit-Decls@:}
|
|
@r{ @: s E @:editing @: 30 @:calc-edit-EvalRules@:}
|
|
@r{ @: s F @:editing @: 30 @:calc-edit-FitRules@:}
|
|
@r{ @: s G @:editing @: 30 @:calc-edit-GenCount@:}
|
|
@r{ @: s H @:editing @: 30 @:calc-edit-Holidays@:}
|
|
@r{ @: s I @:editing @: 30 @:calc-edit-IntegLimit@:}
|
|
@r{ @: s L @:editing @: 30 @:calc-edit-LineStyles@:}
|
|
@r{ @: s P @:editing @: 30 @:calc-edit-PointStyles@:}
|
|
@r{ @: s R @:editing @: 30 @:calc-edit-PlotRejects@:}
|
|
@r{ @: s T @:editing @: 30 @:calc-edit-TimeZone@:}
|
|
@r{ @: s U @:editing @: 30 @:calc-edit-Units@:}
|
|
@r{ @: s X @:editing @: 30 @:calc-edit-ExtSimpRules@:}
|
|
|
|
@c
|
|
@r{ a@: s + @:var @: 29,47 @:calc-store-plus@: (v+a)}
|
|
@r{ a@: s - @:var @: 29,47 @:calc-store-minus@: (v-a)}
|
|
@r{ a@: s * @:var @: 29,47 @:calc-store-times@: (v*a)}
|
|
@r{ a@: s / @:var @: 29,47 @:calc-store-div@: (v/a)}
|
|
@r{ a@: s ^ @:var @: 29,47 @:calc-store-power@: (v^a)}
|
|
@r{ a@: s | @:var @: 29,47 @:calc-store-concat@: (v|a)}
|
|
@r{ @: s & @:var @: 29,47 @:calc-store-inv@: (v^-1)}
|
|
@r{ @: s [ @:var @: 29,47 @:calc-store-decr@: (v-1)}
|
|
@r{ @: s ] @:var @: 29,47 @:calc-store-incr@: (v-(-1))}
|
|
@r{ a b@: s : @: @: 2 @:assign@:(a,b) a @tfn{:=} b}
|
|
@r{ a@: s = @: @: 1 @:evalto@:(a,b) a @tfn{=>}}
|
|
|
|
@c
|
|
@r{ @: t [ @: @: 4 @:calc-trail-first@:}
|
|
@r{ @: t ] @: @: 4 @:calc-trail-last@:}
|
|
@r{ @: t < @: @: 4 @:calc-trail-scroll-left@:}
|
|
@r{ @: t > @: @: 4 @:calc-trail-scroll-right@:}
|
|
@r{ @: t . @: @: 12 @:calc-full-trail-vectors@:}
|
|
|
|
@c
|
|
@r{ @: t b @: @: 4 @:calc-trail-backward@:}
|
|
@r{ @: t d @: @: 12,50 @:calc-trail-display@:}
|
|
@r{ @: t f @: @: 4 @:calc-trail-forward@:}
|
|
@r{ @: t h @: @: @:calc-trail-here@:}
|
|
@r{ @: t i @: @: @:calc-trail-in@:}
|
|
@r{ @: t k @: @: 4 @:calc-trail-kill@:}
|
|
@r{ @: t m @:string @: @:calc-trail-marker@:}
|
|
@r{ @: t n @: @: 4 @:calc-trail-next@:}
|
|
@r{ @: t o @: @: @:calc-trail-out@:}
|
|
@r{ @: t p @: @: 4 @:calc-trail-previous@:}
|
|
@r{ @: t r @:string @: @:calc-trail-isearch-backward@:}
|
|
@r{ @: t s @:string @: @:calc-trail-isearch-forward@:}
|
|
@r{ @: t y @: @: 4 @:calc-trail-yank@:}
|
|
|
|
@c
|
|
@r{ d@: t C @:oz, nz @: @:tzconv@:(d,oz,nz)}
|
|
@r{d oz nz@: t C @:$ @: @:tzconv@:(d,oz,nz)}
|
|
@r{ d@: t D @: @: 15 @:date@:(d)}
|
|
@r{ d@: t I @: @: 4 @:incmonth@:(d,n)}
|
|
@r{ d@: t J @: @: 16 @:julian@:(d,z)}
|
|
@r{ d@: t M @: @: 17 @:newmonth@:(d,n)}
|
|
@r{ @: t N @: @: 16 @:now@:(z)}
|
|
@r{ d@: t P @:1 @: 31 @:year@:(d)}
|
|
@r{ d@: t P @:2 @: 31 @:month@:(d)}
|
|
@r{ d@: t P @:3 @: 31 @:day@:(d)}
|
|
@r{ d@: t P @:4 @: 31 @:hour@:(d)}
|
|
@r{ d@: t P @:5 @: 31 @:minute@:(d)}
|
|
@r{ d@: t P @:6 @: 31 @:second@:(d)}
|
|
@r{ d@: t P @:7 @: 31 @:weekday@:(d)}
|
|
@r{ d@: t P @:8 @: 31 @:yearday@:(d)}
|
|
@r{ d@: t P @:9 @: 31 @:time@:(d)}
|
|
@r{ d@: t U @: @: 16 @:unixtime@:(d,z)}
|
|
@r{ d@: t W @: @: 17 @:newweek@:(d,w)}
|
|
@r{ d@: t Y @: @: 17 @:newyear@:(d,n)}
|
|
|
|
@c
|
|
@r{ a b@: t + @: @: 2 @:badd@:(a,b)}
|
|
@r{ a b@: t - @: @: 2 @:bsub@:(a,b)}
|
|
|
|
@c
|
|
@r{ @: u a @: @: 12 @:calc-autorange-units@:}
|
|
@r{ a@: u b @: @: @:calc-base-units@:}
|
|
@r{ a@: u c @:units @: 18 @:calc-convert-units@:}
|
|
@r{ defn@: u d @:unit, descr @: @:calc-define-unit@:}
|
|
@r{ @: u e @: @: @:calc-explain-units@:}
|
|
@r{ @: u g @:unit @: @:calc-get-unit-definition@:}
|
|
@r{ @: u p @: @: @:calc-permanent-units@:}
|
|
@r{ a@: u r @: @: @:calc-remove-units@:}
|
|
@r{ a@: u s @: @: @:usimplify@:(a)}
|
|
@r{ a@: u t @:units @: 18 @:calc-convert-temperature@:}
|
|
@r{ @: u u @:unit @: @:calc-undefine-unit@:}
|
|
@r{ @: u v @: @: @:calc-enter-units-table@:}
|
|
@r{ a@: u x @: @: @:calc-extract-units@:}
|
|
@r{ a@: u 0-9 @: @: @:calc-quick-units@:}
|
|
|
|
@c
|
|
@r{ v1 v2@: u C @: @: 20 @:vcov@:(v1,v2)}
|
|
@r{ v1 v2@: I u C @: @: 20 @:vpcov@:(v1,v2)}
|
|
@r{ v1 v2@: H u C @: @: 20 @:vcorr@:(v1,v2)}
|
|
@r{ v@: u G @: @: 19 @:vgmean@:(v)}
|
|
@r{ a b@: H u G @: @: 2 @:agmean@:(a,b)}
|
|
@r{ v@: u M @: @: 19 @:vmean@:(v)}
|
|
@r{ v@: I u M @: @: 19 @:vmeane@:(v)}
|
|
@r{ v@: H u M @: @: 19 @:vmedian@:(v)}
|
|
@r{ v@: I H u M @: @: 19 @:vhmean@:(v)}
|
|
@r{ v@: u N @: @: 19 @:vmin@:(v)}
|
|
@r{ v@: u S @: @: 19 @:vsdev@:(v)}
|
|
@r{ v@: I u S @: @: 19 @:vpsdev@:(v)}
|
|
@r{ v@: H u S @: @: 19 @:vvar@:(v)}
|
|
@r{ v@: I H u S @: @: 19 @:vpvar@:(v)}
|
|
@r{ @: u V @: @: @:calc-view-units-table@:}
|
|
@r{ v@: u X @: @: 19 @:vmax@:(v)}
|
|
|
|
@c
|
|
@r{ v@: u + @: @: 19 @:vsum@:(v)}
|
|
@r{ v@: u * @: @: 19 @:vprod@:(v)}
|
|
@r{ v@: u # @: @: 19 @:vcount@:(v)}
|
|
|
|
@c
|
|
@r{ @: V ( @: @: 50 @:calc-vector-parens@:}
|
|
@r{ @: V @{ @: @: 50 @:calc-vector-braces@:}
|
|
@r{ @: V [ @: @: 50 @:calc-vector-brackets@:}
|
|
@r{ @: V ] @:ROCP @: 50 @:calc-matrix-brackets@:}
|
|
@r{ @: V , @: @: 50 @:calc-vector-commas@:}
|
|
@r{ @: V < @: @: 50 @:calc-matrix-left-justify@:}
|
|
@r{ @: V = @: @: 50 @:calc-matrix-center-justify@:}
|
|
@r{ @: V > @: @: 50 @:calc-matrix-right-justify@:}
|
|
@r{ @: V / @: @: 12,50 @:calc-break-vectors@:}
|
|
@r{ @: V . @: @: 12,50 @:calc-full-vectors@:}
|
|
|
|
@c
|
|
@r{ s t@: V ^ @: @: 2 @:vint@:(s,t)}
|
|
@r{ s t@: V - @: @: 2 @:vdiff@:(s,t)}
|
|
@r{ s@: V ~ @: @: 1 @:vcompl@:(s)}
|
|
@r{ s@: V # @: @: 1 @:vcard@:(s)}
|
|
@r{ s@: V : @: @: 1 @:vspan@:(s)}
|
|
@r{ s@: V + @: @: 1 @:rdup@:(s)}
|
|
|
|
@c
|
|
@r{ m@: V & @: @: 1 @:inv@:(m) 1/m}
|
|
|
|
@c
|
|
@r{ v@: v a @:n @: @:arrange@:(v,n)}
|
|
@r{ a@: v b @:n @: @:cvec@:(a,n)}
|
|
@r{ v@: v c @:n >0 @: 21,31 @:mcol@:(v,n)}
|
|
@r{ v@: v c @:n <0 @: 31 @:mrcol@:(v,-n)}
|
|
@r{ m@: v c @:0 @: 31 @:getdiag@:(m)}
|
|
@r{ v@: v d @: @: 25 @:diag@:(v,n)}
|
|
@r{ v m@: v e @: @: 2 @:vexp@:(v,m)}
|
|
@r{ v m f@: H v e @: @: 2 @:vexp@:(v,m,f)}
|
|
@r{ v a@: v f @: @: 26 @:find@:(v,a,n)}
|
|
@r{ v@: v h @: @: 1 @:head@:(v)}
|
|
@r{ v@: I v h @: @: 1 @:tail@:(v)}
|
|
@r{ v@: H v h @: @: 1 @:rhead@:(v)}
|
|
@r{ v@: I H v h @: @: 1 @:rtail@:(v)}
|
|
@r{ @: v i @:n @: 31 @:idn@:(1,n)}
|
|
@r{ @: v i @:0 @: 31 @:idn@:(1)}
|
|
@r{ h t@: v k @: @: 2 @:cons@:(h,t)}
|
|
@r{ h t@: H v k @: @: 2 @:rcons@:(h,t)}
|
|
@r{ v@: v l @: @: 1 @:vlen@:(v)}
|
|
@r{ v@: H v l @: @: 1 @:mdims@:(v)}
|
|
@r{ v m@: v m @: @: 2 @:vmask@:(v,m)}
|
|
@r{ v@: v n @: @: 1 @:rnorm@:(v)}
|
|
@r{ a b c@: v p @: @: 24 @:calc-pack@:}
|
|
@r{ v@: v r @:n >0 @: 21,31 @:mrow@:(v,n)}
|
|
@r{ v@: v r @:n <0 @: 31 @:mrrow@:(v,-n)}
|
|
@r{ m@: v r @:0 @: 31 @:getdiag@:(m)}
|
|
@r{ v i j@: v s @: @: @:subvec@:(v,i,j)}
|
|
@r{ v i j@: I v s @: @: @:rsubvec@:(v,i,j)}
|
|
@r{ m@: v t @: @: 1 @:trn@:(m)}
|
|
@r{ v@: v u @: @: 24 @:calc-unpack@:}
|
|
@r{ v@: v v @: @: 1 @:rev@:(v)}
|
|
@r{ @: v x @:n @: 31 @:index@:(n)}
|
|
@r{ n s i@: C-u v x @: @: @:index@:(n,s,i)}
|
|
|
|
@c
|
|
@r{ v@: V A @:op @: 22 @:apply@:(op,v)}
|
|
@r{ v1 v2@: V C @: @: 2 @:cross@:(v1,v2)}
|
|
@r{ m@: V D @: @: 1 @:det@:(m)}
|
|
@r{ s@: V E @: @: 1 @:venum@:(s)}
|
|
@r{ s@: V F @: @: 1 @:vfloor@:(s)}
|
|
@r{ v@: V G @: @: @:grade@:(v)}
|
|
@r{ v@: I V G @: @: @:rgrade@:(v)}
|
|
@r{ v@: V H @:n @: 31 @:histogram@:(v,n)}
|
|
@r{ v w@: H V H @:n @: 31 @:histogram@:(v,w,n)}
|
|
@r{ v1 v2@: V I @:mop aop @: 22 @:inner@:(mop,aop,v1,v2)}
|
|
@r{ m@: V J @: @: 1 @:ctrn@:(m)}
|
|
@r{ m@: V L @: @: 1 @:lud@:(m)}
|
|
@r{ v@: V M @:op @: 22,23 @:map@:(op,v)}
|
|
@r{ v@: V N @: @: 1 @:cnorm@:(v)}
|
|
@r{ v1 v2@: V O @:op @: 22 @:outer@:(op,v1,v2)}
|
|
@r{ v@: V R @:op @: 22,23 @:reduce@:(op,v)}
|
|
@r{ v@: I V R @:op @: 22,23 @:rreduce@:(op,v)}
|
|
@r{ a n@: H V R @:op @: 22 @:nest@:(op,a,n)}
|
|
@r{ a@: I H V R @:op @: 22 @:fixp@:(op,a)}
|
|
@r{ v@: V S @: @: @:sort@:(v)}
|
|
@r{ v@: I V S @: @: @:rsort@:(v)}
|
|
@r{ m@: V T @: @: 1 @:tr@:(m)}
|
|
@r{ v@: V U @:op @: 22 @:accum@:(op,v)}
|
|
@r{ v@: I V U @:op @: 22 @:raccum@:(op,v)}
|
|
@r{ a n@: H V U @:op @: 22 @:anest@:(op,a,n)}
|
|
@r{ a@: I H V U @:op @: 22 @:afixp@:(op,a)}
|
|
@r{ s t@: V V @: @: 2 @:vunion@:(s,t)}
|
|
@r{ s t@: V X @: @: 2 @:vxor@:(s,t)}
|
|
|
|
@c
|
|
@r{ @: Y @: @: @:@:user commands}
|
|
|
|
@c
|
|
@r{ @: z @: @: @:@:user commands}
|
|
|
|
@c
|
|
@r{ c@: Z [ @: @: 45 @:calc-kbd-if@:}
|
|
@r{ c@: Z | @: @: 45 @:calc-kbd-else-if@:}
|
|
@r{ @: Z : @: @: @:calc-kbd-else@:}
|
|
@r{ @: Z ] @: @: @:calc-kbd-end-if@:}
|
|
|
|
@c
|
|
@r{ @: Z @{ @: @: 4 @:calc-kbd-loop@:}
|
|
@r{ c@: Z / @: @: 45 @:calc-kbd-break@:}
|
|
@r{ @: Z @} @: @: @:calc-kbd-end-loop@:}
|
|
@r{ n@: Z < @: @: @:calc-kbd-repeat@:}
|
|
@r{ @: Z > @: @: @:calc-kbd-end-repeat@:}
|
|
@r{ n m@: Z ( @: @: @:calc-kbd-for@:}
|
|
@r{ s@: Z ) @: @: @:calc-kbd-end-for@:}
|
|
|
|
@c
|
|
@r{ @: Z C-g @: @: @:@:cancel if/loop command}
|
|
|
|
@c
|
|
@r{ @: Z ` @: @: @:calc-kbd-push@:}
|
|
@r{ @: Z ' @: @: @:calc-kbd-pop@:}
|
|
@r{ @: Z # @: @: @:calc-kbd-query@:}
|
|
|
|
@c
|
|
@r{ comp@: Z C @:func, args @: 50 @:calc-user-define-composition@:}
|
|
@r{ @: Z D @:key, command @: @:calc-user-define@:}
|
|
@r{ @: Z E @:key, editing @: 30 @:calc-user-define-edit@:}
|
|
@r{ defn@: Z F @:k, c, f, a, n@: 28 @:calc-user-define-formula@:}
|
|
@r{ @: Z G @:key @: @:calc-get-user-defn@:}
|
|
@r{ @: Z I @: @: @:calc-user-define-invocation@:}
|
|
@r{ @: Z K @:key, command @: @:calc-user-define-kbd-macro@:}
|
|
@r{ @: Z P @:key @: @:calc-user-define-permanent@:}
|
|
@r{ @: Z S @: @: 30 @:calc-edit-user-syntax@:}
|
|
@r{ @: Z T @: @: 12 @:calc-timing@:}
|
|
@r{ @: Z U @:key @: @:calc-user-undefine@:}
|
|
|
|
@end format
|
|
|
|
@noindent
|
|
NOTES
|
|
|
|
@enumerate
|
|
@c 1
|
|
@item
|
|
Positive prefix arguments apply to @expr{n} stack entries.
|
|
Negative prefix arguments apply to the @expr{-n}th stack entry.
|
|
A prefix of zero applies to the entire stack. (For @key{LFD} and
|
|
@kbd{M-@key{DEL}}, the meaning of the sign is reversed.)
|
|
|
|
@c 2
|
|
@item
|
|
Positive prefix arguments apply to @expr{n} stack entries.
|
|
Negative prefix arguments apply to the top stack entry
|
|
and the next @expr{-n} stack entries.
|
|
|
|
@c 3
|
|
@item
|
|
Positive prefix arguments rotate top @expr{n} stack entries by one.
|
|
Negative prefix arguments rotate the entire stack by @expr{-n}.
|
|
A prefix of zero reverses the entire stack.
|
|
|
|
@c 4
|
|
@item
|
|
Prefix argument specifies a repeat count or distance.
|
|
|
|
@c 5
|
|
@item
|
|
Positive prefix arguments specify a precision @expr{p}.
|
|
Negative prefix arguments reduce the current precision by @expr{-p}.
|
|
|
|
@c 6
|
|
@item
|
|
A prefix argument is interpreted as an additional step-size parameter.
|
|
A plain @kbd{C-u} prefix means to prompt for the step size.
|
|
|
|
@c 7
|
|
@item
|
|
A prefix argument specifies simplification level and depth.
|
|
1=Default, 2=like @kbd{a s}, 3=like @kbd{a e}.
|
|
|
|
@c 8
|
|
@item
|
|
A negative prefix operates only on the top level of the input formula.
|
|
|
|
@c 9
|
|
@item
|
|
Positive prefix arguments specify a word size of @expr{w} bits, unsigned.
|
|
Negative prefix arguments specify a word size of @expr{w} bits, signed.
|
|
|
|
@c 10
|
|
@item
|
|
Prefix arguments specify the shift amount @expr{n}. The @expr{w} argument
|
|
cannot be specified in the keyboard version of this command.
|
|
|
|
@c 11
|
|
@item
|
|
From the keyboard, @expr{d} is omitted and defaults to zero.
|
|
|
|
@c 12
|
|
@item
|
|
Mode is toggled; a positive prefix always sets the mode, and a negative
|
|
prefix always clears the mode.
|
|
|
|
@c 13
|
|
@item
|
|
Some prefix argument values provide special variations of the mode.
|
|
|
|
@c 14
|
|
@item
|
|
A prefix argument, if any, is used for @expr{m} instead of taking
|
|
@expr{m} from the stack. @expr{M} may take any of these values:
|
|
@iftex
|
|
{@advance@tableindent10pt
|
|
@end iftex
|
|
@table @asis
|
|
@item Integer
|
|
Random integer in the interval @expr{[0 .. m)}.
|
|
@item Float
|
|
Random floating-point number in the interval @expr{[0 .. m)}.
|
|
@item 0.0
|
|
Gaussian with mean 1 and standard deviation 0.
|
|
@item Error form
|
|
Gaussian with specified mean and standard deviation.
|
|
@item Interval
|
|
Random integer or floating-point number in that interval.
|
|
@item Vector
|
|
Random element from the vector.
|
|
@end table
|
|
@iftex
|
|
}
|
|
@end iftex
|
|
|
|
@c 15
|
|
@item
|
|
A prefix argument from 1 to 6 specifies number of date components
|
|
to remove from the stack. @xref{Date Conversions}.
|
|
|
|
@c 16
|
|
@item
|
|
A prefix argument specifies a time zone; @kbd{C-u} says to take the
|
|
time zone number or name from the top of the stack. @xref{Time Zones}.
|
|
|
|
@c 17
|
|
@item
|
|
A prefix argument specifies a day number (0-6, 0-31, or 0-366).
|
|
|
|
@c 18
|
|
@item
|
|
If the input has no units, you will be prompted for both the old and
|
|
the new units.
|
|
|
|
@c 19
|
|
@item
|
|
With a prefix argument, collect that many stack entries to form the
|
|
input data set. Each entry may be a single value or a vector of values.
|
|
|
|
@c 20
|
|
@item
|
|
With a prefix argument of 1, take a single
|
|
@texline @var{n}@math{\times2}
|
|
@infoline @mathit{@var{N}x2}
|
|
matrix from the stack instead of two separate data vectors.
|
|
|
|
@c 21
|
|
@item
|
|
The row or column number @expr{n} may be given as a numeric prefix
|
|
argument instead. A plain @kbd{C-u} prefix says to take @expr{n}
|
|
from the top of the stack. If @expr{n} is a vector or interval,
|
|
a subvector/submatrix of the input is created.
|
|
|
|
@c 22
|
|
@item
|
|
The @expr{op} prompt can be answered with the key sequence for the
|
|
desired function, or with @kbd{x} or @kbd{z} followed by a function name,
|
|
or with @kbd{$} to take a formula from the top of the stack, or with
|
|
@kbd{'} and a typed formula. In the last two cases, the formula may
|
|
be a nameless function like @samp{<#1+#2>} or @samp{<x, y : x+y>}, or it
|
|
may include @kbd{$}, @kbd{$$}, etc. (where @kbd{$} will correspond to the
|
|
last argument of the created function), or otherwise you will be
|
|
prompted for an argument list. The number of vectors popped from the
|
|
stack by @kbd{V M} depends on the number of arguments of the function.
|
|
|
|
@c 23
|
|
@item
|
|
One of the mapping direction keys @kbd{_} (horizontal, i.e., map
|
|
by rows or reduce across), @kbd{:} (vertical, i.e., map by columns or
|
|
reduce down), or @kbd{=} (map or reduce by rows) may be used before
|
|
entering @expr{op}; these modify the function name by adding the letter
|
|
@code{r} for ``rows,'' @code{c} for ``columns,'' @code{a} for ``across,''
|
|
or @code{d} for ``down.''
|
|
|
|
@c 24
|
|
@item
|
|
The prefix argument specifies a packing mode. A nonnegative mode
|
|
is the number of items (for @kbd{v p}) or the number of levels
|
|
(for @kbd{v u}). A negative mode is as described below. With no
|
|
prefix argument, the mode is taken from the top of the stack and
|
|
may be an integer or a vector of integers.
|
|
@iftex
|
|
{@advance@tableindent-20pt
|
|
@end iftex
|
|
@table @cite
|
|
@item -1
|
|
(@var{2}) Rectangular complex number.
|
|
@item -2
|
|
(@var{2}) Polar complex number.
|
|
@item -3
|
|
(@var{3}) HMS form.
|
|
@item -4
|
|
(@var{2}) Error form.
|
|
@item -5
|
|
(@var{2}) Modulo form.
|
|
@item -6
|
|
(@var{2}) Closed interval.
|
|
@item -7
|
|
(@var{2}) Closed .. open interval.
|
|
@item -8
|
|
(@var{2}) Open .. closed interval.
|
|
@item -9
|
|
(@var{2}) Open interval.
|
|
@item -10
|
|
(@var{2}) Fraction.
|
|
@item -11
|
|
(@var{2}) Float with integer mantissa.
|
|
@item -12
|
|
(@var{2}) Float with mantissa in @expr{[1 .. 10)}.
|
|
@item -13
|
|
(@var{1}) Date form (using date numbers).
|
|
@item -14
|
|
(@var{3}) Date form (using year, month, day).
|
|
@item -15
|
|
(@var{6}) Date form (using year, month, day, hour, minute, second).
|
|
@end table
|
|
@iftex
|
|
}
|
|
@end iftex
|
|
|
|
@c 25
|
|
@item
|
|
A prefix argument specifies the size @expr{n} of the matrix. With no
|
|
prefix argument, @expr{n} is omitted and the size is inferred from
|
|
the input vector.
|
|
|
|
@c 26
|
|
@item
|
|
The prefix argument specifies the starting position @expr{n} (default 1).
|
|
|
|
@c 27
|
|
@item
|
|
Cursor position within stack buffer affects this command.
|
|
|
|
@c 28
|
|
@item
|
|
Arguments are not actually removed from the stack by this command.
|
|
|
|
@c 29
|
|
@item
|
|
Variable name may be a single digit or a full name.
|
|
|
|
@c 30
|
|
@item
|
|
Editing occurs in a separate buffer. Press @kbd{C-c C-c} (or
|
|
@key{LFD}, or in some cases @key{RET}) to finish the edit, or kill the
|
|
buffer with @kbd{C-x k} to cancel the edit. The @key{LFD} key prevents evaluation
|
|
of the result of the edit.
|
|
|
|
@c 31
|
|
@item
|
|
The number prompted for can also be provided as a prefix argument.
|
|
|
|
@c 32
|
|
@item
|
|
Press this key a second time to cancel the prefix.
|
|
|
|
@c 33
|
|
@item
|
|
With a negative prefix, deactivate all formulas. With a positive
|
|
prefix, deactivate and then reactivate from scratch.
|
|
|
|
@c 34
|
|
@item
|
|
Default is to scan for nearest formula delimiter symbols. With a
|
|
prefix of zero, formula is delimited by mark and point. With a
|
|
non-zero prefix, formula is delimited by scanning forward or
|
|
backward by that many lines.
|
|
|
|
@c 35
|
|
@item
|
|
Parse the region between point and mark as a vector. A nonzero prefix
|
|
parses @var{n} lines before or after point as a vector. A zero prefix
|
|
parses the current line as a vector. A @kbd{C-u} prefix parses the
|
|
region between point and mark as a single formula.
|
|
|
|
@c 36
|
|
@item
|
|
Parse the rectangle defined by point and mark as a matrix. A positive
|
|
prefix @var{n} divides the rectangle into columns of width @var{n}.
|
|
A zero or @kbd{C-u} prefix parses each line as one formula. A negative
|
|
prefix suppresses special treatment of bracketed portions of a line.
|
|
|
|
@c 37
|
|
@item
|
|
A numeric prefix causes the current language mode to be ignored.
|
|
|
|
@c 38
|
|
@item
|
|
Responding to a prompt with a blank line answers that and all
|
|
later prompts by popping additional stack entries.
|
|
|
|
@c 39
|
|
@item
|
|
Answer for @expr{v} may also be of the form @expr{v = v_0} or
|
|
@expr{v - v_0}.
|
|
|
|
@c 40
|
|
@item
|
|
With a positive prefix argument, stack contains many @expr{y}'s and one
|
|
common @expr{x}. With a zero prefix, stack contains a vector of
|
|
@expr{y}s and a common @expr{x}. With a negative prefix, stack
|
|
contains many @expr{[x,y]} vectors. (For 3D plots, substitute
|
|
@expr{z} for @expr{y} and @expr{x,y} for @expr{x}.)
|
|
|
|
@c 41
|
|
@item
|
|
With any prefix argument, all curves in the graph are deleted.
|
|
|
|
@c 42
|
|
@item
|
|
With a positive prefix, refines an existing plot with more data points.
|
|
With a negative prefix, forces recomputation of the plot data.
|
|
|
|
@c 43
|
|
@item
|
|
With any prefix argument, set the default value instead of the
|
|
value for this graph.
|
|
|
|
@c 44
|
|
@item
|
|
With a negative prefix argument, set the value for the printer.
|
|
|
|
@c 45
|
|
@item
|
|
Condition is considered ``true'' if it is a nonzero real or complex
|
|
number, or a formula whose value is known to be nonzero; it is ``false''
|
|
otherwise.
|
|
|
|
@c 46
|
|
@item
|
|
Several formulas separated by commas are pushed as multiple stack
|
|
entries. Trailing @kbd{)}, @kbd{]}, @kbd{@}}, @kbd{>}, and @kbd{"}
|
|
delimiters may be omitted. The notation @kbd{$$$} refers to the value
|
|
in stack level three, and causes the formula to replace the top three
|
|
stack levels. The notation @kbd{$3} refers to stack level three without
|
|
causing that value to be removed from the stack. Use @key{LFD} in place
|
|
of @key{RET} to prevent evaluation; use @kbd{M-=} in place of @key{RET}
|
|
to evaluate variables.
|
|
|
|
@c 47
|
|
@item
|
|
The variable is replaced by the formula shown on the right. The
|
|
Inverse flag reverses the order of the operands, e.g., @kbd{I s - x}
|
|
assigns
|
|
@texline @math{x \coloneq a-x}.
|
|
@infoline @expr{x := a-x}.
|
|
|
|
@c 48
|
|
@item
|
|
Press @kbd{?} repeatedly to see how to choose a model. Answer the
|
|
variables prompt with @expr{iv} or @expr{iv;pv} to specify
|
|
independent and parameter variables. A positive prefix argument
|
|
takes @mathit{@var{n}+1} vectors from the stack; a zero prefix takes a matrix
|
|
and a vector from the stack.
|
|
|
|
@c 49
|
|
@item
|
|
With a plain @kbd{C-u} prefix, replace the current region of the
|
|
destination buffer with the yanked text instead of inserting.
|
|
|
|
@c 50
|
|
@item
|
|
All stack entries are reformatted; the @kbd{H} prefix inhibits this.
|
|
The @kbd{I} prefix sets the mode temporarily, redraws the top stack
|
|
entry, then restores the original setting of the mode.
|
|
|
|
@c 51
|
|
@item
|
|
A negative prefix sets the default 3D resolution instead of the
|
|
default 2D resolution.
|
|
|
|
@c 52
|
|
@item
|
|
This grabs a vector of the form [@var{prec}, @var{wsize}, @var{ssize},
|
|
@var{radix}, @var{flfmt}, @var{ang}, @var{frac}, @var{symb}, @var{polar},
|
|
@var{matrix}, @var{simp}, @var{inf}]. A prefix argument from 1 to 12
|
|
grabs the @var{n}th mode value only.
|
|
@end enumerate
|
|
|
|
@iftex
|
|
(Space is provided below for you to keep your own written notes.)
|
|
@page
|
|
@endgroup
|
|
@end iftex
|
|
|
|
|
|
@c [end-summary]
|
|
|
|
@node Key Index, Command Index, Summary, Top
|
|
@unnumbered Index of Key Sequences
|
|
|
|
@printindex ky
|
|
|
|
@node Command Index, Function Index, Key Index, Top
|
|
@unnumbered Index of Calculator Commands
|
|
|
|
Since all Calculator commands begin with the prefix @samp{calc-}, the
|
|
@kbd{x} key has been provided as a variant of @kbd{M-x} which automatically
|
|
types @samp{calc-} for you. Thus, @kbd{x last-args} is short for
|
|
@kbd{M-x calc-last-args}.
|
|
|
|
@printindex pg
|
|
|
|
@node Function Index, Concept Index, Command Index, Top
|
|
@unnumbered Index of Algebraic Functions
|
|
|
|
This is a list of built-in functions and operators usable in algebraic
|
|
expressions. Their full Lisp names are derived by adding the prefix
|
|
@samp{calcFunc-}, as in @code{calcFunc-sqrt}.
|
|
@iftex
|
|
All functions except those noted with ``*'' have corresponding
|
|
Calc keystrokes and can also be found in the Calc Summary.
|
|
@end iftex
|
|
|
|
@printindex tp
|
|
|
|
@node Concept Index, Variable Index, Function Index, Top
|
|
@unnumbered Concept Index
|
|
|
|
@printindex cp
|
|
|
|
@node Variable Index, Lisp Function Index, Concept Index, Top
|
|
@unnumbered Index of Variables
|
|
|
|
The variables in this list that do not contain dashes are accessible
|
|
as Calc variables. Add a @samp{var-} prefix to get the name of the
|
|
corresponding Lisp variable.
|
|
|
|
The remaining variables are Lisp variables suitable for @code{setq}ing
|
|
in your Calc init file or @file{.emacs} file.
|
|
|
|
@printindex vr
|
|
|
|
@node Lisp Function Index, , Variable Index, Top
|
|
@unnumbered Index of Lisp Math Functions
|
|
|
|
The following functions are meant to be used with @code{defmath}, not
|
|
@code{defun} definitions. For names that do not start with @samp{calc-},
|
|
the corresponding full Lisp name is derived by adding a prefix of
|
|
@samp{math-}.
|
|
|
|
@printindex fn
|
|
|
|
@summarycontents
|
|
|
|
@c [end]
|
|
|
|
@contents
|
|
@bye
|
|
|
|
|
|
@ignore
|
|
arch-tag: 77a71809-fa4d-40be-b2cc-da3e8fb137c0
|
|
@end ignore
|