This is algae.info, produced by makeinfo version 4.3 from algae.texinfo.

INFO-DIR-SECTION Programming Languages
START-INFO-DIR-ENTRY
* algae: (algae).		Another Matrix Programming Language
END-INFO-DIR-ENTRY


File: algae.info,  Node: prof,  Next: show,  Prev: info,  Up: Miscellaneous

 - Function: prof ( infile; outfile; threshold )
     The `prof' function reads an `algae.out' file produced by Algae's
     execution profiler (the `-p' option), and summarizes it by file
     and by line number.  The INFILE argument specifies the file name.
     OUTFILE specifies the output file; if it's NULL, stdout is used.

     The THRESHOLD argument may be used to truncate the summary
     listings.  The truncation occurs after enough entries have been
     printed to account for THRESHOLD percent of the total number of
     hits.  If THRESHOLD is NULL, no truncation is performed.

     Below is an example of `prof' output, obtained with the command
     `prof("algae.out";;50);'.

          Algae execution profile listing.
          
          628 total hits
          
          --- by file ---
          
                hits   % hits    cum %   file
                 201    32.01    32.01   lqrtest.A
                 127    20.22    52.23   /usr/local/lib/algae/ode.A
          
          --- by line ---
          
                hits   % hits    cum %   line   file
                 130    20.70    20.70     88   lqrtest.A
                  42     6.69    27.39      1   /usr/local/lib/algae/plot.A
                  40     6.37    33.76     38   lqrtest.A
                  21     3.34    37.10      1   /usr/local/lib/algae/ode.A
                  17     2.71    39.81     44   /usr/local/lib/algae/ode.A
                  15     2.39    42.20     42   /usr/local/lib/algae/ode.A
                  15     2.39    44.59     41   /usr/local/lib/algae/ode.A
                  14     2.23    46.82      1   /usr/local/lib/algae/ode4.A
                  12     1.91    48.73      1   /usr/local/lib/algae/spline.A
                  10     1.59    50.32      1   lqrtest.A

     First, notice that the number of hits counted in this example was
     only 628.  Four digits of precision in the statistics are clearly
     unjustifed with such a small sample.  The first column reports the
     number of profiler hits counted toward each particular file or
     line number.  The second column restates that as a percentage of
     the total number of hits.  The third column gives the cumulative
     percentage.

     All profiler hits that occur while Algae is parsing a file are
     counted toward its first line.  This is normally insignificant
     compared to execution, but it explains why line 1 shows up so
     often in the "by line" report in the example above.

     No files are closed in `prof'.  Normally, this means that you must
     close them yourself if `prof' is to be called more than once.


File: algae.info,  Node: show,  Next: split,  Prev: prof,  Up: Miscellaneous

 - Function: show ( e )
     This function prints information about the entity E and its
     members.


File: algae.info,  Node: split,  Next: string,  Prev: show,  Up: Miscellaneous

 - Function: split ( s; w )
     The `split' function takes a character scalar argument S, splits
     it into tokens, and returns the tokens in a character vector.
     Each token is delimited by one or more characters from W.  For
     example, `split("/bin:/usr/bin";":")' returns the vector

          (  "/bin"    , "/usr/bin" )

     If W is NULL, the string `" \t\n"' is used.  Thus `split("This is
     a test.")' returns the vector

          (  "This" , "is"   , "a"    , "test." )


File: algae.info,  Node: string,  Next: substr,  Prev: split,  Up: Miscellaneous

 - Function: string ( e )
     The `string' function converts its argument E to character type.
     If E is NULL, a zero-length character scalar is returned.  For
     example, `string(1/(1:3))' returns the vector

          (  "1"       , "0.5"     , "0.333333" )

     Currently, the output format cannot be changed.


File: algae.info,  Node: substr,  Next: test,  Prev: string,  Up: Miscellaneous

 - Function: substr ( c; start; length )
     The `substr' function returns the substring of the character string
     C, beginning at index START, with length LENGTH.  The integer
     START must be greater than zero; if it exceeds the length of C,
     then a zero-length string is returned.  If LENGTH is NULL, then
     all of the remaining characters of C are returned; otherwise,
     LENGTH must not be negative.

     See also `dice', `split', and `string'.


File: algae.info,  Node: test,  Next: time,  Prev: substr,  Up: Miscellaneous

 - Function: test ( e )
     The `test' function evaluates the "truth" of E in the same way
     that Algae's `if' statement would, returning 1 for true and 0 for
     false.  The following entities are false:

        * NULL.

        * Numeric arrays in which every element is zero.

        * Character arrays in which every element is `""'.

        * Vectors and matrices with no elements.

        * Tables with no members.

     All others are true.  Notice that if E is an array (`scalar',
     `vector', or `matrix'), then `test' returns true if any element of
     E is nonzero (or has nonzero length, for character type).

     An example of the use of `test' is Algae's `equal' function, which
     is written as

          equal = function( a; b ) { return !test( a != b ); }

     If `a' and `b' are both matrices, then `a!=b' returns a matrix
     that is all zeros only if every element pair is equal.  In that
     case, `test' returns 0 and `!' changes that to 1.

     See also `equal' and `all'.


File: algae.info,  Node: time,  Next: tolower,  Prev: test,  Up: Miscellaneous

 - Function: time ( )
     The `time' function returns the number of seconds of user time that
     the current process has used.  On most machines, its precision is
     not much more than 1/10 of a second.


File: algae.info,  Node: tolower,  Next: toupper,  Prev: time,  Up: Miscellaneous

 - Function: tolower ( s )
     The `tolower' function converts strings to lower case.  Every
     letter is converted as appropriate for the current locale.  The
     argument S may be a character scalar, vector, or matrix.

     See also `toupper'.


File: algae.info,  Node: toupper,  Next: what,  Prev: tolower,  Up: Miscellaneous

 - Function: toupper ( s )
     The `toupper' function converts strings to upper case.  Every
     letter is converted as appropriate for the current locale.  The
     argument S may be a character scalar, vector, or matrix.

     See also `tolower'.


File: algae.info,  Node: what,  Next: who,  Prev: toupper,  Up: Miscellaneous

 - Function: what ( )
     The `what' function returns a table containing all of the global
     functions.  See also `who'.


File: algae.info,  Node: who,  Prev: what,  Up: Miscellaneous

 - Function: who ( opt )
     The `who' function returns a table containing all global variables
     that are neither functions nor NULL.  Variables with names that
     begin with `$' are excluded, unless the optional argument OPT
     equals `"$"'.  See also `what'.


File: algae.info,  Node: Running Algae,  Next: Projects,  Prev: Standard Functions,  Up: Top

Running Algae
*************

   The Algae interpreter assembles your Algae statements into its own
opcodes and then executes them.  When you are working interactively, it
does this one statement (or one block of statements) at a time.  When
its input comes from a file, the entire file is assembled before
execution of it begins.

* Menu:

* Startup Files::
* Command Line::
* Errors::
* Prompt::
* Signals::


File: algae.info,  Node: Startup Files,  Next: Command Line,  Prev: Running Algae,  Up: Running Algae

Startup Files
=============

   When Algae begins execution, it normally tries to read and execute
two startup files.  The first one it tries is the file in which it
expects some of its standard functions to be defined.  A default name
for this file is given when Algae is compiled--usually it's something
like `/usr/local/lib/algae/4.3.6/algae.A'.  That name can be overridden
with an environment variable called `ALGAE_RC0'.

   Without this file, some of Algae's standard functions will be
missing.  For this reason, Algae will emit an error message and quit if
it can't find the file.  (That is, unless the `-S' option is specified
on the command line.)

   After Algae reads its standard functions, it looks for the file
