Info file calc.info, produced by Makeinfo, -*- Text -*- from input
file calc.texinfo.

   This file documents Calc, the GNU Emacs calculator.

   Copyright (C) 1990, 1991 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for
modified versions, except that the section entitled "GNU General
Public License" may be included in a translation approved by the
author instead of in the original English.


File: calc.info,  Node: Concept Index,  Next: Variable Index,  Prev: Function Index,  Up: Top

Concept Index
*************

* Menu:

* AlgSimpRules variable:                Automatic Rewrites.
* Decls variable:                       Declaration Basics.
* EvalRules variable:                   Automatic Rewrites.
* ExtSimpRules variable:                Automatic Rewrites.
* GenCount variable:                    Multiple Solutions.
* Holidays variable:                    Business Days.
* LineStyles variable:                  Graphics Options.
* Modes variable:                       Modes Variable.
* PlotRejects variable:                 Basic Graphics.
* PointStyles variable:                 Graphics Options.
* TimeZone variable:                    Time Zones.
* UnitSimpRules variable:               Automatic Rewrites.
* Units variable:                       User-Defined Units.
* e variable:                           Scientific Functions.
* e variable:                           Variables.
* gamma variable:                       Scientific Functions.
* gamma variable:                       Variables.
* inf variable:                         Infinities.
* i variable:                           Complex Formats.
* i variable:                           Variables.
* max-lisp-eval-depth:                  Recursion Depth.
* max-specpdl-size:                     Recursion Depth.
* nan variable:                         Infinities.
* phi variable:                         Variables.
* phi variable:                         Scientific Functions.
* pi variable:                          Scientific Functions.
* pi variable:                          Variables.
* uinf variable:                        Infinities.
* .emacs file, mode settings:           General Mode Commands.
* .emacs file, user-defined commands:   Creating User Keys.
* .emacs file, user-defined units:      User-Defined Units.
* .emacs file, veriables:               Operations on Variables.
* calc-ext module:                      Basic Commands.
* => operator:                          Evaluates-To Operator.
* Accuracy of calculations:             Floats.
* Accuracy of calculations:             Precision.
* Algebraic mode:                       Algebraic Entry.
* Algebraic notation:                   Algebraic Entry.
* Algebraic simplifications:            Algebraic Simplifications.
* Alternating sums:                     Summations.
* Angle and slope of a line:            Types Tutorial.
* Angular mode:                         Angular Modes.
* Area under a curve:                   Basic Algebra Tutorial.
* Arguments, not evaluated:             Logical Operations.
* Arguments, restoring:                 Undo.
* Arranging a matrix:                   Manipulating Vectors.
* Beatles:                              Types Tutorial.
* Bernoulli numbers, approximate:       Programming Tutorial.
* Bibliography:                         History and Acknowledgements.
* Binary numbers:                       Binary Functions.
* Binary operators:                     Arithmetic Tutorial.
* Branch cuts:                          Branch Cuts.
* Breaking up long lines:               Normal Language Modes.
* C language:                           C FORTRAN Pascal.
* Caches:                               Caches.
* Character strings:                    Strings.
* Clearing the stack:                   RPN Tutorial.
* Coefficients of polynomial:           Decomposing Polynomials.
* Columns of data, extracting:          List Tutorial.
* Common logarithm:                     Arithmetic Tutorial.
* Complex numbers:                      Complex Numbers.
* Composite units:                      Basic Operations on Units.
* Compositions:                         Compositions.
* Conditional structures:               Conditionals in Macros.
* Continued fractions:                  Programming Tutorial.
* Continuous memory:                    General Mode Commands.
* Correlation coefficient:              Paired-Sample Statistics.
* Covariance:                           Paired-Sample Statistics.
* Cross product:                        Vector Analysis Tutorial.
* Data, extracting from buffers:        List Tutorial.
* Date arithmetic, additional functions: Date Arithmetic.
* Date forms:                           Date Forms.
* Daylight savings time:                Time Zones.
* Decimal and non-decimal numbers:      Radix Modes.
* Declaring scalar variables:           Matrix Mode.
* Default simplifications:              Default Simplifications.
* Degree of polynomial:                 Decomposing Polynomials.
* Degrees-minutes-seconds forms:        HMS Forms.
* Deleting stack entries:               Stack Manipulation.
* Demonstration of Calc:                Demonstration of Calc.
* Digamma function:                     Programming Tutorial.
* Digit grouping:                       Grouping Digits.
* Digits, vectors of:                   List Tutorial.
* Division of integers:                 Fraction Mode.
* Divisor functions:                    List Tutorial.
* Dot product:                          Vector Analysis Tutorial.
* Duplicate values in a list:           List Tutorial.
* Duplicating a stack entry:            RPN Tutorial.
* Duplicating stack entries:            Stack Manipulation.
* Editing the stack with Emacs:         Editing Stack Entries.
* Editing user definitions:             Creating User Keys.
* Emptying the stack:                   RPN Tutorial.
* Engineering notation, display of:     Float Formats.
* Entering numbers:                     Numeric Entry.
* Equations, solving:                   Solving Equations.
* Error forms:                          Error Forms.
* Errors, messages:                     Error Messages.
* Errors, undoing:                      Undo.
* Euler's gamma constant:               Scientific Functions.
* Euler's gamma constant:               Programming Tutorial.
* Evaluates-to operator:                Evaluates-To Operator.
* Evaluation of variables in a formula: Variables.
* Exchanging stack entries:             RPN Tutorial.
* Exiting the Calculator:               Basic Commands.
* Exponential integral Ei(x):           Customizing the Integrator.
* Expressions:                          Formulas.
* Extended simplification:              Unsafe Simplifications.
* Extensions module:                    Basic Commands.
* FORTRAN language:                     C FORTRAN Pascal.
* Fermat, primality test of:            Types Tutorial.
* Fibonacci numbers:                    Programming Tutorial.
* Fibonacci numbers:                    Rewrites Tutorial.
* Fitting data to a line:               List Tutorial.
* Fixed points:                         Nesting and Fixed Points.
* Flattening a matrix:                  Manipulating Vectors.
* Floating-point numbers:               Floats.
* Floats vs. fractions:                 Modes Tutorial.
* Flushing caches:                      Caches.
* Formulas:                             Formulas.
* Formulas, entering:                   Algebraic Entry.
* Formulas, evaluation:                 Variables.
* Formulas, referring to stack:         Algebraic Entry.
* Fraction mode:                        Fraction Mode.
* Fractional part of a number:          Integer Truncation.
* Fractions:                            Fractions.
* Fractions vs. floats:                 Modes Tutorial.
* Function call notation:               Formulas.
* Gamma constant, Euler's:              Scientific Functions.
* Gamma constant, Euler's:              Programming Tutorial.
* Garbled displays, refreshing:         Basic Commands.
* Generic functions:                    Specifying Operators.
* Geometric mean:                       Single-Variable Statistics.
* Geometric mean:                       List Tutorial.
* Golden ratio:                         Programming Tutorial.
* Golden ratio:                         Scientific Functions.
* Gregorian calendar:                   Date Forms.
* Grouping digits:                      Grouping Digits.
* Guard digits:                         Modes Tutorial.
* Guard digits:                         Modes Tutorial.
* Harmonic mean:                        Single-Variable Statistics.
* Harmonic numbers:                     Programming Tutorial.
* Hash tables:                          Arithmetic Tutorial.
* Help commands:                        Help Commands.
* Hexadecimal integers:                 Radix Modes.
* Histograms:                           Manipulating Vectors.
* Horizontal scrolling:                 Basic Commands.
* Hours-minutes-seconds forms:          HMS Forms.
* Identity matrix:                      Matrix Tutorial.
* Implicit comma in vectors:            Formulas.
* Implicit multiplication:              Formulas.
* Incomplete algebraic mode:            Algebraic Entry.
* Incomplete complex numbers:           Incomplete Objects.
* Incomplete interval forms:            Incomplete Objects.
* Incomplete vectors:                   Incomplete Objects.
* Index tables:                         Manipulating Vectors.
* Inexact results:                      Symbolic Mode.
* Infinite mode:                        Infinite Mode.
* Infinity:                             Infinities.
* Integer part of a number:             Integer Truncation.
* Integers:                             Integers.
* Integration by Simpson's rule:        Basic Algebra Tutorial.
* Integration, numerical:               Basic Algebra Tutorial.
* Interval forms:                       Interval Forms.
* Inverse of permutation:               Manipulating Vectors.
* Iterative structures:                 Loops in Macros.
* Julian calendar:                      Date Forms.
* Julian day counting:                  Date Forms.
* Julian day counts, conversions:       Date Conversions.
* Keyboard macros:                      Keyboard Macros.
* Keyboard macros, editing:             Naming Keyboard Macros.
* Kill ring:                            Killing From Stack.
* Knuth, Art of Computer Programming:   History and Acknowledgements.
* Lambda expressions:                   Specifying Operators.
* Large numbers, readability:           Modes Tutorial.
* Last-arguments feature:               Undo.
* Leading zeros:                        Radix Modes.
* Least-squares fits:                   Linear Fits.
* Least-squares for fitting a straight line: List Tutorial.
* Least-squares for over-determined systems: Matrix Tutorial.
* Levels of stack:                      RPN Tutorial.
* Line breaking:                        Normal Language Modes.
* Line, fitting data to:                List Tutorial.
* Linear correlation:                   Paired-Sample Statistics.
* Linear equations, systems of:         Matrix Tutorial.
* Linear regression:                    Linear Fits.
* Linearity testing:                    Logical Operations.
* Lists:                                List Tutorial.
* Local variables:                      Local Values in Macros.
* Looping structures:                   Loops in Macros.
* META key:                             Starting Calc.
* Maple language:                       Maple Language Mode.
* Marginal notes:                       About This Manual.
* Marginal notes, adjusting:            Installation.
* Matchstick problem:                   List Tutorial.
* Mathematica language:                 Mathematica Language Mode.
* Matrices:                             Vectors and Matrices.
* Matrix display:                       Normal Language Modes.
* Matrix mode:                          Matrix Mode.
* Maximizing a function over a list of values: List Tutorial.
* Maximum of a function using Calculus: Basic Algebra Tutorial.
* Mean of data values:                  Single-Variable Statistics.
* Median of data values:                Single-Variable Statistics.
* Minimization, numerical:              Minimization.
* Minus signs:                          Numeric Entry.
* Mistakes, undoing:                    Undo.
* Mode line indicators:                 Calc Mode Line.
* Modulo division:                      Modulo Forms.
* Modulo forms:                         Modulo Forms.
* Multiplication, implicit:             Formulas.
* Nameless functions:                   Specifying Operators.
* Narrowing the stack:                  Truncating the Stack.
* Negative numbers, entering:           Numeric Entry.
* Newton's method:                      Root Finding.
* Non-decimal numbers:                  Radix Modes.
* Normalizing a vector:                 Vector Analysis Tutorial.
* Numerator of a fraction, extracting:  Packing and Unpacking.
* Numeric entry:                        Numeric Entry.
* Numerical Recipes:                    History and Acknowledgements.
* Numerical integration:                Basic Algebra Tutorial.
* Numerical root-finding:               Root Finding.
* Octal integers:                       Radix Modes.
* Operands:                             RPN Tutorial.
* Operators:                            RPN Tutorial.
* Operators in formulas:                Formulas.
* Over-determined systems of equations: Matrix Tutorial.
* Parsing formulas, customized:         Syntax Tables.
* Parts of formulas:                    Selecting Subformulas.
* Pascal language:                      C FORTRAN Pascal.
* Pattern matching:                     Rewrite Rules.
* Performance:                          Working Message.
* Permanent mode settings:              General Mode Commands.
* Permanent user definitions:           Creating User Keys.
* Permanent variables:                  Operations on Variables.
* Permutation, inverse of:              Manipulating Vectors.
* Permutations, applying:               Extracting Elements.
* Perpendicular vectors:                Vector Analysis Tutorial.
* Phi, golden ratio:                    Programming Tutorial.
* Phi, golden ratio:                    Scientific Functions.
* Plain vectors:                        Vectors and Matrices.
* Polar mode:                           Polar Mode.
* Polynomial, list of coefficients:     Programming Tutorial.
* Population statistics:                Single-Variable Statistics.
* Positive infinite mode:               Infinite Mode.
* Precedence of operators:              Formulas.
* Precision of calculations:            Precision.
* Primes:                               Combinatorial Functions.
* Principal values:                     Branch Cuts.
* Product of a sequence:                Summations.
* Programming with algebraic formulas:  Algebraic Definitions.
* Programming with keyboard macros:     Keyboard Macros.
* Pythagorean Theorem:                  RPN Tutorial.
* Quaternions:                          Examples of Rewrite Rules.
* Quick Calculator:                     Quick Calculator.
* Quick units:                          User-Defined Units.
* Quick variables:                      Storing Variables.
* Quitting the Calculator:              Basic Commands.
* RPN notation:                         RPN Tutorial.
* Radix display:                        Radix Modes.
* Rank tables:                          Manipulating Vectors.
* Recalling variables:                  Recalling Variables.
* Reciprocal:                           Basic Arithmetic.
* Recursion:                            Programming Tutorial.
* Recursion depth:                      Recursion Depth.
* Redoing after an Undo:                Undo.
* Refreshing a garbled display:         Basic Commands.
* Removing stack entries:               Stack Manipulation.
* Reshaping a matrix:                   Manipulating Vectors.
* Restoring saved modes:                Local Values in Macros.
* Retrieving previous results:          Trail Commands.
* Rewrite rules:                        Rewrite Rules.
* Root-mean-square:                     Single-Variable Statistics.
* Roots of equations:                   Root Finding.
* Round-off errors:                     Modes Tutorial.
* Roundoff errors, correcting:          Conversions.
* Roundoff errors, examples:            Modes Tutorial.
* Roundoff errors, examples:            Arithmetic Tutorial.
* Roundoff errors, in non-decimal numbers: Modes Tutorial.
* Running the Calculator:               Basic Commands.
* Sample statistics:                    Single-Variable Statistics.
* Saving mode settings:                 General Mode Commands.
* Scalar mode:                          Matrix Mode.
* Scientific notation, display of:      Float Formats.
* Scientific notation, entry of:        Modes Tutorial.
* Scientific notation, in non-decimal numbers: Modes Tutorial.
* Scrolling:                            Basic Commands.
* Selections:                           Selecting Subformulas.
* Sets, as binary numbers:              Set Operations.
* Sets, as vectors:                     Set Operations.
* Simpson's rule:                       Basic Algebra Tutorial.
* Sine integral Si(x):                  Programming Tutorial.
* Slope and angle of a line:            Types Tutorial.
* Solving equations:                    Solving Equations.
* Sorting data:                         Manipulating Vectors.
* Speed of light:                       Types Tutorial.
* Square-free numbers:                  List Tutorial.
* Stack basics:                         Stack Basics.
* Stack levels:                         RPN Tutorial.
* Standalone Operation:                 Standalone Operation.
* Standard deviation:                   Single-Variable Statistics.
* Standard deviations:                  Error Forms.
* Standard user interface:              The Standard Interface.
* Starting the Calculator:              Basic Commands.
* Statistical functions:                Statistical Operations.
* Storing user definitions:             Creating User Keys.
* Storing variables:                    Operations on Variables.
* Storing variables:                    Storing Variables.
* Strings:                              Strings.
* Sub-formulas:                         Selecting Subformulas.
* Subscript notation:                   Extracting Elements.
* Summation of a series:                Summations.
* Summations (by keyboard macros):      Loops in Macros.
* Summations (statistical):             Single-Variable Statistics.
* Summing rows and columns of data:     Grabbing From Buffers.
* Symbolic mode:                        Symbolic Mode.
* Syntax tables:                        Syntax Tables.
* Systems of equations, numerical:      Numerical Systems of Equations.
* Systems of equations, symbolic:       Solving Systems of Equations.
* Systems of linear equations:          Matrix Tutorial.
* TeX language:                         TeX Language Mode.
* Temperature conversion:               Basic Operations on Units.
* Temporary assignment to variables:    Let Command.
* Time Zones, converting between:       Date Conversions.
* Time of day:                          HMS Forms.
* Time travel:                          Undo Tutorial.
* Time zones:                           Time Zones.
* Torus, volume of:                     Types Tutorial.
* Total algebraic mode:                 Algebraic Entry.
* Trail buffer:                         Trail Commands.
* Trail pointer:                        Trail Commands.
* Transformations:                      Rewrite Rules.
* Triangular lists:                     List Tutorial.
* Truncating the stack:                 Truncating the Stack.
* Un-storing variables:                 Storing Variables.
* Unary operators:                      Arithmetic Tutorial.
* Undoing mistakes:                     Undo.
* Unit vectors:                         Vector Analysis Tutorial.
* Unix time format:                     Date Forms.
* Unix time format, conversions:        Date Conversions.
* Unsafe simplifications:               Unsafe Simplifications.
* User-defined units:                   User-Defined Units.
* Variables, evaluation:                Variables.
* Variables, in formulas:               Variables.
* Variables, temporary assignment:      Let Command.
* Variance of data values:              Single-Variable Statistics.
* Vectors:                              Vectors and Matrices.
* Vertical scrolling:                   Basic Commands.
* Void variables:                       Storing Variables.
* Why did an error occur?:              Error Messages.
* Wide text, scrolling:                 Basic Commands.
* Word size for binary operations:      Binary Functions.
* Working messages:                     Working Message.
* "Computation got stuck" message:      Recursion Depth.


File: calc.info,  Node: Variable Index,  Next: Lisp Function Index,  Prev: Concept Index,  Up: Top

Index of Variables
******************

   The variables in this list that do not contain dashes are
accessible as Calc variables.  Add a `var-' prefix to get the name
of
the corresponding Lisp variable.

   The remaining variables are Lisp variables suitable for `setq'ing
in your `.emacs' file.

* Menu:

* AlgSimpRules:                         Automatic Rewrites.
* All:                                  Declaration Basics.
* CommuteRules:                         Rearranging with Selections.
* Decls:                                Declaration Basics.
* DistribRules:                         Rearranging with Selections.
* EvalRules:                            Automatic Rewrites.
* ExtSimpRules:                         Automatic Rewrites.
* FactorRules:                          Polynomials.
* FitRules:                             Curve Fitting Details.
* GenCount:                             Multiple Solutions.
* Holidays:                             Business Days.
* IntegAfterRules:                      Customizing the Integrator.
* IntegLimit:                           Integration.
* IntegRules:                           Customizing the Integrator.
* IntegSimpRules:                       Customizing the Integrator.
* InvertRules:                          Rearranging with Selections.
* JumpRules:                            Rearranging with Selections.
* LineStyles:                           Graphics Options.
* MergeRules:                           Rearranging with Selections.
* Model1:                               Standard Nonlinear Models.
* Model2:                               Standard Nonlinear Models.
* Modes:                                Modes Variable.
* NegateRules:                          Rearranging with Selections.
* PlotData1:                            Managing Curves.
* PlotData2:                            Managing Curves.
* PlotRejects:                          Basic Graphics.
* PointStyles:                          Graphics Options.
* RandSeed:                             Random Numbers.
* TimeZone:                             Time Zones.
* UnitSimpRules:                        Automatic Rewrites.
* Units:                                User-Defined Units.
* all:                                  Multi-Phase Rewrite Rules.
* calc-Y-help-msgs:                     Defining Simple Commands.
* calc-alg-ent-map:                     Hooks.
* calc-autoload-directory:              Installation.
* calc-define:                          Defining Functions.
* calc-digit-map:                       Hooks.
* calc-edit-mode-hook:                  Hooks.
* calc-edit-mode-map:                   Hooks.
* calc-embedded-announce-formula:       Customizing Embedded Mode.
* calc-embedded-close-formula:          Customizing Embedded Mode.
* calc-embedded-close-mode:             Customizing Embedded Mode.
* calc-embedded-close-new-formula:      Customizing Embedded Mode.
* calc-embedded-close-plain:            Customizing Embedded Mode.
* calc-embedded-close-word:             Customizing Embedded Mode.
* calc-embedded-open-formula:           Customizing Embedded Mode.
* calc-embedded-open-mode:              Customizing Embedded Mode.
* calc-embedded-open-new-formula:       Customizing Embedded Mode.
* calc-embedded-open-plain:             Customizing Embedded Mode.
* calc-embedded-open-word:              Customizing Embedded Mode.
* calc-end-hook:                        Hooks.
* calc-ext-load-hook:                   Hooks.
* calc-gnuplot-default-device:          Devices.
* calc-gnuplot-default-output:          Devices.
* calc-gnuplot-name:                    Graphics.
* calc-gnuplot-plot-command:            Devices.
* calc-gnuplot-print-command:           Devices.
* calc-gnuplot-print-device:            Devices.
* calc-gnuplot-print-output:            Devices.
* calc-info-filename:                   Installation.
* calc-load-hook:                       Hooks.
* calc-local-var-list:                  Hooks.
* calc-mode-hook:                       Hooks.
* calc-mode-map:                        Hooks.
* calc-mode-save-hook:                  Hooks.
* calc-mode-var-list:                   Hooks.
* calc-other-modes:                     Hooks.
* calc-reset-hook:                      Hooks.
* calc-scan-for-dels:                   Installation.
* calc-settings-file:                   Installation.
* calc-start-hook:                      Hooks.
* calc-store-var-map:                   Hooks.
* calc-trail-mode-hook:                 Hooks.
* calc-trail-window-hook:               Hooks.
* calc-window-hook:                     Hooks.
* e:                                    Variables.
* e:                                    Scientific Functions.
* gamma:                                Variables.
* gamma:                                Scientific Functions.
* i:                                    Complex Formats.
* i:                                    Variables.
* inf:                                  Infinities.
* load-path:                            Installation.
* math-daylight-savings-hook:           Time Zones.
* math-tzone-names:                     Time Zones.
* nan:                                  Infinities.
* phi:                                  Variables.
* pi:                                   Scientific Functions.
* pi:                                   Variables.
* q0:                                   Storing Variables.
* q9:                                   Storing Variables.
* remember:                             Other Features of Rewrite Rules.
* uinf:                                 Infinities.


File: calc.info,  Node: Lisp Function Index,  Prev: Variable Index,  Up: Top

Index of Lisp Math Functions
****************************

   The following functions are meant to be used with `defmath', not