`.algae' in your home directory and executes it if it's there.  This
file's name can be overridden with the `ALGAE_RC1' environment
variable.  Execution of this file is inhibited by the `-s' command line
option.  No startup files at all are read if the `-S' option is given.


File: algae.info,  Node: Command Line,  Next: Errors,  Prev: Startup Files,  Up: Running Algae

The Command Line
================

   Algae supports command line arguments to request various actions.
Arguments starting with `-' are "options".  Other arguments specify
files to execute.

   Option flags always begin with a hyphen.  Algae supports both
traditional single-letter options and mnemonic long option names.  Long
option names are indicated with `--' instead of `-'.  Abbreviations for
option names are allowed as long as they are unique.

   Options which change Algae's behavior take effect before any files
are executed.  The order of the arguments is unimportant, with the
following two exceptions:
  1. Any input scripts given (with the `-e' or `--script' option) are
     executed in the order that they appear on the command line.  This
     occurs after the startup files are executed and before any other
     files are executed.

  2. Any input files named on the command line are executed in the
     order in which they appear.

   Below is a list of options accepted by Algae.  Both the short and
long option names are indicated.

`-D'
`--disassemble'
     This option turns on the disassembler, which prints Algae's
     opcodes to stderr in a form like assembly language.  You'll
     probably want to combine this with the `-S' option; otherwise,
     you'll get more than 800 lines of opcodes from the standard
     functions.

`-d I'
`--debug I'
     This option sets the debug level to I, where I is an integer.  It
     is normally of use only for debugging the Algae implementation.

`-e COMMANDS'
`--script COMMANDS'
     This option allows you to provide a script for Algae to execute
     from the command line, rather than from a file or from standard
     input.  Such a script is executed after any startup files but
     before any other files are executed.  Any number of `-e' (or
     `--script') options may be given, and the specified scripts are
     executed in the order in which they appear on the command line.

`-h'
`--help'
     Print a brief description of the command line arguments.

`-i'
`--interactive'
     This option causes Algae to use interactive mode when reading from
     the standard input device "stdin".  Without this option, Algae
     uses interactive mode only when its input appears to be from a
     terminal.  In interactive mode, input is parsed a line at a time
     and exceptions do not cause Algae to exit.

`-n'
`--nowhite'
     This option changes the way that scalars are displayed.  The
     printing statements (that is, statements that are terminated by
     either a newline or a `?' character) normally precede the scalar's
     value with a tab, and follow it with a newline.  With this option
     set, neither the tab nor the newline is printed.  (For character
     scalars, the quotation marks are also omitted.)  This option
     affects the printing statements only, and has no effect on the
     functions like `printf'.

`-p'
`--profile'
     This option enables execution profiling--a means for determining
     the execution time characteristics of your Algae program.  When
     profiling is enabled, the profiler periodically interrupts Algae
     and records the line that is currently being executed.  When Algae
     exits, it records this data in the file `algae.out' in the current
     directory.

     Use the `prof' function to read the `algae.out' file and summarize
     it by file and by line number.

     You may wish to use the `strip' function in conjunction with
     profiling.  Since `strip' removes the line and file information
     from a function, any time spent in a call to that function gets
     charged to the line from which it was called.

     We've encountered several systems on which operating system bugs
     prevent the execution profiler from working correctly.  These
     include a DECstation and a Titan, both with MIPS architectures.
     If you have such a system, then Algae should have been installed
     with the execution profiler disabled.  In that case, you'll get an
     error message if you try to use the `-p' option.

`-R'
`--restrict'
     This option causes Algae to run in restricted mode.  The `system'
     function is disabled, as are "pipes" (i.e., file names that begin
     with the `!' character).

     Restricted mode should be used whenever you deal with untrusted
     Algae code.  Without it, a malicious provider of such code could
     cause major damage.

`-r'
`--noreadline'
     If the GNU Readline facility is available, Algae normally uses it
     for interactive command line editing and history.  The `-r' option
     forces Algae to skip Readline processing.  Readline's editing
     commands are similar to emacs: `C-f' forward, `C-b' backward,
     `C-p' up, and `C-n' down.  You can change to `vi' style by typing
     `M-C-j'.

`-S'
`--nostartup'
     If this option is given, none of Algae's startup files are read.
     This means that many of the standard functions will be unavailable.

`-s'
`--norc'
     This option skips reading the user's startup file.

`-V'
`--version'
     This option prints version and date information.

`-x'
`--nostdin'
     This option causes Algae not to read stdin by default when no file
     names are given on the command line.

   Any file names given on the command line are executed as input to
Algae.  If no file names are given (and the `-x' option is not present),
input comes from stdin.  You can specify stdin explicitly with a single
hyphen, so a command line like

     algae init.A -

has Algae execute `init.A' first and then read from standard input.


File: algae.info,  Node: Errors,  Next: Prompt,  Prev: Command Line,  Up: Running Algae

Errors
======

   Several types of errors may be encountered when running Algae.  The
two most common are "parse" errors and "run time" errors.  Parse errors
occur while Algae is parsing its input statements.  Run time errors
occur while Algae is executing its code.  In both cases, Algae prints a
file name and line number associated with the error.


File: algae.info,  Node: Prompt,  Next: Signals,  Prev: Errors,  Up: Running Algae

The algae Prompt
================

   When executing interactively, Algae displays the primary prompt when
it is ready to read a command, and the secondary prompt when it needs
more input to complete a command.  You can customize the prompt simply
by assigning a character vector to the global variable `$prompt'.  Its
first two elements specify the primary and secondary prompts.  By
default, `$prompt' is `( "> ", " " )'.  Assigning something other than
a character vector to `$prompt' is not an error--Algae just won't give
you a prompt.  (Wouldn't it be fun to accept a function?  Hmm, maybe
someday.)

   If the GNU Readline facility is available (that is, linked with
Algae during installation), Algae normally uses it for interactive
command line editing and history.  Readline's editing commands are
similar to emacs: `C-f' forward, `C-b' backward, `C-p' up, and `C-n'
down.  You can change to `vi' style by typing `M-C-j'.  The `-r'
command line option forces Algae to skip Readline processing.


File: algae.info,  Node: Signals,  Prev: Prompt,  Up: Running Algae

Signals
=======

   If Algae receives an interrupt signal (because you pressed a `C-c'
on the keyboard, for example), it stops what it's doing and returns to
the prompt.  (If it isn't running interactively, it simply exits.)  On
Unix systems, you can also use the `kill' command to send a signal to a
process.

   The implementation of interrupt signal handling in Algae is
necessarily a compromise.  We want it to respond promptly, but not at
the expense of our performance.  As a result, it sometimes happens that
Algae does not respond promptly to an interrupt signal.  (If you find a
case like this; please report it.  Sometimes it's the result of an
oversight.)

   Sending Algae a quit signal causes an immediate, clean exit.  There
are various other signals which will cause Algae to terminate, but this
is the one to use if you want your files closed properly, etc.


File: algae.info,  Node: Projects,  Next: Bugs,  Prev: Running Algae,  Up: Top

Projects
********

   Below is a list of improvements that we'd like to make to Algae.
These items run the gamut from specific changes that would take only an
hour or so to implement to vague, half-baked ideas that might take
months.  The items are in no particular order--we haven't identified
priorities on most of them.  We'd be very happy to have some help.

   * The `atan' and `atanh' functions need improvement for complex
     arguments.  They are based on simple formulas, but better
     algorithms are available that are faster, more accurate, and less
     prone to overflow.

   * In the old days, getting Readline to do context-based completion
     (as on variable names) was nearly impossible.  This may have
     changed - we ought to take a new look at it.

   * The `printf' and related functions should be given additional
     capabilities to accept array arguments.

   * I'm interested in exploring a better arrangement for the help
     system.  Users should be able to tie in documentation for their
     own code.

   * With the `builtin' function, Algae has dynamic linking capability.
     To make this useful, though, we have to document the interface
     and reorganize the header files.

   * Wouldn't a GTK+ (http://www.gtk.org/) interface be nice?

   * We need to complete the `fread' and `fwrite' implementation, and
     we'll probably want an `fseek' function as well.

   * Symbolic debugging of Algae code would be very helpful.



File: algae.info,  Node: Bugs,  Next: Concept Index,  Prev: Projects,  Up: Top

Bugs
****

   Your bug reports play an essential role in making Algae reliable.
By reporting a bug, you may or may not get a timely solution to your
problem.  Either way, bug reports help us to make the next version of
Algae better.  In addition, your comments or criticisms on Algae or the
Algae language are also welcomed.

   The Algae interpreter is incomplete.  There are several operations
that it should be able to perform but that have not yet been
implemented.  These cases elicit a "detour" message from Algae.  Since
they're not bugs, you don't need to tell us about them.  Still,
complaining about them might get them fixed.

* Menu:

* Reporting Bugs::
* Reported Bugs::


File: algae.info,  Node: Reporting Bugs,  Next: Reported Bugs,  Prev: Bugs,  Up: Bugs

Reporting Bugs
==============

   In order for a bug report to serve its purpose, you must include the
information we need to fix it.  As the GNU people say, "report all the
facts".  But never mind Joe Friday--the more information the better.
It usually doesn't pay to explore the "envelope" of the bug; that is,
changes to the input that affect it.  Providing a simple example is the
best way to get a bug fixed.

   You should include the following information with your bug report:

   * The version of Algae.  You can get this by running it with the
     `-V' option.

   * A complete input file that will reproduce the bug.  A single
     statement is generally not sufficient.

   * The type of machine you are using, and the operating system name
     and version number.

   * A description of what behavior you observe that you believe is
     incorrect.

   Send bug reports to:

     ksh@sideslip.org

or, as a last resort, mail them to:

     Algae Bugs
     Attn: Scott Hunziker
     The Boeing Company
     P.O. Box 3707, MC 8K-26
     Seattle, WA  98124-2207


File: algae.info,  Node: Reported Bugs,  Prev: Reporting Bugs,  Up: Bugs

Reported Bugs
=============

   Below is a list of bugs that are known to exist in the current
version of Algae and are waiting to be fixed.

1
     Recurse deep enough, and Algae dumps core.  For example, the
     expression

          function () { return self(); } ()

     will not return gracefully.  (I just tried it, and I had to reboot
     my machine!)  It usually takes more than 500 levels of recursion
     to hit this bug, though, so you'll probably only encounter it with
     runaway functions.

16
     We have problems when a parse error occurs in a recursive call to
     the parser.  Local variables created in the recursive call are
     left in an invalid state.  This happens, for example, if you call
     the `source' function from an interactive session and encounter a
     parse error in the process.

22
     Every time Algae parses a file, it leaks the memory in which the
     name of that file is stored.  The names are kept around because
     user functions refer to them.  Instead, we should arrange for the
     names to be stored with each user function so that they get
     deleted when the function is deleted.

23
     When Algae reads a binary file that contains a user function, it
     allocates memory for every string constant in that function.  If
     you then delete that function, this memory is leaked.

24
     We use the texi2html program to make Algae's HTML documentation
     from the texinfo source.  Among its numerous deficiencies, it
     sometimes splits an anchor from the text with which it is supposed
     to be associated.  For example (from algae-3.5.0), the anchor for
     the section named "Running Algae" is put at the bottom of the file
     `algae_6.html' instead of at the top of `algae_7.html' where it
     belongs.  For this reason, the Algae `info' function may not take
     you to the right place in the document.


File: algae.info,  Node: Concept Index,  Next: Function Index,  Prev: Bugs,  Up: Top

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

   If you can't find what you're looking for here, please send us a bug
report.  We'll try to include an entry for it in the next release of
this manual.

* Menu:

* ! (not operator) <1>:                  Not.
* ! (not operator):                      Primer.
* != (inequality operator) <1>:          Relation.
* != (inequality operator):              Primer.
* " (quote character):                   Data.
* # (begin comment):                     Statements.
* $$:                                    Variable Names.
* % (modulus operator):                  Multiplication.
* %= (assignment operator):              Assign.
* & (and operator) <1>:                  And.
* & (and operator):                      Primer.
* && (and operator) <1>:                 Short And.
* && (and operator):                     Primer.
* ' (conjugate transpose operator):      Transpose.
* () function calls:                     Call.
* * (multiplication operator):           Multiplication.
* *= (assignment operator):              Assign.
* + (addition operator):                 Addition.
* + (affirmation operator):              Negation.
* += (assignment operator):              Assign.
* , (append operator) <1>:               Append.
* , (append operator):                   Primer.
* - (negation operator):                 Negation.
* - (subtraction operator):              Addition.
* -= (assignment operator):              Assign.
* . (member reference operator):         Member.
* / (division operator):                 Multiplication.
* /= (assignment operator):              Assign.
* : (vector generation operator) <1>:    Generate.
* : (vector generation operator):        Primer.
* ; (statement terminator) <1>:          Statements.
* ; (statement terminator):              Primer.
* < (less than operator) <1>:            Relation.
* < (less than operator):                Primer.
* <= (less or equal operator) <1>:       Relation.
* <= (less or equal operator):           Primer.
* = (assignment operator):               Assign.
* == (equality operator) <1>:            Relation.
* == (equality operator):                Primer.
* > (greater than operator) <1>:         Relation.
* > (greater than operator):             Primer.
* >= (greater or equal operator) <1>:    Relation.
* >= (greater or equal operator):        Primer.
* ? (statement terminator) <1>:          Statements.
* ? (statement terminator):              Primer.
* @ (element-by-element multiplication operator): Multiplication.
* @= (assignment operator):              Assign.
* [ ] (element reference):               Element.
* \ (backslash character):               Data.
* ^ (power operator):                    Power.
* Absolute file name:                    src.
* Absolute value:                        abs.
* Addition operator:                     Addition.
* Affirmation operator:                  Negation.
* algae.out <1>:                         Command Line.
* algae.out:                             prof.
* ALGAE_SRC_PATH environment variable:   src.
* And operator <1>:                      Short And.
* And operator <2>:                      And.
* And operator:                          Primer.
* Apostrophe:                            Transpose.
* Append operator <1>:                   Append.
* Append operator:                       Primer.
* Arc cosine:                            acos.
* Arc cosine hyperbolic:                 acosh.
* Arc sine:                              asin.
* Arc sine hyperbolic:                   asinh.
* Arc tangent:                           atan.
* Arc tangent hyperbolic:                atanh.
* Argument:                              arg.
* Arguments of functions <1>:            Functions.
* Arguments of functions <2>:            Call.
* Arguments of functions:                Primer.
* Arguments, command line:               Command Line.
* Arnoldi method:                        iram.
* ARPACK:                                iram.
* Arrays:                                Data.
* Assignment operators:                  Assign.
* Assignments:                           Expressions.
* Associativity of operators:            Operators.
* Automatic class conversion <1>:        Operators.
* Automatic class conversion:            Primer.
* Automatic type conversion:             Operators.
* Autosrc functions:                     autosrc.
* Back substitution:                     backsub.
* Backslash character:                   Data.
* Bandwidth:                             band.
* Bandwidth reduction:                   gpskca.
* BCSLIB-EXT <1>:                        factor.
* BCSLIB-EXT <2>:                        chol.
* BCSLIB-EXT:                            backsub.
* Beep:                                  Predefined Variables.
* Beginning execution:                   Startup Files.
* Binary input:                          fread.
* Binary output:                         fwrite.
* Block diagonal:                        bdiag.
* Block transpose:                       btrans.
* Boeing Computer Services <1>:          factor.
* Boeing Computer Services <2>:          chol.
* Boeing Computer Services:              backsub.
* Braces:                                Primer.
* Brackets:                              Element.
* break statement:                       Primer.
* Brennan, Mike:                         About Algae.
* Bugs:                                  Bugs.
* Builtin functions:                     Primer.
* Call by value:                         Primer.
* Calling functions:                     Call.
* Case <1>:                              toupper.
* Case:                                  tolower.
* Case of variable names:                Variable Names.
* catch:                                 Primer.
* Catenation, string:                    Addition.
* Ceiling:                               ceil.
* Change directory:                      cd.
* Character constants:                   Data.
* Character strings <1>:                 substr.
* Character strings:                     string.
* Character type <1>:                    Data.
* Character type:                        Primer.
* Cholesky factorization:                chol.
* Circular shift:                        circshift.
* Circumflex:                            Power.
* Class conversions <1>:                 Operators.
* Class conversions:                     Primer.
* Class of entities <1>:                 Data.
* Class of entities <2>:                 Entities.
* Class of entities:                     Primer.
* Closing a file:                        close.
* Colon <1>:                             Generate.
* Colon:                                 Primer.
* Comma <1>:                             Append.
* Comma:                                 Primer.
* Command line arguments:                Command Line.
* Comments:                              Statements.
* Complement:                            complement.
* Complex conjugate:                     conj.
* Complex type <1>:                      Data.
* Complex type:                          Primer.
* Concatenation, string:                 Addition.
* Condition number:                      equilibrate.
* Conjugate transpose operator:          Transpose.
* Conjugate, complex:                    conj.
* Constants:                             Data.
* continue statement:                    Primer.
* Control-flow statements:               Primer.
* Conversions between classes:           Operators.
* Conversions between types:             Operators.
* Converting between classes:            Primer.
* Cosine:                                cos.
* Creating new members:                  Primer.
* Cubic splines:                         spline.
* Data types:                            Data.
* Debug level:                           Command Line.
* Defining functions <1>:                Functions.
* Defining functions:                    Primer.
* Defining variables:                    Variables.
* Deleting entities:                     Primer.
* Dense storage:                         dense.
* Detours:                               Bugs.
* Diagonal of a matrix:                  diag.
* Digital filter:                        filter.
* Digits to print <1>:                   digits.
* Digits to print:                       Predefined Variables.
* Digits, significant:                   Statements.
* Directory, changing:                   cd.
* Disassembler:                          Command Line.
* Division operator:                     Multiplication.
* Dot operator <1>:                      Member.
* Dot operator <2>:                      Entities.
* Dot operator:                          Primer.
* Double quotes:                         Data.
* Dynamic linking:                       builtin.
* Efficiency of loops:                   Primer.
* Efficient matrix products:             mult.
* Eigenvalues and eigenvectors <1>:      iram.
* Eigenvalues and eigenvectors:          eig.
* Element numbering in matrices:         Primer.
* Element numbering in vectors:          Primer.
* Element references:                    Element.
* Emacs:                                 Command Line.
* End of file:                           Reading Numbers.
* Entities <1>:                          Data.
* Entities <2>:                          Entities.
* Entities:                              Primer.
* Entity members <1>:                    Entities.
* Entity members:                        Primer.
* Environment variables:                 getenv.
* Equality operators:                    Primer.
* Equilibration:                         equilibrate.
* Error function <1>:                    erfc.
* Error function:                        erf.
* Error messages <1>:                    Errors.
* Error messages:                        message.
* Escape sequences:                      Data.
* Evaluation <1>:                        exec.
* Evaluation:                            eval.
* Evaluation of variables:               Evaluation.
* Exceptions:                            exception.
* exceptions:                            Primer.
* Exclamation mark <1>:                  fprintf.
* Exclamation mark:                      Not.
* Execution profiling <1>:               Command Line.
* Execution profiling:                   prof.
* Exiting:                               exit.
* Exponential:                           exp.
* Expressions <1>:                       Expressions.
* Expressions:                           Language.
* Factors, prime:                        primef.
* False:                                 Primer.
* Features:                              provide.
* FFTW:                                  fft.
* File closing:                          close.
* File searching:                        src.
* Files on the command line:             Command Line.
* Floor:                                 floor.
* for statement:                         Primer.
* Format for printing:                   digits.
* Format, real or complex number:        Statements.
* Formatted output <1>:                  printf.
* Formatted output:                      fprintf.
* Forward substitution:                  backsub.
* Fourier transform:                     fft.
* Full storage:                          full.
* Function calls:                        Call.
* Function expressions:                  Functions.
* Functions <1>:                         Data.
* Functions <2>:                         Functions.
* Functions:                             Primer.
* Future of Algae:                       Projects.
* Generate operator <1>:                 Generate.
* Generate operator:                     Primer.
* Generating vectors:                    Primer.
* Gibbs-King:                            gpskca.
* Gibbs-Poole-Stockmeyer:                gpskca.
* Global scope:                          Primer.
* Global symbol table:                   Variable Names.
* Global variables:                      Variable Names.
* Greatest common divisor:               gcd.
* grep:                                  grep.
* Hunziker, Jennifer:                    About Algae.
* Hunziker, Scott:                       About Algae.
* Hyperbolic arc cosine:                 acosh.
* Hyperbolic arc sine:                   asinh.
* Hyperbolic arc tangent:                atanh.
* Hyperbolic cosine:                     cosh.
* Hyperbolic sine:                       sinh.
* Hyperbolic tangent:                    tanh.
* Identity matrix:                       ident.
* if statement:                          Primer.
* Imaginary value:                       imag.
* in keyword:                            Primer.
* Initial value problems:                ode4.
* Input filters <1>:                     Command Line.
* Input filters <2>:                     src.
* Input filters:                         fprintf.
* Input, binary:                         fread.
* Input, character:                      read.
* Input, numeric:                        readnum.
* Integer power program:                 Powers.
* Integer type <1>:                      Data.
* Integer type:                          Primer.
* Integration:                           trapz.
* Interactive mode <1>:                  Command Line.
* Interactive mode:                      Primer.
* Interpolation:                         spline.
* Interpreter:                           Running Algae.
* Interrupt signal:                      Signals.
* Interrupting loops:                    Primer.
* Intersection:                          intersection.
* Inverse cosine:                        acos.
* Inverse fourier transform:             ifft.
* Inverse hyperbolic cosine:             acosh.
* Inverse hyperbolic sine:               asinh.
* Inverse hyperbolic tangent:            atanh.
* Inverse tangent:                       atan.
* Inverse, matrix:                       inv.
* Killing Algae:                         Signals.
* Known bugs:                            Reported Bugs.
* Labels in submatrix expressions:       Primer.
* Labels in subvector expressions:       Primer.
* Lanczos method:                        iram.
* LAPACK:                                backsub.
* Least common multiple:                 lcm.
* Least squares:                         leastsq.
* Length of variable names:              Variable Names.
* Lewis, John:                           gpskca.
* Linear equations <1>:                  solve.
* Linear equations:                      backsub.
* Linear spacing:                        linspace.
* Linking, dynamic:                      builtin.
* local statement <1>:                   Scope.
* local statement:                       Primer.
* Logarithm:                             log.
* Logarithmic spacing:                   logspace.
* Logical operators:                     Primer.
* Loops:                                 Primer.
* Lower case:                            tolower.
* Lower triangle:                        tril.
* Magic squares:                         magic.
* Magnitude:                             abs.
* Matching labels:                       Primer.
* MATLAB <1>:                            putmat.
* MATLAB <2>:                            getmat.
* MATLAB <3>:                            Data.
* MATLAB:                                About Algae.
* Matrices <1>:                          Data.
* Matrices:                              Primer.
* Matrix constants:                      Data.
* Matrix factorization <1>:              factor.
* Matrix factorization:                  chol.
* Matrix inverse:                        inv.
* Matrix labels:                         Primer.
* Matrix multiplication:                 mult.
* Matrix norm:                           norm.
* Matrix products:                       mult.
* Matrix, diagonal:                      diag.
* Maximum <1>:                           max.
* Maximum:                               imax.
* Member names:                          Member.
* Member references:                     Member.
* Members:                               Primer.
* Members of entities:                   Entities.
* Members of matrices:                   Data.
* Members of scalars:                    Data.
* Members of vectors:                    Data.
* Messages, error:                       Errors.
* Minimum <1>:                           min.
* Minimum:                               imin.
* Minus sign:                            Negation.
* Modulus operator:                      Multiplication.
* Monte Carlo integration:               monte.
* Multiplication operators:              Multiplication.
* Names of members:                      Member.
* Names of variables:                    Variable Names.
* Negation operator:                     Negation.
* Newline <1>:                           Statements.
* Newline:                               Primer.
* Nonlinear equations:                   brent.
* Norm:                                  norm.
* Not operator <1>:                      Not.
* Not operator:                          Primer.
* NULL:                                  Primer.
* Number reading program:                Reading Numbers.
* Numeric constants:                     Data.
* Numerical integration:                 trapz.
* Operations on functions:               Primer.
* Operations on NULL:                    Primer.
* Operations on tables:                  Primer.
* Operators:                             Operators.
* Operators, associativity:              Operators.
* Operators, precedence:                 Operators.
* Options on the command line:           Command Line.
* Or operator <1>:                       Short Or.
* Or operator <2>:                       Or.
* Or operator:                           Primer.
* Ordinary differential equations:       ode4.
* Output filters <1>:                    Command Line.
* Output filters <2>:                    src.
* Output filters:                        fprintf.
* Output, binary:                        fwrite.
* Output, formatted <1>:                 printf.
* Output, formatted:                     fprintf.
* Overdetermined systems:                leastsq.
* Parentheses:                           Call.
* Passing arguments by value:            Primer.
* Path lists:                            get_path.
* Phase:                                 arg.
* PID:                                   Predefined Variables.
* Pipes <1>:                             Command Line.
* Pipes <2>:                             src.
* Pipes:                                 fprintf.
* Plus sign:                             Negation.
* Polynomial roots:                      roots.
* Power operator:                        Power.
* Precedence of operators:               Operators.
* Predefined members:                    Primer.
* Predefined variables:                  Predefined Variables.
* Prime factors:                         primef.
* Prime numbers:                         primes.
* Print format:                          digits.
* Printing formatted output <1>:         printf.
* Printing formatted output:             fprintf.
* Profile:                               band.
* Profile reduction:                     gpskca.
* Profiling <1>:                         Command Line.
* Profiling:                             prof.
* Program, integer powers:               Powers.
* Program, number reading:               Reading Numbers.
* Program, temperature conversions:      Temperatures.
* Projects:                              Projects.
* Prompt <1>:                            Prompt.
* Prompt:                                Predefined Variables.
* Question mark <1>:                     Statements.
* Question mark:                         Primer.
* Quit signal:                           Signals.
* Quote character:                       Data.
* raise an exception:                    Primer.
* Random numbers <1>:                    srand.
* Random numbers <2>:                    randn.
* Random numbers:                        rand.
* Reading entities:                      get.
* Reading numbers:                       readnum.
* Reading text:                          read.
* Readline facility:                     Command Line.
* Real type <1>:                         Data.
* Real type:                             Primer.
* Real value:                            real.
* Recursion:                             Primer.
* Reduction, bandwidth:                  gpskca.
* Reduction, profile:                    gpskca.
* Referencing elements:                  Element.
* Referencing members:                   Member.
* Regular expressions:                   grep.
* Relational operators <1>:              Relation.
* Relational operators:                  Primer.
* Relative file name:                    src.
* Reported bugs:                         Reported Bugs.
* Reporting bugs:                        Reporting Bugs.
* Restricted execution:                  Command Line.
* return statement:                      Primer.
* Root finding:                          brent.
* Roots of a polynomial:                 roots.
* Rounding:                              round.
* Runge-Kutta:                           ode4.
* Scalar constants:                      Data.
* Scalars:                               Data.
* Scope of variables <1>:                Scope.
* Scope of variables:                    Primer.
* Searching:                             grep.
* self:                                  Primer.
* Semicolon <1>:                         Statements.
* Semicolon:                             Primer.
* Separating arguments:                  Primer.
* Sets:                                  set.
* Shared objects:                        builtin.
* Shift, circular:                       circshift.
* Short And:                             Short And.
* Short Or:                              Short Or.
* SIGINT:                                Signals.
* Sign:                                  sign.
* Signals:                               Signals.
* Significant digits:                    Statements.
* Signum:                                sign.
* SIGQUIT:                               Signals.
* Sine:                                  sin.
* Singular value decomposition:          svd.
* Solving linear equations <1>:          solve.
* Solving linear equations:              backsub.
* Solving nonlinear equations:           brent.
* Sorting vectors <1>:                   sort.
* Sorting vectors:                       isort.
* Source files:                          src.
* Sparse storage:                        sparse.
* Spline interpolation:                  spline.
* Splitting into tokens:                 split.
* Square root:                           sqrt.
* Standard functions:                    Standard Functions.
* Standard input:                        Command Line.
* Starting algae:                        Primer.
* Startup files:                         Startup Files.
* Statement terminators <1>:             Statements.
* Statement terminators:                 Primer.
* Statements <1>:                        Statements.
* Statements <2>:                        Language.
* Statements:                            Primer.
* Statements for control-flow:           Primer.
* stderr:                                message.
* stdin:                                 Command Line.
* String concatenation:                  Addition.
* Strings <1>:                           string.
* Strings <2>:                           Data.
* Strings:                               Primer.
* Submatrix expressions:                 Primer.
* Subspace iteration:                    ssi.
* Substrings:                            substr.
* Subtraction operator:                  Addition.
* Subvector assignment:                  Primer.
* Subvector expressions:                 Primer.
* SuperLU:                               backsub.
* Symbol table:                          Variable Names.
* Tables <1>:                            Data.
* Tables:                                Primer.
* Tangent:                               tan.
* Temperature conversion program:        Temperatures.
* Temporary files:                       tmp_file.
* Terminal, width:                       Predefined Variables.
* Terminating Algae:                     exit.
* Terminating statements <1>:            Statements.
* Terminating statements:                Primer.
* Testing for equality:                  Primer.
* Tokens, splitting:                     split.
* Transpose operator:                    Transpose.
* Trapezoidal integration:               trapz.
* Triangle <1>:                          triu.
* Triangle:                              tril.
* True:                                  Primer.
* try:                                   Primer.
* Type conversions:                      Operators.
* Types <1>:                             Data.
* Types:                                 Primer.
* Unary minus operator:                  Negation.
* Unary plus operator:                   Negation.
* Underdetermined systems:               leastsq.
* Union of two sets:                     union.
* Upper case:                            toupper.
* Upper triangle:                        triu.
* User functions:                        Primer.
* Variable evaluation:                   Evaluation.
* Variable names:                        Variable Names.
* Variables <1>:                         Variables.
* Variables:                             Primer.
* Variables, environment:                getenv.
* Variables, predefined:                 Predefined Variables.
* Variables, scope:                      Scope.
* Vector constants:                      Data.
* Vector generation <1>:                 Generate.
* Vector generation:                     Primer.
* Vector labels:                         Primer.
* Vector norm:                           norm.
* Vectors <1>:                           Data.
* Vectors:                               Primer.
* veil statement:                        Scope.
* Version:                               Command Line.
* vi:                                    Command Line.
* while statement:                       Primer.
* Width of terminal:                     Predefined Variables.
* Wrapping lines:                        Predefined Variables.
* Writing entities:                      put.
* | (or operator) <1>:                   Or.
* | (or operator):                       Primer.
* || (or operator) <1>:                  Short Or.
* || (or operator):                      Primer.