`defun' definitions.  For names that do not start with `calc-', the
corresponding full Lisp name is derived by adding a prefix of `math-'.

* Menu:

* abs-approx:                           Computational Lisp Functions.
* anglep:                               Predicates.
* apply-rewrites:                       Symbolic Lisp Functions.
* beforep:                              Predicates.
* build-polynomial-expr:                Symbolic Lisp Functions.
* build-vector:                         Vector Lisp Functions.
* calc-binary-op:                       Stack Lisp Functions.
* calc-change-current-selection:        Symbolic Lisp Functions.
* calc-check-defines:                   Defining Functions.
* calc-clear-command-flag:              Interactive Lisp Functions.
* calc-cursor-stack-index:              Stack Lisp Functions.
* calc-do-alg-entry:                    Formatting Lisp Functions.
* calc-encase-atoms:                    Symbolic Lisp Functions.
* calc-enter-result:                    Defining Stack Commands.
* calc-enter-result:                    Stack Lisp Functions.
* calc-eval:                            Formatting Lisp Functions.
* calc-find-assoc-parent-formula:       Symbolic Lisp Functions.
* calc-find-nth-part:                   Symbolic Lisp Functions.
* calc-find-parent-formula:             Symbolic Lisp Functions.
* calc-find-selected-part:              Symbolic Lisp Functions.
* calc-find-sub-formula:                Symbolic Lisp Functions.
* calc-grow-assoc-formula:              Symbolic Lisp Functions.
* calc-is-hyperbolic:                   Interactive Lisp Functions.
* calc-is-inverse:                      Interactive Lisp Functions.
* calc-normalize:                       Stack Lisp Functions.
* calc-pop-stack:                       Stack Lisp Functions.
* calc-prepare-selection:               Symbolic Lisp Functions.
* calc-push-list:                       Stack Lisp Functions.
* calc-record-list:                     Stack Lisp Functions.
* calc-record-undo:                     Interactive Lisp Functions.
* calc-record-why:                      Interactive Lisp Functions.
* calc-refresh:                         Stack Lisp Functions.
* calc-replace-sub-formula:             Symbolic Lisp Functions.
* calc-select-buffer:                   Defining Simple Commands.
* calc-set-command-flag:                Defining Simple Commands.
* calc-set-command-flag:                Interactive Lisp Functions.
* calc-slow-wrapper:                    Defining Stack Commands.
* calc-stack-size:                      Stack Lisp Functions.
* calc-substack-height:                 Stack Lisp Functions.
* calc-top-list:                        Stack Lisp Functions.
* calc-top-list-n:                      Defining Stack Commands.
* calc-top-list-n:                      Stack Lisp Functions.
* calc-top-n:                           Stack Lisp Functions.
* calc-unary-op:                        Stack Lisp Functions.
* calc-wrapper:                         Defining Simple Commands.
* cancel-common-factor:                 Symbolic Lisp Functions.
* check-unit-name:                      Symbolic Lisp Functions.
* col-matrix:                           Vector Lisp Functions.
* common-constant-factor:               Symbolic Lisp Functions.
* comp-ascent:                          Formatting Lisp Functions.
* comp-descent:                         Formatting Lisp Functions.
* comp-first-char:                      Formatting Lisp Functions.
* comp-height:                          Formatting Lisp Functions.
* comp-last-char:                       Formatting Lisp Functions.
* comp-width:                           Formatting Lisp Functions.
* compare:                              Computational Lisp Functions.
* compile-rewrites:                     Symbolic Lisp Functions.
* complete:                             Argument Qualifiers.
* complexp:                             Predicates.
* compose-expr:                         Formatting Lisp Functions.
* composition-to-string:                Formatting Lisp Functions.
* constp:                               Predicates.
* convert-temp:                         Calling Calc from Your Programs.
* copy-matrix:                          Vector Lisp Functions.
* defmath:                              Defining Functions.
* deriv:                                Symbolic Lisp Functions.
* dimension-error:                      Vector Lisp Functions.
* div-mod:                              Computational Lisp Functions.
* e:                                    Computational Lisp Functions.
* equal:                                Predicates.
* equal-int:                            Predicates.
* evaluate-expr:                        Computational Lisp Functions.
* evenp:                                Predicates.
* expr-contains:                        Symbolic Lisp Functions.
* expr-contains-count:                  Symbolic Lisp Functions.
* expr-contains-vars:                   Symbolic Lisp Functions.
* expr-depends:                         Symbolic Lisp Functions.
* expr-height:                          Symbolic Lisp Functions.
* expr-subst:                           Symbolic Lisp Functions.
* expr-weight:                          Symbolic Lisp Functions.
* extract-units:                        Symbolic Lisp Functions.
* fixnatnump:                           Predicates.
* fixnum:                               Argument Qualifiers.
* fixnum:                               Computational Lisp Functions.
* fixnump:                              Predicates.
* flatten-vector:                       Vector Lisp Functions.
* float:                                Argument Qualifiers.
* float:                                Computational Lisp Functions.
* floatp:                               Predicates.
* format-flat-expr:                     Formatting Lisp Functions.
* format-nice-expr:                     Formatting Lisp Functions.
* format-number:                        Formatting Lisp Functions.
* format-value:                         Formatting Lisp Functions.
* frac-gcd:                             Symbolic Lisp Functions.
* from-hms:                             Computational Lisp Functions.
* from-radians:                         Computational Lisp Functions.
* from-radians-2:                       Computational Lisp Functions.
* full-circle:                          Computational Lisp Functions.
* half-circle:                          Computational Lisp Functions.
* idiv:                                 Computational Lisp Functions.
* idivmod:                              Computational Lisp Functions.
* imod:                                 Computational Lisp Functions.
* inexact-value:                        Predicates.
* integ:                                Symbolic Lisp Functions.
* integer:                              Argument Qualifiers.
* integer-log2:                         Computational Lisp Functions.
* integerp:                             Predicates.
* interactive:                          Defining Simple Commands.
* is-polynomial:                        Symbolic Lisp Functions.
* is-true:                              Predicates.
* isqrt:                                Computational Lisp Functions.
* lessp:                                Predicates.
* ln-10:                                Computational Lisp Functions.
* ln-2:                                 Computational Lisp Functions.
* looks-evenp:                          Predicates.
* looks-negp:                           Predicates.
* make-float:                           Computational Lisp Functions.
* make-frac:                            Computational Lisp Functions.
* make-intv:                            Computational Lisp Functions.
* make-mod:                             Computational Lisp Functions.
* make-sdev:                            Computational Lisp Functions.
* make-vec:                             Vector Lisp Functions.
* map-tree:                             Symbolic Lisp Functions.
* map-vec:                              Vector Lisp Functions.
* map-vec-2:                            Vector Lisp Functions.
* mat-col:                              Vector Lisp Functions.
* mat-dimens:                           Vector Lisp Functions.
* mat-less-col:                         Vector Lisp Functions.
* mat-less-row:                         Vector Lisp Functions.
* mat-row:                              Vector Lisp Functions.
* match-patterns:                       Symbolic Lisp Functions.
* math-concat:                          Vector Lisp Functions.
* math-defcache:                        Computational Lisp Functions.
* math-defintegral:                     Symbolic Lisp Functions.
* math-defintegral-2:                   Symbolic Lisp Functions.
* math-defsimplify:                     Symbolic Lisp Functions.
* math-equal:                           Predicates.
* math-prev-weekday-in-month:           Time Zones.
* math-std-daylight-savings:            Time Zones.
* matrixp:                              Predicates.
* messy-integerp:                       Predicates.
* multi-subst:                          Symbolic Lisp Functions.
* natnum:                               Argument Qualifiers.
* natnump:                              Predicates.
* nearly-equal:                         Predicates.
* nearly-zerop:                         Predicates.
* negp:                                 Predicates.
* normalize:                            Computational Lisp Functions.
* num-integerp:                         Predicates.
* num-natnump:                          Predicates.
* numberp:                              Predicates.
* numdigs:                              Computational Lisp Functions.
* numvecp:                              Predicates.
* objectp:                              Predicates.
* objvecp:                              Predicates.
* oddp:                                 Predicates.
* overflow:                             Predicates.
* pi:                                   Computational Lisp Functions.
* pi-over-180:                          Computational Lisp Functions.
* pi-over-2:                            Computational Lisp Functions.
* pi-over-4:                            Computational Lisp Functions.
* polar-complexp:                       Predicates.
* poly-mix:                             Symbolic Lisp Functions.
* poly-mul:                             Symbolic Lisp Functions.
* poly-simplify:                        Symbolic Lisp Functions.
* polynomial-base:                      Symbolic Lisp Functions.
* polynomial-p:                         Symbolic Lisp Functions.
* posp:                                 Predicates.
* pow:                                  Computational Lisp Functions.
* pow-mod:                              Computational Lisp Functions.
* power-of-2:                           Computational Lisp Functions.
* prime-test:                           Computational Lisp Functions.
* primp:                                Predicates.
* quarter-circle:                       Computational Lisp Functions.
* quarter-integer:                      Computational Lisp Functions.
* quotient:                             Computational Lisp Functions.
* random-digit:                         Computational Lisp Functions.
* random-digits:                        Computational Lisp Functions.
* random-float:                         Computational Lisp Functions.
* ratp:                                 Predicates.
* read-expr:                            Formatting Lisp Functions.
* read-exprs:                           Formatting Lisp Functions.
* read-number:                          Formatting Lisp Functions.
* realp:                                Predicates.
* rect-complexp:                        Predicates.
* reduce-cols:                          Vector Lisp Functions.
* reduce-vec:                           Vector Lisp Functions.
* reject-arg:                           Predicates.
* remove-units:                         Symbolic Lisp Functions.
* rewrite:                              Symbolic Lisp Functions.
* rewrite-heads:                        Symbolic Lisp Functions.
* row-matrix:                           Vector Lisp Functions.
* scalarp:                              Predicates.
* scale-int:                            Computational Lisp Functions.
* scale-rounding:                       Computational Lisp Functions.
* simplify:                             Symbolic Lisp Functions.
* simplify-extended:                    Symbolic Lisp Functions.
* simplify-units:                       Symbolic Lisp Functions.
* single-units-in-expr-p:               Symbolic Lisp Functions.
* solve-eqn:                            Symbolic Lisp Functions.
* solve-for:                            Symbolic Lisp Functions.
* solve-system:                         Symbolic Lisp Functions.
* sort-intv:                            Computational Lisp Functions.
* sqr:                                  Computational Lisp Functions.
* sqrt-e:                               Computational Lisp Functions.
* sqrt-two-pi:                          Computational Lisp Functions.
* square-matrixp:                       Predicates.
* swap-rows:                            Vector Lisp Functions.
* tderiv:                               Symbolic Lisp Functions.
* to-fraction:                          Computational Lisp Functions.
* to-hms:                               Computational Lisp Functions.
* to-radians:                           Computational Lisp Functions.
* to-radians-2:                         Computational Lisp Functions.
* to-simple-fraction:                   Computational Lisp Functions.
* to-standard-units:                    Symbolic Lisp Functions.
* transpose:                            Vector Lisp Functions.
* two-pi:                               Computational Lisp Functions.
* underflow:                            Predicates.
* units-in-expr-p:                      Symbolic Lisp Functions.
* vec-length:                           Vector Lisp Functions.
* vectorp:                              Predicates.
* with-extra-prec:                      Computational Lisp Functions.
* zerop:                                Predicates.