This is octave.info, produced by makeinfo version 4.6 from octave.texi.

START-INFO-DIR-ENTRY
* Octave: (octave).	Interactive language for numerical computations.
END-INFO-DIR-ENTRY

   Copyright (C) 1996, 1997 John W. Eaton.

   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 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.


File: octave.info,  Node: Audio Processing,  Next: Quaternions,  Prev: Image Processing,  Up: Top

Audio Processing
****************

Octave provides a few functions for dealing with audio data.  An audio
`sample' is a single output value from an A/D converter, i.e., a small
integer number (usually 8 or 16 bits), and audio data is just a series
of such samples.  It can be characterized by three parameters:  the
sampling rate (measured in samples per second or Hz, e.g. 8000 or
44100), the number of bits per sample (e.g. 8 or 16), and the number of
channels (1 for mono, 2 for stereo, etc.).

   There are many different formats for representing such data.
Currently, only the two most popular, _linear encoding_ and _mu-law
encoding_, are supported by Octave.  There is an excellent FAQ on audio
formats by Guido van Rossum <guido@cwi.nl> which can be found at any
FAQ ftp site, in particular in the directory
`/pub/usenet/news.answers/audio-fmts' of the archive site
`rtfm.mit.edu'.

   Octave simply treats audio data as vectors of samples (non-mono data
are not supported yet).  It is assumed that audio files using linear
encoding have one of the extensions `lin' or `raw', and that files
holding data in mu-law encoding end in `au', `mu', or `snd'.

 - Function File:  lin2mu (X, N)
     Converts audio data from linear to mu-law.  Mu-law values use 8-bit
     unsigned integers.  Linear values use N-bit signed integers or
     floating point values in the range -1<=X<=1 if N is 0.  If N is
     not specified it defaults to 0, 8 or 16 depending on the range
     values in X.

 - Function File:  mu2lin (X, BPS)
     Converts audio data from linear to mu-law.  Mu-law values are 8-bit
     unsigned integers.  Linear values use N-bit signed integers or
     floating point values in the range -1<=y<=1 if N is 0.  If N is
     not specified it defaults to 8.

 - Function File:  loadaudio (NAME, EXT, BPS)
     Loads audio data from the file `NAME.EXT' into the vector X.

     The extension EXT determines how the data in the audio file is
     interpreted;  the extensions `lin' (default) and `raw' correspond
     to linear, the extensions `au', `mu', or `snd' to mu-law encoding.

     The argument BPS can be either 8 (default) or 16, and specifies
     the number of bits per sample used in the audio file.

 - Function File:  saveaudio (NAME, X, EXT, BPS)
     Saves a vector X of audio data to the file `NAME.EXT'.  The
     optional parameters EXT and BPS determine the encoding and the
     number of bits per sample used in the audio file (see
     `loadaudio');  defaults are `lin' and 8, respectively.

   The following functions for audio I/O require special A/D hardware
and operating system support.  It is assumed that audio data in linear
encoding can be played and recorded by reading from and writing to
`/dev/dsp', and that similarly `/dev/audio' is used for mu-law
encoding.  These file names are system-dependent.  Improvements so that
these functions will work without modification on a wide variety of
hardware are welcome.

 - Function File:  playaudio (NAME, EXT)
 - Function File:  playaudio (X)
     Plays the audio file `NAME.EXT' or the audio data stored in the
     vector X.

 - Function File:  record (SEC, SAMPLING_RATE)
     Records SEC seconds of audio input into the vector X.  The default
     value for SAMPLING_RATE is 8000 samples per second, or 8kHz.  The
     program waits until the user types <RET> and then immediately
     starts to record.

 - Function File: setaudio ([W_TYPE [, VALUE]])
     executes the shell command `mixer [W_TYPE [, VALUE]]'


File: octave.info,  Node: Quaternions,  Next: System Utilities,  Prev: Audio Processing,  Up: Top

Quaternions
***********

Quaternions are hypercomplex numbers used to represent spatial
rotations in three dimensions.  This set of routines provides a useful
basis for working with quaternions in Octave.  A tutorial is in the
Octave source, scripts/quaternion/quaternion.ps.

   These functions were written by A. S. Hodel, Associate Professor,
Auburn University.

 - Function File: [A, B, C, D] = quaternion (w)
 - Function File: [VV, THETA] = quaternion (w)
 - Function File: W = quaternion (A, B, C, D)
 - Function File: W = quaternion (VV, THETA)
     Construct or extract a quaternion

          w = a*i + b*j + c*k + d

     from given data.

 - Function File:  qconj (Q)
     Conjugate of a quaternion.

          q = [w, x, y, z] = w*i + x*j + y*k + z
          qconj (q) = -w*i -x*j -y*k + z

 - Function File:  qderiv (omega)
     Derivative of a quaternion.

     Let Q be a quaternion to transform a vector from a fixed frame to
     a rotating frame.  If the rotating frame is rotating about the [x,
     y, z] axes at angular rates [wx, wy, wz], then the derivative of Q
     is given by

          Q' = qderivmat (omega) * Q

     If the passive convention is used (rotate the frame, not the
     vector), then

          Q' = -qderivmat (omega) * Q

 - Function File:  qderivmat (OMEGA)
     Derivative of a quaternion.

     Let Q be a quaternion to transform a vector from a fixed frame to
     a rotating frame.  If the rotating frame is rotating about the [x,
     y, z] axes at angular rates [wx, wy, wz], then the derivative of Q
     is given by

          Q' = qderivmat (omega) * Q

     If the passive convention is used (rotate the frame, not the
     vector), then

          Q' = -qderivmat (omega) * Q.

 - Function File:  qinv (Q)
     Return the inverse of a quaternion.

          q = [w, x, y, z] = w*i + x*j + y*k + z
          qmult (q, qinv (q)) = 1 = [0 0 0 1]

 - Function File:  qmult (A, B)
     Multiply two quaternions.

          [w, x, y, z] = w*i + x*j + y*k + z

     identities:

          i^2 = j^2 = k^2 = -1
          ij = k                 jk = i
          ki = j                 kj = -i
          ji = -k                ik = -j

 - Function File:  qtrans (V, Q)
     Transform the unit quaternion V by the unit quaternion Q.  Returns
     `V = Q*V/Q'.

 - Function File:  qtransv (V, Q)
     Transform the 3-D vector V by the unit quaternion Q.  Return a
     column vector.

          vi = (2*real(q)^2 - 1)*vb + 2*imag(q)*(imag(q)'*vb)
             + 2*real(q)*cross(imag(q),vb)

     Where imag(q) is a column vector of length 3.

 - Function File:  qtransvmat (QIB)
     Construct a 3x3 transformation matrix from quaternion QIB that is
     equivalent to rotation of th radians about axis VV, where `[VV,
     TH] = quaternion (QIB)'.

 - Function File:  qcoordinate_plot (QF, QB, QV)
     Plot in the current figure a set of coordinate axes as viewed from
     the orientation specified by quaternion QV.  Inertial axes are
     also plotted:

    QF
          Quaternion from reference (x,y,z) to inertial.

    QB
          Quaternion from reference to body.

    QV
          Quaternion from reference to view angle.


File: octave.info,  Node: System Utilities,  Next: Tips,  Prev: Quaternions,  Up: Top

System Utilities
****************

This chapter describes the functions that are available to allow you to
get information about what is happening outside of Octave, while it is
still running, and use this information in your program.  For example,
you can get information about environment variables, the current time,
and even start other programs from the Octave prompt.

* Menu:

* Timing Utilities::
* Filesystem Utilities::
* Controlling Subprocesses::
* Process ID Information::
* Environment Variables::
* Current Working Directory::
* Password Database Functions::
* Group Database Functions::
* System Information::


File: octave.info,  Node: Timing Utilities,  Next: Filesystem Utilities,  Up: System Utilities

Timing Utilities
================

Octave's core set of functions for manipulating time values are
patterned after the corresponding functions from the standard C library.
Several of these functions use a data structure for time that includes
the following elements:

`usec'
     Microseconds after the second (0-999999).

`sec'
     Seconds after the minute (0-61).  This number can be 61 to account
     for leap seconds.

`min'
     Minutes after the hour (0-59).

`hour'
     Hours since midnight (0-23).

`mday'
     Day of the month (1-31).

`mon'
     Months since January (0-11).

`year'
     Years since 1900.

`wday'
     Days since Sunday (0-6).

`yday'
     Days since January 1 (0-365).

`isdst'
     Daylight Savings Time flag.

`zone'
     Time zone.

In the descriptions of the following functions, this structure is
referred to as a TM_STRUCT.

 - Loadable Function:  time ()
     Return the current time as the number of seconds since the epoch.
     The epoch is referenced to 00:00:00 CUT (Coordinated Universal
     Time) 1 Jan 1970.  For example, on Monday February 17, 1997 at
     07:15:06 CUT, the value returned by `time' was 856163706.

 - Function File:  ctime (T)
     Convert a value returned from `time' (or any other nonnegative
     integer), to the local time and return a string of the same form as
     `asctime'.  The function `ctime (time)' is equivalent to `asctime
     (localtime (time))'.  For example,

          ctime (time ())
          => "Mon Feb 17 01:15:06 1997\n"

 - Loadable Function:  gmtime (T)
     Given a value returned from time (or any nonnegative integer),
     return a time structure corresponding to CUT.  For example,

          gmtime (time ())
               => {
                     usec = 0
                     year = 97
                     mon = 1
                     mday = 17
                     sec = 6
                     zone = CST
                     min = 15
                     wday = 1
                     hour = 7
                     isdst = 0
                     yday = 47
                   }

 - Loadable Function:  localtime (T)
     Given a value returned from time (or any nonnegative integer),
     return a time structure corresponding to the local time zone.

          localtime (time ())
               => {
                     usec = 0
                     year = 97
                     mon = 1
                     mday = 17
                     sec = 6
                     zone = CST
                     min = 15
                     wday = 1
                     hour = 1
                     isdst = 0
                     yday = 47
                   }

 - Loadable Function:  mktime (TM_STRUCT)
     Convert a time structure corresponding to the local time to the
     number of seconds since the epoch.  For example,

          mktime (localtime (time ())
               => 856163706

 - Function File:  asctime (TM_STRUCT)
     Convert a time structure to a string using the following five-field
     format: Thu Mar 28 08:40:14 1996.  For example,

          asctime (localtime (time ())
          => "Mon Feb 17 01:15:06 1997\n"

     This is equivalent to `ctime (time ())'.

 - Loadable Function:  strftime (TM_STRUCT)
     Format a time structure in a flexible way using `%' substitutions
     similar to those in `printf'.  Except where noted, substituted
     fields have a fixed size; numeric fields are padded if necessary.
     Padding is with zeros by default; for fields that display a single
     number, padding can be changed or inhibited by following the `%'
     with one of the modifiers described below.  Unknown field
     specifiers are copied as normal characters.  All other characters
     are copied to the output without change.  For example,

          strftime ("%r (%Z) %A %e %B %Y", localtime (time ()) )
               => "01:15:06 AM (CST) Monday 17 February 1997"

     Octave's `strftime' function supports a superset of the ANSI C
     field specifiers.

     Literal character fields:

    `%'
          % character.

    `n'
          Newline character.

    `t'
          Tab character.

     Numeric modifiers (a nonstandard extension):

    `- (dash)'
          Do not pad the field.

    `_ (underscore)'
          Pad the field with spaces.

     Time fields:

    `%H'
          Hour (00-23).

    `%I'
          Hour (01-12).

    `%k'
          Hour (0-23).

    `%l'
          Hour (1-12).

    `%M'
          Minute (00-59).

    `%p'
          Locale's AM or PM.

    `%r'
          Time, 12-hour (hh:mm:ss [AP]M).

    `%R'
          Time, 24-hour (hh:mm).

    `%s'
          Time in seconds since 00:00:00, Jan 1, 1970 (a nonstandard
          extension).

    `%S'
          Second (00-61).

    `%T'
          Time, 24-hour (hh:mm:ss).

    `%X'
          Locale's time representation (%H:%M:%S).

    `%Z'
          Time zone (EDT), or nothing if no time zone is determinable.

     Date fields:

    `%a'
          Locale's abbreviated weekday name (Sun-Sat).

    `%A'
          Locale's full weekday name, variable length (Sunday-Saturday).

    `%b'
          Locale's abbreviated month name (Jan-Dec).

    `%B'
          Locale's full month name, variable length (January-December).

    `%c'
          Locale's date and time (Sat Nov 04 12:02:33 EST 1989).

    `%C'
          Century (00-99).

    `%d'
          Day of month (01-31).

    `%e'
          Day of month ( 1-31).

    `%D'
          Date (mm/dd/yy).

    `%h'
          Same as %b.

    `%j'
          Day of year (001-366).

    `%m'
          Month (01-12).

    `%U'
          Week number of year with Sunday as first day of week (00-53).

    `%w'
          Day of week (0-6).

    `%W'
          Week number of year with Monday as first day of week (00-53).

    `%x'
          Locale's date representation (mm/dd/yy).

    `%y'
          Last two digits of year (00-99).

    `%Y'
          Year (1970-).

 - Loadable Function: [TM_STRUCT, NCHARS] = strptime (STR, FMT)
     Convert the string STR to a time structure under the control of
     the format FMT.

   Most of the remaining functions described in this section are not
patterned after the standard C library.  Some are available for
compatiblity with MATLAB and others are provided because they are
useful.

 - Function File:  clock ()
     Return a vector containing the current year, month (1-12), day
     (1-31), hour (0-23), minute (0-59) and second (0-61).  For example,

          clock ()
          => [ 1993, 8, 20, 4, 56, 1 ]

     The function clock is more accurate on systems that have the
     `gettimeofday' function.

 - Function File:  date ()
     Return the date as a character string in the form DD-MMM-YY.  For
     example,

          date ()
          => "20-Aug-93"

 - Function File:  etime (T1, T2)
     Return the difference (in seconds) between two time values
     returned from `clock'.  For example:

          t0 = clock ();
           many computations later...
          elapsed_time = etime (clock (), t0);

     will set the variable `elapsed_time' to the number of seconds since
     the variable `t0' was set.

 - Function File: [TOTAL, USER, SYSTEM] = cputime ();
     Return the CPU time used by your Octave session.  The first output
     is the total time spent executing your process and is equal to the
     sum of second and third outputs, which are the number of CPU
     seconds spent executing in user mode and the number of CPU seconds
     spent executing in system mode, respectively.  If your system does
     not have a way to report CPU time usage, `cputime' returns 0 for
     each of its output values.  Note that because Octave used some CPU
     time to start, it is reasonable to check to see if `cputime' works
     by checking to see if the total CPU time used is nonzero.

 - Function File:  is_leap_year (YEAR)
     Return 1 if the given year is a leap year and 0 otherwise.  If no
     arguments are provided, `is_leap_year' will use the current year.
     For example,

          is_leap_year (2000)
          => 1

 - Function File:  tic ()
 - Function File:  toc ()
     These functions set and check a wall-clock timer.  For example,

          tic ();
           many computations later...
          elapsed_time = toc ();

     will set the variable `elapsed_time' to the number of seconds since
     the most recent call to the function `tic'.

     If you are more interested in the CPU time that your process used,
     you should use the `cputime' function instead.  The `tic' and
     `toc' functions report the actual wall clock time that elapsed
     between the calls.  This may include time spent processing other
     jobs or doing nothing at all.  For example,

          tic (); sleep (5); toc ()
          => 5
          t = cputime (); sleep (5); cputime () - t
          => 0

     (This example also illustrates that the CPU timer may have a fairly
     coarse resolution.)

 - Built-in Function:  pause (SECONDS)
     Suspend the execution of the program.  If invoked without any
     arguments, Octave waits until you type a character.  With a
     numeric argument, it pauses for the given number of seconds.  For
     example, the following statement prints a message and then waits 5
     seconds before clearing the screen.

          fprintf (stderr, "wait please...
          ");
          pause (5);
          clc;

 - Built-in Function:  sleep (SECONDS)
     Suspend the execution of the program for the given number of
     seconds.

 - Built-in Function:  usleep (MICROSECONDS)
     Suspend the execution of the program for the given number of
     microseconds.  On systems where it is not possible to sleep for
     periods of time less than one second, `usleep' will pause the
     execution for `round (MICROSECONDS / 1e6)' seconds.


File: octave.info,  Node: Filesystem Utilities,  Next: Controlling Subprocesses,  Prev: Timing Utilities,  Up: System Utilities

Filesystem Utilities
====================

Octave includes the following functions for renaming and deleting files,
creating, deleting, and reading directories, and for getting information
about the status of files.

 - Built-in Function: [ERR, MSG] = rename (OLD, NEW)
     Change the name of file OLD to NEW.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = link (OLD, NEW)
     Create a new link (also known as a hard link) to an existing file.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = symlink (OLD, NEW)
     Create a symbolic link NEW which contains the string OLD.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [RESULT, ERR, MSG] = readlink (SYMLINK)
     Read the value of the symbolic link SYMLINK.

     If successful, RESULT contains the contents of the symbolic link
     SYMLINK, ERR is 0 and MSG is an empty string.  Otherwise, ERR is
     nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = unlink (FILE)
     Delete the file named FILE.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [FILES, ERR, MSG] = readdir (DIR)
     Return names of the files in the directory DIR as a cell array of
     strings.  If an error occurs, return an empty cell array in FILES.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = mkdir (DIR)
     Create a directory named DIR.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = rmdir (DIR)
     Remove the directory named DIR.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [ERR, MSG] = mkfifo (NAME, MODE)
     Create a FIFO special file named NAME with file mode MODE

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function:  umask (MASK)
     Set the permission mask for file creation.  The parameter MASK is
     an integer, interpreted as an octal number.  If successful,
     returns the previous value of the mask (as an integer to be
     interpreted as an octal number); otherwise an error message is
     printed.

 - Built-in Function: [INFO, ERR, MSG] = stat (FILE)
 - Built-in Function: [INFO, ERR, MSG] = lstat (FILE)
     Return a structure S containing the following information about
     FILE.

    `dev'
          ID of device containing a directory entry for this file.

    `ino'
          File number of the file.

    `modestr'
          File mode, as a string of ten letters or dashes as would be
          returned by `ls -l'.

    `nlink'
          Number of links.

    `uid'
          User ID of file's owner.

    `gid'
          Group ID of file's group.

    `rdev'
          ID of device for block or character special files.

    `size'
          Size in bytes.

    `atime'
          Time of last access in the same form as time values returned
          from `time'.  *Note Timing Utilities::.

    `mtime'
          Time of last modification in the same form as time values
          returned from `time'.  *Note Timing Utilities::.

    `ctime'
          Time of last file status change in the same form as time
          values returned from `time'.  *Note Timing Utilities::.

    `blksize'
          Size of blocks in the file.

    `blocks'
          Number of blocks allocated for file.

     If the call is successful ERR is 0 and MSG is an empty string.  If
     the file does not exist, or some other error occurs, S is an empty
     matrix, ERR is -1, and MSG contains the corresponding system error
     message.

     If FILE is a symbolic link, `stat' will return information about
     the actual file the is referenced by the link.  Use `lstat' if you
     want information about the symbolic link itself.

     For example,

          [s, err, msg] = stat ("/vmlinuz")
                => s =
                  {
                    atime = 855399756
                    rdev = 0
                    ctime = 847219094
                    uid = 0
                    size = 389218
                    blksize = 4096
                    mtime = 847219094
                    gid = 6
                    nlink = 1
                    blocks = 768
                    modestr = -rw-r--r--
                    ino = 9316
                    dev = 2049
                  }
               => err = 0
               => msg =

 - Built-in Function:  glob (PATTERN)
     Given an array of strings in PATTERN, return a cell array of file
     names that match any of them, or an empty cell array if no
     patterns match.  Tilde expansion is performed on each of the
     patterns before looking for matching file names.  For example,

          glob ("/vm*")
               => "/vmlinuz"

 - Built-in Function:  fnmatch (PATTERN, STRING)
     Return 1 or zero for each element of STRING that matches any of
     the elements of the string array PATTERN, using the rules of
     filename pattern matching.  For example,

          fnmatch ("a*b", ["ab"; "axyzb"; "xyzab"])
               => [ 1; 1; 0 ]

 - Built-in Function:  file_in_path (PATH, FILE)
 - Built-in Function:  file_in_path (PATH, FILE, "all")
     Return the absolute name name of FILE if it can be found in PATH.
     The value of PATH should be a colon-separated list of directories
     in the format described for the built-in variable `LOADPATH'.  If
     no file is found, return an empty matrix.  For example,

          file_in_path (LOADPATH, "nargchk.m")
               => "/usr/local/share/octave/2.0/m/general/nargchk.m"

     If the second argument is a cell array of of strings, search each
     directory of the path for element of the cell array and return the
     first that matches.

     If the third optional argument `"all"' is supplied, return a cell
     array containing the list of all files that have the same name in
     the path.  If no files are found, return an empty cell array.


 - Built-in Function:  tilde_expand (STRING)
     Performs tilde expansion on STRING.  If STRING begins with a tilde
     character, (`~'), all of the characters preceding the first slash
     (or all characters, if there is no slash) are treated as a
     possible user name, and the tilde and the following characters up
     to the slash are replaced by the home directory of the named user.
     If the tilde is followed immediately by a slash, the tilde is
     replaced by the home directory of the user running Octave.  For
     example,

          tilde_expand ("~joeuser/bin")
               => "/home/joeuser/bin"
          tilde_expand ("~/bin")
               => "/home/jwe/bin"


File: octave.info,  Node: Controlling Subprocesses,  Next: Process ID Information,  Prev: Filesystem Utilities,  Up: System Utilities

Controlling Subprocesses
========================

Octave includes some high-level commands like `system' and `popen' for
starting subprocesses.  If you want to run another program to perform
some task and then look at its output, you will probably want to use
these functions.

   Octave also provides several very low-level Unix-like functions which
can also be used for starting subprocesses, but you should probably only
use them if you can't find any way to do what you need with the
higher-level functions.

 - Built-in Function:  system (STRING, RETURN_OUTPUT, TYPE)
     Execute a shell command specified by STRING.  The second argument
     is optional.  If TYPE is `"async"', the process is started in the
     background and the process id of the child process is returned
     immediately.  Otherwise, the process is started, and Octave waits
     until it exits.  If TYPE argument is omitted, a value of `"sync"'
     is assumed.

     If two input arguments are given (the actual value of
     RETURN_OUTPUT is irrelevant) and the subprocess is started
     synchronously, or if SYSTEM is called with one input argument and
     one or more output arguments, the output from the command is
     returned.  Otherwise, if the subprocess is executed synchronously,
     it's output is sent to the standard output.  To send the output of
     a command executed with SYSTEM through the pager, use a command
     like

          disp (system (cmd, 1));

     or

          printf ("%s
          ", system (cmd, 1));

     The `system' function can return two values.  The first is any
     output from the command that was written to the standard output
     stream, and the second is the output status of the command.  For
     example,

          [output, status] = system ("echo foo; exit 2");

     will set the variable `output' to the string `foo', and the
     variable `status' to the integer `2'.

 - Built-in Function: FID = popen (COMMAND, MODE)
     Start a process and create a pipe.  The name of the command to run
     is given by COMMAND.  The file identifier corresponding to the
     input or output stream of the process is returned in FID.  The
     argument MODE may be

    `"r"'
          The pipe will be connected to the standard output of the
          process, and open for reading.

    `"w"'
          The pipe will be connected to the standard input of the
          process, and open for writing.

     For example,

          fid = popen ("ls -ltr / | tail -3", "r");
          while (isstr (s = fgets (fid)))
            fputs (stdout, s);
          endwhile
               -| drwxr-xr-x  33 root  root  3072 Feb 15 13:28 etc
               -| drwxr-xr-x   3 root  root  1024 Feb 15 13:28 lib
               -| drwxrwxrwt  15 root  root  2048 Feb 17 14:53 tmp

 - Built-in Function:  pclose (FID)
     Close a file identifier that was opened by `popen'.  You may also
     use `fclose' for the same purpose.

 - Function File: [IN, OUT, PID] = popen2 (COMMAND, ARGS)
     Start a subprocess with two-way communication.  The name of the
     process is given by COMMAND, and ARGS is an array of strings
     containing options for the command.  The file identifiers for the
     input and output streams of the subprocess are returned in IN and
     OUT.  If execution of the command is successful, PID contains the
     process ID of the subprocess.  Otherwise, PID is -1.

     For example,

          [in, out, pid] = popen2 ("sort", "-nr");
          fputs (in, "these\nare\nsome\nstrings\n");
          fclose (in);
          while (isstr (s = fgets (out)))
            fputs (stdout, s);
          endwhile
          fclose (out);
          -| are
          -| some
          -| strings
          -| these

 - Built-in Variable: EXEC_PATH
     The variable `EXEC_PATH' is a colon separated list of directories
     to search when executing external programs.  Its initial value is
     taken from the environment variable `OCTAVE_EXEC_PATH' (if it
     exists) or `PATH', but that value can be overridden by the command
     line argument `--exec-path PATH', or by setting the value of
     `EXEC_PATH' in a startup script.  If the value of `EXEC_PATH'
     begins (ends) with a colon, the directories

          OCTAVE-HOME/libexec/octave/site/exec/ARCH
          OCTAVE-HOME/libexec/octave/VERSION/exec/ARCH

     are prepended (appended) to `EXEC_PATH', where OCTAVE-HOME is the
     top-level directory where all of Octave is installed (the default
     value is `/usr/local').  If you don't specify a value for
     `EXEC_PATH' explicitly, these special directories are prepended to
     your shell path.

   In most cases, the following functions simply decode their arguments
and make the corresponding Unix system calls.  For a complete example
of how they can be used, look at the definition of the function
`popen2'.

 - Built-in Function: [PID, MSG] = fork ()
     Create a copy of the current process.

     Fork can return one of the following values:

    > 0
          You are in the parent process.  The value returned from
          `fork' is the process id of the child process.  You should
          probably arrange to wait for any child processes to exit.

    0
          You are in the child process.  You can call `exec' to start
          another process.  If that fails, you should probably call
          `exit'.

    < 0
          The call to `fork' failed for some reason.  You must take
          evasive action.  A system dependent error message will be
          waiting in MSG.

 - Built-in Function: [ERR, MSG] = exec (FILE, ARGS)
     Replace current process with a new process.  Calling `exec' without
     first calling `fork' will terminate your current Octave process and
     replace it with the program named by FILE.  For example,

          exec ("ls" "-l")

     will run `ls' and return you to your shell prompt.

     If successful, `exec' does not return.  If `exec' does return, ERR
     will be nonzero, and MSG will contain a system-dependent error
     message.

 - Built-in Function: [FILE_IDS, ERR, MSG] = pipe ()
     Create a pipe and return the vector FILE_IDS, which corresponding
     to the reading and writing ends of the pipe.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.

 - Built-in Function: [FID, MSG] = dup2 (OLD, NEW)
     Duplicate a file descriptor.

     If successful, FID is greater than zero and contains the new file
     ID.  Otherwise, FID is negative and MSG contains a
     system-dependent error message.

 - Built-in Function: [PID, MSG] = waitpid (PID, OPTIONS)
     Wait for process PID to terminate.  The PID argument can be:

    -1
          Wait for any child process.

    0
          Wait for any child process whose process group ID is equal to
          that of the Octave interpreter process.

    > 0
          Wait for termination of the child process with ID PID.

     The OPTIONS argument can be:

    0
          Wait until signal is received or a child process exits (this
          is the default if the OPTIONS argument is missing).

    1
          Do not hang if status is not immediately available.

    2
          Report the status of any child processes that are stopped,
          and whose status has not yet been reported since they stopped.

    3
          Implies both 1 and 2.

     If the returned value of PID is greater than 0, it is the process
     ID of the child process that exited.  If an error occurs, PID will
     be less than zero and MSG will contain a system-dependent error
     message.

 - Built-in Function: [ERR, MSG] = fcntl (FID, REQUEST, ARG)
     Change the properties of the open file FID.  The following values
     may be passed as REQUEST:

    `F_DUPFD'
          Return a duplicate file descriptor.

    `F_GETFD'
          Return the file descriptor flags for FID.

    `F_SETFD'
          Set the file descriptor flags for FID.

    `F_GETFL'
          Return the file status flags for FID.  The following codes
          may be returned (some of the flags may be undefined on some
          systems).

         `O_RDONLY'
               Open for reading only.

         `O_WRONLY'
               Open for writing only.

         `O_RDWR'
               Open for reading and writing.

         `O_APPEND'
               Append on each write.

         `O_NONBLOCK'
               Nonblocking mode.

         `O_SYNC'
               Wait for writes to complete.

         `O_ASYNC'
               Asynchronous I/O.

    `F_SETFL'
          Set the file status flags for FID to the value specified by
          ARG.  The only flags that can be changed are `O_APPEND' and
          `O_NONBLOCK'.

     If successful, ERR is 0 and MSG is an empty string.  Otherwise,
     ERR is nonzero and MSG contains a system-dependent error message.


File: octave.info,  Node: Process ID Information,  Next: Environment Variables,  Prev: Controlling Subprocesses,  Up: System Utilities

Process, Group, and User IDs
============================

 - Built-in Function: pgid = getpgrp ()
     Return the process group id of the current process.

 - Built-in Function: pid = getpid ()
     Return the process id of the current process.

 - Built-in Function: pid = getppid ()
     Return the process id of the parent process.

 - Built-in Function: euid = geteuid ()
     Return the effective user id of the current process.

 - Built-in Function: uid = getuid ()
     Return the real user id of the current process.

 - Built-in Function: egid = getegid ()
     Return the effective group id of the current process.

 - Built-in Function: gid = getgid ()
     Return the real group id of the current process.


File: octave.info,  Node: Environment Variables,  Next: Current Working Directory,  Prev: Process ID Information,  Up: System Utilities

Environment Variables
=====================

 - Built-in Function:  getenv (VAR)
     Return the value of the environment variable VAR.  For example,

          getenv ("PATH")

     returns a string containing the value of your path.

 - Built-in Function:  putenv (VAR, VALUE)
     Set the value of the environment variable VAR to VALUE.


File: octave.info,  Node: Current Working Directory,  Next: Password Database Functions,  Prev: Environment Variables,  Up: System Utilities

Current Working Directory
=========================

 - Command: cd dir
 - Command: chdir dir
     Change the current working directory to DIR.  If DIR is omitted,
     the current directory is changed to the users home directory.  For
     example,

          cd ~/octave

     Changes the current working directory to `~/octave'.  If the
     directory does not exist, an error message is printed and the
     working directory is not changed.

 - Command: ls options
     List directory contents.  For example,

          ls -l
               -| total 12
               -| -rw-r--r--   1 jwe  users  4488 Aug 19 04:02 foo.m
               -| -rw-r--r--   1 jwe  users  1315 Aug 17 23:14 bar.m

     The `dir' and `ls' commands are implemented by calling your
     system's directory listing command, so the available options may
     vary from system to system.

 - Built-in Function:  pwd ()
     Return the current working directory.


File: octave.info,  Node: Password Database Functions,  Next: Group Database Functions,  Prev: Current Working Directory,  Up: System Utilities

Password Database Functions
===========================

Octave's password database functions return information in a structure
with the following fields.

`name'
     The user name.

`passwd'
     The encrypted password, if available.

`uid'
     The numeric user id.

`gid'
     The numeric group id.

`gecos'
     The GECOS field.

`dir'
     The home directory.

`shell'
     The initial shell.

   In the descriptions of the following functions, this data structure
is referred to as a PW_STRUCT.

 - Loadable Function: PW_STRUCT =  getpwent ()
     Return a structure containing an entry from the password database,
     opening it if necessary. Once the end of the data has been reached,
     `getpwent' returns 0.

 - Loadable Function: PW_STRUCT =  getpwuid (UID).
     Return a structure containing the first entry from the password
     database with the user ID UID.  If the user ID does not exist in
     the database, `getpwuid' returns 0.

 - Loadable Function: PW_STRUCT =  getpwnam (NAME)
     Return a structure containing the first entry from the password
     database with the user name NAME.  If the user name does not exist
     in the database, `getpwname' returns 0.

 - Loadable Function:  setpwent ()
     Return the internal pointer to the beginning of the password
     database.

 - Loadable Function:  endpwent ()
     Close the password database.


File: octave.info,  Node: Group Database Functions,  Next: System Information,  Prev: Password Database Functions,  Up: System Utilities

Group Database Functions
========================

Octave's group database functions return information in a structure
with the following fields.

`name'
     The user name.

`passwd'
     The encrypted password, if available.

`gid'
     The numeric group id.

`mem'
     The members of the group.

   In the descriptions of the following functions, this data structure
is referred to as a GRP_STRUCT.

 - Loadable Function: GRP_STRUCT = getgrent ()
     Return an entry from the group database, opening it if necessary.
     Once the end of the data has been reached, `getgrent' returns 0.

 - Loadable Function: GRP_STRUCT = getgrgid (GID).
     Return the first entry from the group database with the group ID
     GID.  If the group ID does not exist in the database, `getgrgid'
     returns 0.

 - Loadable Function: GRP_STRUCT = getgrnam (NAME)
     Return the first entry from the group database with the group name
     NAME.  If the group name does not exist in the database,
     `getgrname' returns 0.

 - Loadable Function:  setgrent ()
     Return the internal pointer to the beginning of the group database.

 - Loadable Function:  endgrent ()
     Close the group database.


File: octave.info,  Node: System Information,  Prev: Group Database Functions,  Up: System Utilities

System Information
==================

 - Function File:  computer ()
     Print or return a string of the form CPU-VENDOR-OS that identifies
     the kind of computer Octave is running on.  If invoked with an
     output argument, the value is returned instead of printed.  For
     example,

          computer ()
          -| i586-pc-linux-gnu
          
          x = computer ()
          => x = "i586-pc-linux-gnu"

 - Built-in Function:  isieee ()
     Return 1 if your computer claims to conform to the IEEE standard
     for floating point calculations.

 - Built-in Variable: OCTAVE_VERSION
     The version number of Octave, as a string.

 - Built-in Function:  octave_config_info (OPTION)
     Return a structure containing configuration and installation
     information for Octave.

     if OPTION is a string, return the configuration information for the
     specified option.


 - Loadable Function:  getrusage ()
     Return a structure containing a number of statistics about the
     current Octave process.  Not all fields are available on all
     systems.  If it is not possible to get CPU time statistics, the
     CPU time slots are set to zero.  Other missing data are replaced
     by NaN.  Here is a list of all the possible fields that can be
     present in the structure returned by `getrusage':

    `idrss'
          Unshared data size.

    `inblock'
          Number of block input operations.

    `isrss'
          Unshared stack size.

    `ixrss'
          Shared memory size.

    `majflt'
          Number of major page faults.

    `maxrss'
          Maximum data size.

    `minflt'
          Number of minor page faults.

    `msgrcv'
          Number of messages received.

    `msgsnd'
          Number of messages sent.

    `nivcsw'
          Number of involuntary context switches.

    `nsignals'
          Number of signals received.

    `nswap'
          Number of swaps.

    `nvcsw'
          Number of voluntary context switches.

    `oublock'
          Number of block output operations.

    `stime'
          A structure containing the system CPU time used.  The
          structure has the elements `sec' (seconds) `usec'
          (microseconds).

    `utime'
          A structure containing the user CPU time used.  The structure
          has the elements `sec' (seconds) `usec' (microseconds).


File: octave.info,  Node: Tips,  Next: Trouble,  Prev: System Utilities,  Up: Top

Tips and Standards
******************

This chapter describes no additional features of Octave.  Instead it
gives advice on making effective use of the features described in the
previous chapters.

* Menu:

* Style Tips::                  Writing clean and robust programs.
* Coding Tips::                 Making code run faster.
* Documentation Tips::          Writing readable documentation strings.
* Comment Tips::                Conventions for writing comments.
* Function Headers::            Standard headers for functions.


File: octave.info,  Node: Style Tips,  Next: Coding Tips,  Up: Tips

Writing Clean Octave Programs
=============================

Here are some tips for avoiding common errors in writing Octave code
intended for widespread use:

   * Since all global variables share the same name space, and all
     functions share another name space, you should choose a short word
     to distinguish your program from other Octave programs.  Then take
     care to begin the names of all global variables, constants, and
     functions with the chosen prefix.  This helps avoid name conflicts.

     If you write a function that you think ought to be added to Octave
     under a certain name, such as `fiddle_matrix', don't call it by
     that name in your program.  Call it `mylib_fiddle_matrix' in your
     program, and send mail to <bug-octave@bevo.che.wisc.edu>
     suggesting that it be added to Octave.  If and when it is, the
     name can be changed easily enough.

     If one prefix is insufficient, your package may use two or three
     alternative common prefixes, so long as they make sense.

     Separate the prefix from the rest of the symbol name with an
     underscore `_'.  This will be consistent with Octave itself and
     with most Octave programs.

   * When you encounter an error condition, call the function `error'
     (or `usage').  The `error' and `usage' functions do not return.
     *Note Errors::.

   * Please put a copyright notice on the file if you give copies to
     anyone.  Use the same lines that appear at the top of the function
     files distributed with Octave.  If you have not signed papers to
     assign the copyright to anyone else, then place your name in the
     copyright notice.


File: octave.info,  Node: Coding Tips,  Next: Documentation Tips,  Prev: Style Tips,  Up: Tips

Tips for Making Code Run Faster.
================================

Here are some ways of improving the execution speed of Octave programs.

   * Avoid looping wherever possible.

   * Use iteration rather than recursion whenever possible.  Function
     calls are slow in Octave.

   * Avoid resizing matrices unnecessarily.  When building a single
     result matrix from a series of calculations, set the size of the
     result matrix first, then insert values into it.  Write

          result = zeros (big_n, big_m)
          for i = over:and_over
            r1 = ...
            r2 = ...
            result (r1, r2) = new_value ();
          endfor

     instead of

          result = [];
          for i = ever:and_ever
            result = [ result, new_value() ];
          endfor

   * Avoid calling `eval' or `feval' whenever possible, because they
     require Octave to parse input or look up the name of a function in
     the symbol table.

     If you are using `eval' as an exception handling mechanism and not
     because you need to execute some arbitrary text, use the `try'
     statement instead.  *Note The try Statement::.

   * If you are calling lots of functions but none of them will need to
     change during your run, set the variable
     `ignore_function_time_stamp' to `"all"' so that Octave doesn't
     waste a lot of time checking to see if you have updated your
     function files.


File: octave.info,  Node: Documentation Tips,  Next: Comment Tips,  Prev: Coding Tips,  Up: Tips

Tips for Documentation Strings
==============================

Here are some tips for the writing of documentation strings.

   * Every command, function, or variable intended for users to know
     about should have a documentation string.

   * An internal variable or subroutine of an Octave program might as
     well have a documentation string.

   * The first line of the documentation string should consist of one
     or two complete sentences that stand on their own as a summary.

     The documentation string can have additional lines that expand on
     the details of how to use the function or variable.  The
     additional lines should also be made up of complete sentences.

   * For consistency, phrase the verb in the first sentence of a
     documentation string as an infinitive with "to" omitted.  For
     instance, use "Return the frob of A and B." in preference to
     "Returns the frob of A and B."  Usually it looks good to do
     likewise for the rest of the first paragraph.  Subsequent
     paragraphs usually look better if they have proper subjects.

   * Write documentation strings in the active voice, not the passive,
     and in the present tense, not the future.  For instance, use
     "Return a list containing A and B." instead of "A list containing
     A and B will be returned."

   * Avoid using the word "cause" (or its equivalents) unnecessarily.
     Instead of, "Cause Octave to display text in boldface," write just
     "Display text in boldface."

   * Do not start or end a documentation string with whitespace.

   * Format the documentation string so that it fits in an Emacs window
     on an 80-column screen.  It is a good idea for most lines to be no
     wider than 60 characters.

     However, rather than simply filling the entire documentation
     string, you can make it much more readable by choosing line breaks
     with care.  Use blank lines between topics if the documentation
     string is long.

   * *Do not* indent subsequent lines of a documentation string so that
     the text is lined up in the source code with the text of the first
     line.  This looks nice in the source code, but looks bizarre when
     users view the documentation.  Remember that the indentation
     before the starting double-quote is not part of the string!

   * The documentation string for a variable that is a yes-or-no flag
     should start with words such as "Nonzero means...", to make it
     clear that all nonzero values are equivalent and indicate
     explicitly what zero and nonzero mean.

   * When a function's documentation string mentions the value of an
     argument of the function, use the argument name in capital letters
     as if it were a name for that value.  Thus, the documentation
     string of the operator `/' refers to its second argument as
     `DIVISOR', because the actual argument name is `divisor'.

     Also use all caps for meta-syntactic variables, such as when you
     show the decomposition of a list or vector into subunits, some of
     which may vary.


File: octave.info,  Node: Comment Tips,  Next: Function Headers,  Prev: Documentation Tips,  Up: Tips

Tips on Writing Comments
========================

Here are the conventions to follow when writing comments.

`#'
     Comments that start with a single sharp-sign, `#', should all be
     aligned to the same column on the right of the source code.  Such
     comments usually explain how the code on the same line does its
     job.  In the Emacs mode for Octave, the `M-;'
     (`indent-for-comment') command automatically inserts such a `#' in
     the right place, or aligns such a comment if it is already present.

`##'
     Comments that start with two semicolons, `##', should be aligned to
     the same level of indentation as the code.  Such comments usually
     describe the purpose of the following lines or the state of the
     program at that point.

The indentation commands of the Octave mode in Emacs, such as `M-;'
(`indent-for-comment') and `TAB' (`octave-indent-line') automatically
indent comments according to these conventions, depending on the number
of semicolons.  *Note Manipulating Comments: (emacs)Comments.


File: octave.info,  Node: Function Headers,  Prev: Comment Tips,  Up: Tips

Conventional Headers for Octave Functions
=========================================

Octave has conventions for using special comments in function files to
give information such as who wrote them.  This section explains these
conventions.

   The top of the file should contain a copyright notice, followed by a
block of comments that can be used as the help text for the function.
Here is an example:

     ## Copyright (C) 1996, 1997 John W. Eaton
     ##
     ## This file is part of Octave.
     ##
     ## Octave 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, or (at your option) any later version.
     ##
     ## Octave 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 Octave; see the file COPYING.  If not,
     ## write to the Free Software Foundation, 59 Temple Place -
     ## Suite 330, Boston, MA 02111-1307, USA.
     
     ## usage: [IN, OUT, PID] = popen2 (COMMAND, ARGS)
     ##
     ## Start a subprocess with two-way communication.  COMMAND
     ## specifies the name of the command to start.  ARGS is an
     ## array of strings containing options for COMMAND.  IN and
     ## OUT are the file ids of the input and streams for the
     ## subprocess, and PID is the process id of the subprocess,
     ## or -1 if COMMAND could not be executed.
     ##
     ## Example:
     ##
     ##  [in, out, pid] = popen2 ("sort", "-nr");
     ##  fputs (in, "these\nare\nsome\nstrings\n");
     ##  fclose (in);
     ##  while (isstr (s = fgets (out)))
     ##    fputs (stdout, s);
     ##  endwhile
     ##  fclose (out);

   Octave uses the first block of comments in a function file that do
not appear to be a copyright notice as the help text for the file.  For
Octave to recognize the first comment block as a copyright notice, it
must match the regular expression

     ^ Copyright (C).*\n\n This file is part of Octave.

or

     ^ Copyright (C).*\n\n This program is free softwar

(after stripping the leading comment characters).  This is a fairly
strict requirement, and may be relaxed somewhat in the future.

   After the copyright notice and help text come several "header
comment" lines, each beginning with `## HEADER-NAME:'.  For example,

     ## Author: jwe
     ## Keywords: subprocesses input-output
     ## Maintainer: jwe

   Here is a table of the conventional possibilities for HEADER-NAME:

`Author'
     This line states the name and net address of at least the principal
     author of the library.

          ## Author: John W. Eaton <jwe@bevo.che.wisc.edu>

`Maintainer'
     This line should contain a single name/address as in the Author
     line, or an address only, or the string `jwe'.  If there is no
     maintainer line, the person(s) in the Author field are presumed to
     be the maintainers.  The example above is mildly bogus because the
     maintainer line is redundant.

     The idea behind the `Author' and `Maintainer' lines is to make
     possible a function to "send mail to the maintainer" without
     having to mine the name out by hand.

     Be sure to surround the network address with `<...>' if you
     include the person's full name as well as the network address.

`Created'
     This optional line gives the original creation date of the file.
     For historical interest only.

`Version'
     If you wish to record version numbers for the individual Octave
     program, put them in this line.

`Adapted-By'
     In this header line, place the name of the person who adapted the
     library for installation (to make it fit the style conventions, for
     example).

`Keywords'
     This line lists keywords.  Eventually, it will be used by an
     apropos command to allow people will find your package when
     they're looking for things by topic area.  To separate the
     keywords, you can use spaces, commas, or both.

   Just about every Octave function ought to have the `Author' and
`Keywords' header comment lines.  Use the others if they are
appropriate.  You can also put in header lines with other header
names--they have no standard meanings, so they can't do any harm.


File: octave.info,  Node: Trouble,  Next: Installation,  Prev: Tips,  Up: Top

Known Causes of Trouble
***********************

   This section describes known problems that affect users of Octave.
Most of these are not Octave bugs per se--if they were, we would fix
them.  But the result for a user may be like the result of a bug.

   Some of these problems are due to bugs in other software, some are
missing features that are too much work to add, and some are places
where people's opinions differ as to what is best.

* Menu:

* Actual Bugs::                 Bugs we will fix later.
* Reporting Bugs::
* Bug Criteria::
* Bug Lists::
* Bug Reporting::
* Sending Patches::
* Service::


File: octave.info,  Node: Actual Bugs,  Next: Reporting Bugs,  Up: Trouble

Actual Bugs We Haven't Fixed Yet
================================

   * Output that comes directly from Fortran functions is not sent
     through the pager and may appear out of sequence with other output
     that is sent through the pager.  One way to avoid this is to force
     pending output to be flushed before calling a function that will
     produce output from within Fortran functions.  To do this, use the
     command

          fflush (stdout)

     Another possible workaround is to use the command

          page_screen_output = "false"

     to turn the pager off.

   * If you get messages like

          Input line too long

     when trying to plot many lines on one graph, you have probably
     generated a plot command that is too large for `gnuplot''s
     fixed-length buffer for commands.  Splitting up the plot command
     doesn't help because replot is implemented in gnuplot by simply
     appending the new plotting commands to the old command line and
     then evaluating it again.

     You can demonstrate this `feature' by running gnuplot and doing
     something like

            plot sin (x), sin (x), sin (x), ... lots more ..., sin (x)

     and then

            replot sin (x), sin (x), sin (x), ... lots more ..., sin (x)

     after repeating the replot command a few times, gnuplot will give
     you an error.

     Also, it doesn't help to use backslashes to enter a plot command
     over several lines, because the limit is on the overall command
     line length, once the backslashed lines are all pasted together.

     Because of this, Octave tries to use as little of the command-line
     length as possible by using the shortest possible abbreviations for
     all the plot commands and options.  Unfortunately, the length of
     the temporary file names is probably what is taking up the most
     space on the command line.

     You can buy a little bit of command line space by setting the
     environment variable `TMPDIR' to be "." before starting Octave, or
     you can increase the maximum command line length in gnuplot by
     changing the following limits in the file plot.h in the gnuplot
     distribution and recompiling gnuplot.

          #define MAX_LINE_LEN 32768  /* originally 1024 */
          #define MAX_TOKENS 8192     /* originally 400 */

     Of course, this doesn't really fix the problem, but it does make it
     much less likely that you will run into trouble unless you are
     putting a very large number of lines on a given plot.

   A list of ideas for future enhancements is distributed with Octave.
See the file `PROJECTS' in the top level directory in the source
distribution.


File: octave.info,  Node: Reporting Bugs,  Next: Bug Criteria,  Prev: Actual Bugs,  Up: Trouble

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

Your bug reports play an essential role in making Octave reliable.

   When you encounter a problem, the first thing to do is to see if it
is already known.  *Note Trouble::.  If it isn't known, then you should
report the problem.

   Reporting a bug may help you by bringing a solution to your problem,
or it may not.  In any case, the principal function of a bug report is
to help the entire community by making the next version of Octave work
better.  Bug reports are your contribution to the maintenance of Octave.

   In order for a bug report to serve its purpose, you must include the
information that makes it possible to fix the bug.

   If you have Octave working at all, the easiest way to prepare a
complete bug report is to use the Octave function `bug_report'.  When
you execute this function, Octave will prompt you for a subject and then
invoke the editor on a file that already contains all the configuration
information.  When you exit the editor, Octave will mail the bug report
for you.

* Menu:

* Bug Criteria::
* Where: Bug Lists.             Where to send your bug report.
* Reporting: Bug Reporting.     How to report a bug effectively.
* Patches: Sending Patches.     How to send a patch for Octave.


File: octave.info,  Node: Bug Criteria,  Next: Bug Lists,  Prev: Reporting Bugs,  Up: Trouble

Have You Found a Bug?
=====================

If you are not sure whether you have found a bug, here are some
guidelines:

   * If Octave gets a fatal signal, for any input whatever, that is a
     bug.  Reliable interpreters never crash.

   * If Octave produces incorrect results, for any input whatever, that
     is a bug.

   * Some output may appear to be incorrect when it is in fact due to a
     program whose behavior is undefined, which happened by chance to
     give the desired results on another system.  For example, the
     range operator may produce different results because of
     differences in the way floating point arithmetic is handled on
     various systems.

   * If Octave produces an error message for valid input, that is a bug.

   * If Octave does not produce an error message for invalid input,
     that is a bug.  However, you should note that your idea of
     "invalid input" might be my idea of "an extension" or "support for
     traditional practice".

   * If you are an experienced user of programs like Octave, your
     suggestions for improvement are welcome in any case.


File: octave.info,  Node: Bug Lists,  Next: Bug Reporting,  Prev: Bug Criteria,  Up: Trouble

Where to Report Bugs
====================

If you have Octave working at all, the easiest way to prepare a complete
bug report is to use the Octave function `bug_report'.  When you
execute this function, Octave will prompt you for a subject and then
invoke the editor on a file that already contains all the configuration
information.  When you exit the editor, Octave will mail the bug report
for you.

   If for some reason you cannot use Octave's `bug_report' function,
send bug reports for Octave to <bug-octave@bevo.che.wisc.edu>.

   *Do not send bug reports to `help-octave'*.  Most users of Octave do
not want to receive bug reports.  Those that do have asked to be on the
mailing list.

   As a last resort, send bug reports on paper to:

     Octave Bugs c/o John W. Eaton
     University of Wisconsin-Madison
     Department of Chemical Engineering
     1415 Engineering Drive
     Madison, Wisconsin 53706  USA


File: octave.info,  Node: Bug Reporting,  Next: Sending Patches,  Prev: Bug Lists,  Up: Trouble

How to Report Bugs
==================

Send bug reports for Octave to one of the addresses listed in *Note Bug
Lists::.

   The fundamental principle of reporting bugs usefully is this:
*report all the facts*.  If you are not sure whether to state a fact or
leave it out, state it!

   Often people omit facts because they think they know what causes the
problem and they conclude that some details don't matter.  Thus, you
might assume that the name of the variable you use in an example does
not matter.  Well, probably it doesn't, but one cannot be sure.
Perhaps the bug is a stray memory reference which happens to fetch from
the location where that name is stored in memory; perhaps, if the name
were different, the contents of that location would fool the
interpreter into doing the right thing despite the bug.  Play it safe
and give a specific, complete example.

   Keep in mind that the purpose of a bug report is to enable someone to
fix the bug if it is not known. Always write your bug reports on the
assumption that the bug is not known.

   Sometimes people give a few sketchy facts and ask, "Does this ring a
bell?"  This cannot help us fix a bug.  It is better to send a complete
bug report to begin with.

   Try to make your bug report self-contained.  If we have to ask you
for more information, it is best if you include all the previous
information in your response, as well as the information that was
missing.

   To enable someone to investigate the bug, you should include all
these things:

   * The version of Octave.  You can get this by noting the version
     number that is printed when Octave starts, or running it with the
     `-v' option.

   * A complete input file that will reproduce the bug.

     A single statement may not be enough of an example--the bug might
     depend on other details that are missing from the single statement
     where the error finally occurs.

   * The command arguments you gave Octave to execute that example and
     observe the bug.  To guarantee you won't omit something important,
     list all the options.

     If we were to try to guess the arguments, we would probably guess
     wrong and then we would not encounter the bug.

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

   * The command-line arguments you gave to the `configure' command when
     you installed the interpreter.

   * A complete list of any modifications you have made to the
     interpreter source.

     Be precise about these changes--show a context diff for them.

   * Details of any other deviations from the standard procedure for
     installing Octave.

   * A description of what behavior you observe that you believe is
     incorrect.  For example, "The interpreter gets a fatal signal,"
     or, "The output produced at line 208 is incorrect."

     Of course, if the bug is that the interpreter gets a fatal signal,
     then one can't miss it.  But if the bug is incorrect output, we
     might not notice unless it is glaringly wrong.

     Even if the problem you experience is a fatal signal, you should
     still say so explicitly.  Suppose something strange is going on,
     such as, your copy of the interpreter is out of synch, or you have
     encountered a bug in the C library on your system.  Your copy
     might crash and the copy here would not.  If you said to expect a
     crash, then when the interpreter here fails to crash, we would
     know that the bug was not happening.  If you don't say to expect a
     crash, then we would not know whether the bug was happening.  We
     would not be able to draw any conclusion from our observations.

     Often the observed symptom is incorrect output when your program
     is run.  Unfortunately, this is not enough information unless the
     program is short and simple.  It is very helpful if you can
     include an explanation of the expected output, and why the actual
     output is incorrect.

   * If you wish to suggest changes to the Octave source, send them as
     context diffs.  If you even discuss something in the Octave source,
     refer to it by context, not by line number, because the line
     numbers in the development sources probably won't match those in
     your sources.

   Here are some things that are not necessary:

   * A description of the envelope of the bug.

     Often people who encounter a bug spend a lot of time investigating
     which changes to the input file will make the bug go away and
     which changes will not affect it.  Such information is usually not
     necessary to enable us to fix bugs in Octave, but if you can find
     a simpler example to report _instead_ of the original one, that is
     a convenience.  Errors in the output will be easier to spot,
     running under the debugger will take less time, etc. Most Octave
     bugs involve just one function, so the most straightforward way to
     simplify an example is to delete all the function definitions
     except the one in which the bug occurs.

     However, simplification is not vital; if you don't want to do
     this, report the bug anyway and send the entire test case you used.

   * A patch for the bug.  Patches can be helpful, but if you find a
     bug, you should report it, even if you cannot send a fix for the
     problem.


File: octave.info,  Node: Sending Patches,  Next: Service,  Prev: Bug Reporting,  Up: Trouble

Sending Patches for Octave
==========================

If you would like to write bug fixes or improvements for Octave, that is
very helpful.  When you send your changes, please follow these
guidelines to avoid causing extra work for us in studying the patches.

   If you don't follow these guidelines, your information might still be
useful, but using it will take extra work.  Maintaining Octave is a lot
of work in the best of circumstances, and we can't keep up unless you do
your best to help.

   * Send an explanation with your changes of what problem they fix or
     what improvement they bring about.  For a bug fix, just include a
     copy of the bug report, and explain why the change fixes the bug.

   * Always include a proper bug report for the problem you think you
     have fixed.  We need to convince ourselves that the change is
     right before installing it.  Even if it is right, we might have
     trouble judging it if we don't have a way to reproduce the problem.

   * Include all the comments that are appropriate to help people
     reading the source in the future understand why this change was
     needed.

   * Don't mix together changes made for different reasons.  Send them
     _individually_.

     If you make two changes for separate reasons, then we might not
     want to install them both.  We might want to install just one.

   * Use `diff -c' to make your diffs.  Diffs without context are hard
     for us to install reliably.  More than that, they make it hard for
     us to study the diffs to decide whether we want to install them.
     Unidiff format is better than contextless diffs, but not as easy
     to read as `-c' format.

     If you have GNU diff, use `diff -cp', which shows the name of the
     function that each change occurs in.

   * Write the change log entries for your changes.

     Read the `ChangeLog' file to see what sorts of information to put
     in, and to learn the style that we use.  The purpose of the change
     log is to show people where to find what was changed.  So you need
     to be specific about what functions you changed; in large
     functions, it's often helpful to indicate where within the
     function the change was made.

     On the other hand, once you have shown people where to find the
     change, you need not explain its purpose. Thus, if you add a new
     function, all you need to say about it is that it is new.  If you
     feel that the purpose needs explaining, it probably does--but the
     explanation will be much more useful if you put it in comments in
     the code.

     If you would like your name to appear in the header line for who
     made the change, send us the header line.


File: octave.info,  Node: Service,  Prev: Sending Patches,  Up: Trouble

How To Get Help with Octave
===========================

The mailing list <help-octave@bevo.che.wisc.edu> exists for the
discussion of matters related to using and installing Octave.  If would
like to join the discussion, please send a short note to
<help-octave*-request*@bevo.che.wisc.edu>.

   *Please do not* send requests to be added or removed from the
mailing list, or other administrative trivia to the list itself.

   If you think you have found a bug in the installation procedure,
however, you should send a complete bug report for the problem to
<bug-octave@bevo.che.wisc.edu>.  *Note Bug Reporting::, for information
that will help you to submit a useful report.


File: octave.info,  Node: Installation,  Next: Emacs,  Prev: Trouble,  Up: Top

Installing Octave
*****************

   Here is the procedure for installing Octave from scratch on a Unix
system.

   * Run the shell script `configure'.  This will determine the features
     your system has (or doesn't have) and create a file named
     `Makefile' from each of the files named `Makefile.in'.

     Here is a summary of the configure options that are most
     frequently used when building Octave:

    `--prefix=PREFIX'
          Install Octave in subdirectories below PREFIX.  The default
          value of PREFIX is `/usr/local'.

    `--srcdir=DIR'
          Look for Octave sources in the directory DIR.

    `--with-f2c'
          Use `f2c' even if a Fortran compiler is available.

    `--with-f77'
          Use `f77' to compile Fortran code.  You may also specify the
          name of the compiler to use as an optional argument.  For
          example, `--with-f77=g77' sets the name of the Fortran
          compiler to `g77'.

    `--enable-shared'
          Create shared libraries.  If you are planning to use
          `--enable-lite-kernel' or the dynamic loading features, you
          will probably want to use this option.  It will make your
          `.oct' files much smaller and on some systems it may be
          necessary to build shared libraries in order to use
          dynamically linked functions.

          You may also want to build a shared version of `libstdc++',
          if your system doesn't already have one.  Note that a patch
          is needed to build shared versions of version 2.7.2 of
          `libstdc++' on the HP-PA architecture.  You can find the
          patch at
          <ftp://ftp.cygnus.com/pub/g++/libg++-2.7.2-hppa-gcc-fix>.

    `--enable-dl'
          Use `dlopen' and friends to make Octave capable of dynamically
          linking externally compiled functions.  This only works on
          systems that actually have these functions.  If you plan on
          using this feature, you should probably also use
          `--enable-shared' to reduce the size of your `.oct' files.

    `--enable-shl'
          Use `shl_load' and friends to make Octave capable of
          dynamically linking externally compiled functions.  This only
          works on systems that actually have these functions (only
          HP-UX systems).  If you plan on using this feature, you
          should probably also use `--enable-shared' to reduce the size
          of your `.oct' files.

    `--enable-lite-kernel'
          Compile smaller kernel.  This currently requires the dynamic
          linking functions `dlopen' or `shl_load' and friends so that
          Octave can load functions at run time that are not loaded at
          compile time.

    `--without-blas'
          Compile and use the generic BLAS and LAPACK versions included
          with Octave.  By default, configure first looks for BLAS and
          LAPACK matrix libraries on your system, including optimized
          BLAS implementations such as the free ATLAS 3.0, as well as
          vendor-tuned libraries.  (The use of an optimized BLAS will
          generally result in several-times faster matrix operations.)
          Only use this option if your system has BLAS/LAPACK libraries
          that cause problems for some reason.  You can also use
          `--with-blas=lib' to specify a particular BLAS library
          `-llib' that configure doesn't check for automatically.

    `--help'
          Print a summary of the options recognized by the configure
          script.

     See the file `INSTALL' for more information about the command line
     options used by configure.  That file also contains instructions
     for compiling in a directory other than where the source is
     located.

   * Run make.

     You will need a recent version of GNU Make.  Modifying Octave's
     makefiles to work with other make programs is probably not worth
     your time.  We recommend you get and compile GNU Make instead.

     For plotting, you will need to have gnuplot installed on your
     system.  Gnuplot is a command-driven interactive function plotting
     program.  Gnuplot is copyrighted, but freely distributable.  The
     `gnu' in gnuplot is a coincidence--it is not related to the GNU
     project or the FSF in any but the most peripheral sense.

     To compile Octave, you will need a recent version of GNU Make.  You
     will also need `g++' 2.7.2 or later.  Version 2.8.0 or `egcs'
     1.0.x should work.  Later versions may work, but C++ is still
     evolving, so don't be too surprised if you run into some trouble.

     It is no longer necessary to have `libg++', but you do need to have
     the GNU implementation of `libstdc++'.  If you are using `g++'
     2.7.2, `libstdc++' is distributed along with `libg++', but for
     later versions, `libstdc++' is distributed separately.  For
     `egcs', `libstdc++' is included with the compiler distribution.

     If you plan to modify the parser you will also need GNU `bison' and
     `flex'.  If you modify the documentation, you will need GNU
     Texinfo, along with the patch for the `makeinfo' program that is
     distributed with Octave.

     GNU Make, `gcc', and `libstdc++', `gnuplot', `bison', `flex', and
     Texinfo are all available from many anonymous ftp archives.  The
     primary site is <ftp.gnu.org>, but it is often very busy.  A list
     of sites that mirror the software on <ftp.gnu.org> is available by
     anonymous ftp from <ftp://ftp.gnu.org/pub/gnu/GNUinfo/FTP>.

     If you don't have a Fortran compiler, or if your Fortran compiler
     doesn't work like the traditional Unix f77, you will need to have
     the Fortran to C translator `f2c'.  You can get `f2c' from any
     number of anonymous ftp archives.  The most recent version of `f2c'
     is always available from <netlib.att.com>.

     On an otherwise idle Pentium 133 running Linux, it will take
     somewhere between 1-1/2 to 3 hours to compile everything,
     depending on whether you are building shared libraries.  You will
     need about 100 megabytes of disk storage to work with
     (considerably less if you don't compile with debugging symbols).
     To do that, use the command

          make CFLAGS=-O CXXFLAGS=-O LDFLAGS=

     instead of just `make'.

   * If you encounter errors while compiling Octave, first check the
     list of known problems below to see if there is a workaround or
     solution for your problem.  If not, see *Note Trouble::, for
     information about how to report bugs.

   * Once you have successfully compiled Octave, run `make install'.

     This will install a copy of octave, its libraries, and its
     documentation in the destination directory.  As distributed,
     Octave is installed in the following directories.  In the table
     below, PREFIX defaults to `/usr/local', VERSION stands for the
     current version number of the interpreter, and ARCH is the type of
     computer on which Octave is installed (for example,
     `i586-unknown-gnu').

    `PREFIX/bin'
          Octave and other binaries that people will want to run
          directly.

    `PREFIX/lib'
          Libraries like libcruft.a and liboctave.a.

    `PREFIX/share'
          Architecture-independent data files.

    `PREFIX/include/octave'
          Include files distributed with Octave.

    `PREFIX/man/man1'
          Unix-style man pages describing Octave.

    `PREFIX/info'
          Info files describing Octave.

    `PREFIX/share/octave/VERSION/m'
          Function files distributed with Octave.  This includes the
          Octave version, so that multiple versions of Octave may be
          installed at the same time.

    `PREFIX/lib/octave/VERSION/exec/ARCH'
          Executables to be run by Octave rather than the user.

    `PREFIX/lib/octave/VERSION/oct/ARCH'
          Object files that will be dynamically loaded.

    `PREFIX/share/octave/VERSION/imagelib'
          Image files that are distributed with Octave.

* Menu:

* Installation Problems::


File: octave.info,  Node: Installation Problems,  Up: Installation

Installation Problems
=====================

This section contains a list of problems (and some apparent problems
that don't really mean anything is wrong) that may show up during
installation of Octave.

   * On some SCO systems, `info' fails to compile if `HAVE_TERMIOS_H'
     is defined int `config.h'.  Simply removing the definition from
     `info/config.h' should allow it to compile.

   * If `configure' finds `dlopen', `dlsym', `dlclose', and `dlerror',
     but not the header file `dlfcn.h', you need to find the source for
     the header file and install it in the directory `usr/include'.
     This is reportedly a problem with Slackware 3.1.  For Linux/GNU
     systems, the source for `dlfcn.h' is in the `ldso' package.

   * Building `.oct' files doesn't work.

     You should probably have a shared version of `libstdc++'.  A patch
     is needed to build shared versions of version 2.7.2 of `libstdc++'
     on the HP-PA architecture.  You can find the patch at
     <ftp://ftp.cygnus.com/pub/g++/libg++-2.7.2-hppa-gcc-fix>.

   * On some alpha systems there may be a problem with the `libdxml'
     library, resulting in floating point errors and/or segmentation
     faults in the linear algebra routines called by Octave.  If you
     encounter such problems, then you should modify the configure
     script so that `SPECIAL_MATH_LIB' is not set to `-ldxml'.

   * On FreeBSD systems Octave may hang while initializing some internal
     constants.  The fix appears to be to use

          options      GPL_MATH_EMULATE

     rather than

          options      MATH_EMULATE

     in the kernel configuration files (typically found in the directory
     `/sys/i386/conf'.  After making this change, you'll need to rebuild
     the kernel, install it, and reboot.

   * If you encounter errors like

          passing `void (*)()' as argument 2 of
            `octave_set_signal_handler(int, void (*)(int))'

     or

          warning: ANSI C++ prohibits conversion from `(int)' to `(...)'

     while compiling `sighandlers.cc', you may need to edit some files
     in the `gcc' include subdirectory to add proper prototypes for
     functions there.  For example, Ultrix 4.2 needs proper
     declarations for the `signal' function and the `SIG_IGN' macro in
     the file `signal.h'.

     On some systems the `SIG_IGN' macro is defined to be something like
     this:

          #define  SIG_IGN  (void (*)())1

     when it should really be something like:

          #define  SIG_IGN  (void (*)(int))1

     to match the prototype declaration for the `signal' function.  This
     change should also be made for the `SIG_DFL' and `SIG_ERR'
     symbols. It may be necessary to change the definitions in
     `sys/signal.h' as well.

     The `gcc' `fixincludes' and `fixproto' scripts should probably fix
     these problems when `gcc' installs its modified set of header
     files, but I don't think that's been done yet.

     *You should not change the files in `/usr/include'*.  You can find
     the `gcc' include directory tree by running the command

          gcc -print-libgcc-file-name

     The directory of `gcc' include files normally begins in the same
     directory that contains the file `libgcc.a'.

   * Some of the Fortran subroutines may fail to compile with older
     versions of the Sun Fortran compiler.  If you get errors like

          zgemm.f:
          	zgemm:
          warning: unexpected parent of complex expression subtree
          zgemm.f, line 245: warning: unexpected parent of complex
            expression subtree
          warning: unexpected parent of complex expression subtree
          zgemm.f, line 304: warning: unexpected parent of complex
            expression subtree
          warning: unexpected parent of complex expression subtree
          zgemm.f, line 327: warning: unexpected parent of complex
            expression subtree
          pcc_binval: missing IR_CONV in complex op
          make[2]: *** [zgemm.o] Error 1

     when compiling the Fortran subroutines in the `libcruft'
     subdirectory, you should either upgrade your compiler or try
     compiling with optimization turned off.

   * On NeXT systems, if you get errors like this:

          /usr/tmp/cc007458.s:unknown:Undefined local symbol LBB7656
          /usr/tmp/cc007458.s:unknown:Undefined local symbol LBE7656

     when compiling `Array.cc' and `Matrix.cc', try recompiling these
     files without `-g'.

   * Some people have reported that calls to shell_cmd and the pager do
     not work on SunOS systems.  This is apparently due to having
     `G_HAVE_SYS_WAIT' defined to be 0 instead of 1 when compiling
     `libg++'.

   * On NeXT systems, linking to `libsys_s.a' may fail to resolve the
     following functions

          _tcgetattr
          _tcsetattr
          _tcflow

     which are part of `libposix.a'.  Unfortunately, linking Octave with
     `-posix' results in the following undefined symbols.

          .destructors_used
          .constructors_used
          _objc_msgSend
          _NXGetDefaultValue
          _NXRegisterDefaults
          .objc_class_name_NXStringTable
          .objc_class_name_NXBundle

     One kluge around this problem is to extract `termios.o' from
     `libposix.a', put it in Octave's `src' directory, and add it to
     the list of files to link together in the makefile.  Suggestions
     for better ways to solve this problem are welcome!

   * If Octave crashes immediately with a floating point exception, it
     is likely that it is failing to initialize the IEEE floating point
     values for infinity and NaN.

     If your system actually does support IEEE arithmetic, you should
     be able to fix this problem by modifying the function
     `octave_ieee_init' in the file `lo-ieee.cc' to correctly
     initialize Octave's internal infinity and NaN variables.

     If your system does not support IEEE arithmetic but Octave's
     configure script incorrectly determined that it does, you can work
     around the problem by editing the file `config.h' to not define
     `HAVE_ISINF', `HAVE_FINITE', and `HAVE_ISNAN'.

     In any case, please report this as a bug since it might be
     possible to modify Octave's configuration script to automatically
     determine the proper thing to do.

   * After installing the binary distribution of Octave in an alternate
     directory, the Emacs command `run-octave' doesn't work.  Emacs
     hangs in `accept-process-output' in `inferior-octave-startup'.

     This seems to be a problem with executing a shell script using the
     comint package.  You can avoid the problem by changing the way
     Octave is installed to eliminate the need for the shell script.
     You can either compile and install Octave using the source
     distribution, reinstall the binary distribution in the default
     directory, or copy the commands in the octave shell script wrapper
     to your shell startup files (and the shell startup files for
     anyone else who is using Octave) and then rename the file
     `octave.bin' to be `octave'.


File: octave.info,  Node: Emacs,  Next: Grammar,  Prev: Installation,  Up: Top

Emacs Octave Support
********************

The development of Octave code can greatly be facilitated using Emacs
with Octave mode, a major mode for editing Octave files which can e.g.
automatically indent the code, do some of the typing (with Abbrev mode)
and show keywords, comments, strings, etc. in different faces (with
Font-lock mode on devices that support it).

   It is also possible to run Octave from within Emacs, either by
directly entering commands at the prompt in a buffer in Inferior Octave
mode, or by interacting with Octave from within a file with Octave
code.  This is useful in particular for debugging Octave code.

   Finally, you can convince Octave to use the Emacs info reader for
`help -i'.

   All functionality is provided by the Emacs Lisp package EOS (for
"Emacs Octave Support").  This chapter describes how to set up and use
this package.

   Please contact <Kurt.Hornik@ci.tuwien.ac.at> if you have any
questions or suggestions on using EOS.

* Menu:

* Installing EOS::
* Using Octave Mode::
* Running Octave From Within Emacs::
* Using the Emacs Info Reader for Octave::


File: octave.info,  Node: Installing EOS,  Next: Using Octave Mode,  Up: Emacs

Installing EOS
==============

The Emacs package EOS consists of the three files `octave-mod.el',
`octave-inf.el', and `octave-hlp.el'.  These files, or better yet their
byte-compiled versions, should be somewhere in your Emacs load-path.

   If you have GNU Emacs with a version number at least as high as
19.35, you are all set up, because EOS is respectively will be part of
GNU Emacs as of version 19.35.

   Otherwise, copy the three files from the `emacs' subdirectory of the
Octave distribution to a place where Emacs can find them (this depends
on how your Emacs was installed).  Byte-compile them for speed if you
want.


File: octave.info,  Node: Using Octave Mode,  Next: Running Octave From Within Emacs,  Prev: Installing EOS,  Up: Emacs

Using Octave Mode
=================

If you are lucky, your sysadmins have already arranged everything so
that Emacs automatically goes into Octave mode whenever you visit an
Octave code file as characterized by its extension `.m'.  If not,
proceed as follows.

  1. To begin using Octave mode for all `.m' files you visit, add the
     following lines to a file loaded by Emacs at startup time,
     typically your `~/.emacs' file:

          (autoload 'octave-mode "octave-mod" nil t)
          (setq auto-mode-alist
                (cons '("\\.m$" . octave-mode) auto-mode-alist))

  2. Finally, to turn on the abbrevs, auto-fill and font-lock features
     automatically, also add the following lines to one of the Emacs
     startup files:
          (add-hook 'octave-mode-hook
                    (lambda ()
                      (abbrev-mode 1)
                      (auto-fill-mode 1)
                      (if (eq window-system 'x)
                          (font-lock-mode 1))))
     See the Emacs manual for more information about how to customize
     Font-lock mode.

   In Octave mode, the following special Emacs commands can be used in
addition to the standard Emacs commands.

`C-h m'
     Describe the features of Octave mode.

`LFD'
     Reindent the current Octave line, insert a newline and indent the
     new line (`octave-reindent-then-newline-and-indent').  An abbrev
     before point is expanded if `abbrev-mode' is non-`nil'.

`TAB'
     Indents current Octave line based on its contents and on previous
     lines (`indent-according-to-mode').

`;'
     Insert an "electric" semicolon (`octave-electric-semi').  If
     `octave-auto-indent' is non-`nil', reindent the current line.  If
     `octave-auto-newline' is non-`nil', automagically insert a newline
     and indent the new line.

``'
     Start entering an abbreviation (`octave-abbrev-start').  If Abbrev
     mode is turned on, typing ``C-h' or ``?' lists all abbrevs.  Any
     other key combination is executed normally.  Note that all Octave
     abbrevs start with a grave accent.

`M-LFD'
     Break line at point and insert continuation marker and alignment
     (`octave-split-line').

`M-TAB'
     Perform completion on Octave symbol preceding point, comparing that
     symbol against Octave's reserved words and builtin variables
     (`octave-complete-symbol').

`M-C-a'
     Move backward to the beginning of a function
     (`octave-beginning-of-defun').  With prefix argument N, do it that
     many times if N is positive;  otherwise, move forward to the N-th
     following beginning of a function.

`M-C-e'
     Move forward to the end of a function (`octave-end-of-defun').
     With prefix argument N, do it that many times if N is positive;
     otherwise, move back to the N-th preceding end of a function.

`M-C-h'
     Puts point at beginning and mark at the end of the current Octave
     function, i.e., the one containing point or following point
     (`octave-mark-defun').

`M-C-q'
     Properly indents the Octave function which contains point
     (`octave-indent-defun').

`M-;'
     If there is no comment already on this line, create a code-level
     comment (started by two comment characters) if the line is empty,
     or an in-line comment (started by one comment character) otherwise
     (`octave-indent-for-comment').  Point is left after the start of
     the comment which is properly aligned.

`C-c ;'
     Puts the comment character `#' (more precisely, the string value of
     `octave-comment-start') at the beginning of every line in the
     region (`octave-comment-region').  With just `C-u' prefix
     argument, uncomment each line in the region.  A numeric prefix
     argument N means use N comment characters.

`C-c :'
     Uncomments every line in the region (`octave-uncomment-region').

`C-c C-p'
     Move one line of Octave code backward, skipping empty and comment
     lines (`octave-previous-code-line').  With numeric prefix argument
     N, move that many code lines backward (forward if N is negative).

`C-c C-n'
     Move one line of Octave code forward, skipping empty and comment
     lines (`octave-next-code-line').  With numeric prefix argument N,
     move that many code lines forward (backward if N is negative).

`C-c C-a'
     Move to the `real' beginning of the current line
     (`octave-beginning-of-line').  If point is in an empty or comment
     line, simply go to its beginning;  otherwise, move backwards to the
     beginning of the first code line which is not inside a continuation
     statement,  i.e., which does not follow a code line ending in `...'
     or `\', or is inside an open parenthesis list.

`C-c C-e'
     Move to the `real' end of the current line (`octave-end-of-line').
     If point is in a code line, move forward to the end of the first
     Octave code line which does not end in `...' or `\' or is inside an
     open parenthesis list.  Otherwise, simply go to the end of the
     current line.

`C-c M-C-n'
     Move forward across one balanced begin-end block of Octave code
     (`octave-forward-block').  With numeric prefix argument N, move
     forward across N such blocks (backward if N is negative).

`C-c M-C-p'
     Move back across one balanced begin-end block of Octave code
     (`octave-backward-block').  With numeric prefix argument N, move
     backward across N such blocks (forward if N is negative).

`C-c M-C-d'
     Move forward down one begin-end block level of Octave code
     (`octave-down-block').  With numeric prefix argument, do it that
     many times;  a negative argument means move backward, but still go
     down one level.

`C-c M-C-u'
     Move backward out of one begin-end block level of Octave code
     (`octave-backward-up-block').  With numeric prefix argument, do it
     that many times; a negative argument means move forward, but still
     to a less deep spot.

`C-c M-C-h'
     Put point at the beginning of this block, mark at the end
     (`octave-mark-block').  The block marked is the one that contains
     point or follows point.

`C-c ]'
     Close the current block on a separate line (`octave-close-block').
     An error is signaled if no block to close is found.

`C-c f'
     Insert a function skeleton, prompting for the function's name,
     arguments and return values which have to be entered without parens
     (`octave-insert-defun').

`C-c C-h'
     Search the function, operator and variable indices of all info
     files with documentation for Octave for entries (`octave-help').
     If used interactively, the entry is prompted for with completion.
     If multiple matches are found, one can cycle through them using
     the standard `,' (`Info-index-next') command of the Info reader.

     The variable `octave-help-files' is a list of files to search
     through and defaults to `'("octave")'.  If there is also an Octave
     Local Guide with corresponding info file, say, `octave-LG', you can
     have `octave-help' search both files by
          (setq octave-help-files '("octave" "octave-LG"))

     in one of your Emacs startup files.


   A common problem is that the <RET> key does _not_ indent the line to
where the new text should go after inserting the newline.  This is
because the standard Emacs convention is that <RET> (aka `C-m') just
adds a newline, whereas <LFD> (aka `C-j') adds a newline and indents
it.  This is particularly inconvenient for users with keyboards which
do not have a special <LFD> key at all;  in such cases, it is typically
more convenient to use <RET> as the <LFD> key (rather than typing
`C-j').

   You can make <RET> do this by adding
     (define-key octave-mode-map "\C-m"
       'octave-reindent-then-newline-and-indent)

to one of your Emacs startup files.  Another, more generally applicable
solution is
     (defun RET-behaves-as-LFD ()
       (let ((x (key-binding "\C-j")))
         (local-set-key "\C-m" x)))
     (add-hook 'octave-mode-hook 'RET-behaves-as-LFD)

(this works for all modes by adding to the startup hooks, without having
to know the particular binding of <RET> in that mode!).  Similar
considerations apply for using <M-RET> as <M-LFD>.  As Barry A. Warsaw
<bwarsaw@cnri.reston.va.us> says in the documentation for his
`cc-mode', "This is a very common question. `:-)' If you want this to
be the default behavior, don't lobby me, lobby RMS!"

   The following variables can be used to customize Octave mode.

`octave-auto-indent'
     Non-`nil' means auto-indent the current line after a semicolon or
     space.  Default is `nil'.

`octave-auto-newline'
     Non-`nil' means auto-insert a newline and indent after semicolons
     are typed.  The default value is `nil'.

`octave-blink-matching-block'
     Non-`nil' means show matching begin of block when inserting a
     space, newline or `;' after an else or end keyword.  Default is
     `t'.  This is an extremely useful feature for automatically
     verifying that the keywords match--if they don't, an error message
     is displayed.

`octave-block-offset'
     Extra indentation applied to statements in block structures.
     Default is 2.

`octave-continuation-offset'
     Extra indentation applied to Octave continuation lines.  Default
     is 4.

`octave-continuation-string'
     String used for Octave continuation lines.  Normally `\'.

`octave-mode-startup-message'
     If `t' (default), a startup message is displayed when Octave mode
     is called.


   If Font Lock mode is enabled, Octave mode will display
   * strings in `font-lock-string-face'

   * comments in `font-lock-comment-face'

   * the Octave reserved words (such as all block keywords) and the text
     functions (such as `cd' or `who') which are also reserved using
     `font-lock-keyword-face'

   * the builtin operators (`&&', `<>', ...) using
     `font-lock-reference-face'

   * the builtin variables (such as `warn_fortran_indexing', `NaN' or
     `LOADPATH') in `font-lock-variable-name-face'

   * and the function names in function declarations in
     `font-lock-function-name-face'.

   There is also rudimentary support for Imenu (currently, function
names can be indexed).

   You can generate TAGS files for Emacs from Octave `.m' files using
the shell script `otags' that is installed alongside your copy of
Octave.

   Customization of Octave mode can be performed by modification of the
variable `octave-mode-hook'.  If the value of this variable is
non-`nil', turning on Octave mode calls its value.

   If you discover a problem with Octave mode, you can conveniently
send a bug report using `C-c C-b' (`octave-submit-bug-report').  This
automatically sets up a mail buffer with version information already
added.  You just need to add a description of the problem, including a
reproducible test case and send the message.


File: octave.info,  Node: Running Octave From Within Emacs,  Next: Using the Emacs Info Reader for Octave,  Prev: Using Octave Mode,  Up: Emacs

Running Octave From Within Emacs
================================

The package `octave' provides commands for running an inferior Octave
process in a special Emacs buffer.  Use
     M-x run-octave

to directly start an inferior Octave process.  If Emacs does not know
about this command, add the line
     (autoload 'run-octave "octave-inf" nil t)

to your `.emacs' file.

   This will start Octave in a special buffer the name of which is
specified by the variable `inferior-octave-buffer' and defaults to
`"*Inferior Octave*"'.  From within this buffer, you can interact with
the inferior Octave process `as usual', i.e., by entering Octave
commands at the prompt.  The buffer is in Inferior Octave mode, which
is derived from the standard Comint mode, a major mode for interacting
with an inferior interpreter.  See the documentation for `comint-mode'
for more details, and use `C-h b' to find out about available special
keybindings.

   You can also communicate with an inferior Octave process from within
files with Octave code (i.e., buffers in Octave mode), using the
following commands.

`C-c i l'
     Send the current line to the inferior Octave process
     (`octave-send-line').  With positive prefix argument N, send that
     many lines.  If `octave-send-line-auto-forward' is non-`nil', go
     to the next unsent code line.

`C-c i b'
     Send the current block to the inferior Octave process
     (`octave-send-block').

`C-c i f'
     Send the current function to the inferior Octave process
     (`octave-send-defun').

`C-c i r'
     Send the region to the inferior Octave process
     (`octave-send-region').

`C-c i s'
     Make sure that `inferior-octave-buffer' is displayed
     (`octave-show-process-buffer').

`C-c i h'
     Delete all windows that display the inferior Octave buffer
     (`octave-hide-process-buffer').

`C-c i k'
     Kill the inferior Octave process and its buffer
     (`octave-kill-process').

   The effect of the commands which send code to the Octave process can
be customized by the following variables.
`octave-send-echo-input'
     Non-`nil' means echo input sent to the inferior Octave process.
     Default is `t'.

`octave-send-show-buffer'
     Non-`nil' means display the buffer running the Octave process after
     sending a command (but without selecting it).  Default is `t'.

   If you send code and there is no inferior Octave process yet, it
will be started automatically.

   The startup of the inferior Octave process is highly customizable.
The variable `inferior-octave-startup-args' can be used for specifying
command lines arguments to be passed to Octave on startup as a list of
strings.  For example, to suppress the startup message and use
`traditional' mode, set this to `'("-q" "--traditional")'.  You can
also specify a startup file of Octave commands to be loaded on startup;
note that these commands will not produce any visible output in the
process buffer.  Which file to use is controlled by the variable
`inferior-octave-startup-file'.  If this is `nil', the file
`~/.emacs-octave' is used if it exists.

   And finally, `inferior-octave-mode-hook' is run after starting the
process and putting its buffer into Inferior Octave mode.  Hence, if you
like the up and down arrow keys to behave in the interaction buffer as
in the shell, and you want this buffer to use nice colors, add
     (add-hook 'inferior-octave-mode-hook
               (lambda ()
                 (turn-on-font-lock)
                 (define-key inferior-octave-mode-map [up]
                   'comint-previous-input)
                 (define-key inferior-octave-mode-map [down]
                   'comint-next-input)))

to your `.emacs' file.  You could also swap the roles of `C-a'
(`beginning-of-line') and `C-c C-a' (`comint-bol') using this hook.

     *Note:* If you set your Octave prompts to something different from
     the defaults, make sure that `inferior-octave-prompt' matches them.
     Otherwise, _nothing_ will work, because Emacs will have no idea
     when Octave is waiting for input, or done sending output.


File: octave.info,  Node: Using the Emacs Info Reader for Octave,  Prev: Running Octave From Within Emacs,  Up: Emacs

Using the Emacs Info Reader for Octave
======================================

You can also set up the Emacs Info reader for dealing with the results
of Octave's `help -i'.  For this, the package `gnuserv' needs to be
installed, which unfortunately still does not come with GNU Emacs (it
does with XEmacs).  It can be retrieved from any GNU Emacs Lisp Code
Directory archive, e.g.
<ftp://ftp.cis.ohio-state.edu/pub/gnu/emacs/elisp-archive>, in the
`packages' subdirectory.  A recent version of gnuserv is available from
<http://www.meltin.net/hacks/emacs/src/gnuserv-3.12.2.tar.gz>.

   If `gnuserv' is installed, add the lines
     (autoload 'octave-help "octave-hlp" nil t)
     (require 'gnuserv)
     (gnuserv-start)

to your `.emacs' file.

   You can use either `plain' Emacs Info or the function `octave-help'
as your Octave info reader (for `help -i').  In the former case, set
the Octave variable `INFO_PROGRAM' to `"info-emacs-info"'.  The latter
is perhaps more attractive because it allows to look up keys in the
indices of _several_ info files related to Octave (provided that the
Emacs variable `octave-help-files' is set correctly).  In this case,
set `INFO_PROGRAM' to `"info-emacs-octave-help"'.

   If you use Octave from within Emacs, these settings are best done in
the `~/.emacs-octave' startup file (or the file pointed to by the Emacs
variable `inferior-octave-startup-file').


File: octave.info,  Node: Grammar,  Next: Copying,  Prev: Emacs,  Up: Top

Grammar
*******

Someday I hope to expand this to include a semi-formal description of
Octave's language.

* Menu:

* Keywords::


File: octave.info,  Node: Keywords,  Up: Grammar

Keywords
========

The following identifiers are keywords, and may not be used as variable
or function names:

     all_va_args             endwhile
     break                   for
     case                    function
     catch                   global
     continue                gplot
     else                    gsplot
     elseif                  if
     end                     otherwise
     end_try_catch           return
     end_unwind_protect      switch
     endfor                  try
     endfunction             unwind_protect
     endif                   unwind_protect_cleanup
     endswitch               while

   The following command-like functions are also speical.  They may be
used as simple variable names, but not as formal parameters for
functions, or as the names of structure variables.  Failed assignments
leave them undefined (you can recover the orginal definition as a
function using clear).

     casesen       echo          load          show
     cd            edit_history  ls            type
     chdir         format        more          which
     clear         help          run_history   who
     diary         history       save          whos
     dir           hold          set


File: octave.info,  Node: Copying,  Next: Concept Index,  Prev: Grammar,  Up: Top

GNU GENERAL PUBLIC LICENSE
**************************

                         Version 2, June 1991
     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
     
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

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.

    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. 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.

  1. 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.

  2. 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:

       a. You must cause the modified files to carry prominent notices
          stating that you changed the files and the date of any change.

       b. 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.

       c. 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.)

     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.

  3. 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:

       a. 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,

       b. 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,

       c. 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.)

     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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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.

  9. 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.

 10. 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.

                                NO WARRANTY

 11. 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.

 12. 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 OF TERMS AND CONDITIONS

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.

     ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES.
     Copyright (C) 19YY  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., 59 Temple Place - Suite 330, Boston, MA
     02111-1307, USA.

   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:

     Gnomovision version 69, Copyright (C) 19YY 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.

   The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than `show w' and `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:

     Yoyodyne, Inc., hereby disclaims all copyright interest in the program
     `Gnomovision' (which makes passes at compilers) written by James Hacker.
     
     SIGNATURE OF TY COON, 1 April 1989
     Ty Coon, President of Vice

   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.


File: octave.info,  Node: Concept Index,  Next: Variable Index,  Prev: Copying,  Up: Top

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

* Menu:

* #:                                     Comments.
* #!:                                    Executable Octave Programs.
* %:                                     Comments.
* --braindead:                           Command Line Options.
* --debug:                               Command Line Options.
* --echo-commands:                       Command Line Options.
* --exec-path PATH:                      Command Line Options.
* --help:                                Command Line Options.
* --info-file FILENAME:                  Command Line Options.
* --info-program PROGRAM:                Command Line Options.
* --interactive:                         Command Line Options.
* --no-init-file:                        Command Line Options.
* --no-line-editing:                     Command Line Options.
* --no-site-file:                        Command Line Options.
* --norc:                                Command Line Options.
* --path PATH:                           Command Line Options.
* --quiet:                               Command Line Options.
* --silent:                              Command Line Options.
* --traditional:                         Command Line Options.
* --verbose:                             Command Line Options.
* --version:                             Command Line Options.
* -?:                                    Command Line Options.
* -d:                                    Command Line Options.
* -f:                                    Command Line Options.
* -h:                                    Command Line Options.
* -i:                                    Command Line Options.
* -p PATH:                               Command Line Options.
* -q:                                    Command Line Options.
* -v:                                    Command Line Options.
* -V:                                    Command Line Options.
* -x:                                    Command Line Options.
* ... <1>:                               Variable-length Return Lists.
* ...:                                   Variable-length Argument Lists.
* ... continuation marker:               The try Statement.
* .octaverc:                             Startup Files.
* \ continuation marker:                 The try Statement.
* acknowledgements:                      Acknowledgements.
* addition:                              Arithmetic Ops.
* and operator:                          Boolean Expressions.
* answers, incorrect <1>:                Bug Reporting.
* answers, incorrect:                    Bug Criteria.
* any key:                               Fonts.
* arguments in function call:            Calling Functions.
* arithmetic operators:                  Arithmetic Ops.
* assignment expressions:                Assignment Ops.
* assignment operators:                  Assignment Ops.
* body of a loop:                        The while Statement.
* boolean expressions:                   Boolean Expressions.
* boolean operators:                     Boolean Expressions.
* break statement:                       The break Statement.
* bug criteria:                          Bug Criteria.
* bug report mailing lists:              Bug Lists.
* bugs:                                  Reporting Bugs.
* bugs, investigating:                   Bug Reporting.
* bugs, known:                           Trouble.
* bugs, reporting <1>:                   Bug Reporting.
* bugs, reporting:                       Bug Lists.
* built-in data types:                   Built-in Data Types.
* built-in function:                     A Sample Function Description.
* case statement:                        The switch Statement.
* catch:                                 The try Statement.
* cell arrays:                           Cell Arrays.
* character strings <1>:                 Strings.
* character strings:                     String Objects.
* Cholesky factorization:                Matrix Factorizations.
* clearing the screen:                   Cursor Motion.
* coding standards:                      Tips.
* command and ouput logs:                Diary and Echo Commands.
* command completion:                    Commands For Completion.
* command descriptions:                  A Sample Command Description.
* command echoing:                       Diary and Echo Commands.
* command history:                       Commands For History.
* command options:                       Command Line Options.
* command-line editing:                  Command Line Editing.
* comments:                              Comments.
* comparison expressions:                Comparison Ops.
* complex-conjugate transpose:           Arithmetic Ops.
* compounding, value of:                 Financial Functions.
* containers:                            Containers.
* continuation lines:                    The try Statement.
* continue statement:                    The continue Statement.
* contributing to Octave:                How You Can Contribute to Octave.
* contributors:                          Preface.
* conversion specifications (printf):    Formatted Output.
* conversion specifications (scanf):     Formatted Input.
* copyright:                             Keywords.
* core dump:                             Bug Criteria.
* customizing the prompt:                Customizing the Prompt.
* DAE:                                   Differential Equations.
* data structures <1>:                   Data Structures.
* data structures:                       Data Structure Objects.
* data types:                            Data Types.
* data types, built-in:                  Built-in Data Types.
* data types, user-defined:              User-defined Data Types.
* decrement operator:                    Assignment Ops.
* defining functions:                    Functions and Scripts.
* description format:                    Format of Descriptions.
* diary of commands and output:          Diary and Echo Commands.
* Differential Equations:                Differential Equations.
* diffs, submitting:                     Sending Patches.
* distribution of Octave:                Distribution.
* division:                              Arithmetic Ops.
* do-until statement:                    The do-until Statement.
* documentation notation:                Evaluation Notation.
* documenting Octave programs:           Comments.
* dynamic linking:                       Dynamically Linked Functions.
* echoing executing commands:            Diary and Echo Commands.
* editing the command line:              Command Line Editing.
* element-by-element evaluation:         Element-by-element Boolean Operators.
* else statement:                        The if Statement.
* elseif statement:                      The if Statement.
* Emacs TAGS files:                      Using Octave Mode.
* end statement:                         Statements.
* end_try_catch:                         The try Statement.
* end_unwind_protect:                    The unwind_protect Statement.
* endfor statement:                      The for Statement.
* endfunction statement:                 Defining Functions.
* endif statement:                       The if Statement.
* endswitch statement:                   The switch Statement.
* endwhile statement:                    The while Statement.
* equality operator:                     Comparison Ops.
* equality, tests for:                   Comparison Ops.
* equations, nonlinear:                  Nonlinear Equations.
* erroneous messages:                    Bug Criteria.
* erroneous results <1>:                 Bug Reporting.
* erroneous results:                     Bug Criteria.
* error message notation:                Error Messages.
* error messages:                        Errors.
* error messages, incorrect:             Bug Criteria.
* escape sequence notation:              Strings.
* evaluation notation:                   Evaluation Notation.
* executable scripts:                    Executable Octave Programs.
* execution speed:                       Coding Tips.
* exiting octave <1>:                    Quitting Octave.
* exiting octave:                        Running Octave.
* exponentiation:                        Arithmetic Ops.
* expression, range:                     Ranges.
* expressions:                           Expressions.
* expressions, assignment:               Assignment Ops.
* expressions, boolean:                  Boolean Expressions.
* expressions, comparison:               Comparison Ops.
* expressions, logical:                  Boolean Expressions.
* factorial function:                    Recursion.
* fatal signal:                          Bug Criteria.
* financial functions:                   Financial Functions.
* flag character (printf):               Output Conversion Syntax.
* flag character (scanf):                Input Conversion Syntax.
* flying high and fast:                  Variables.
* fonts:                                 Fonts.
* for statement:                         The for Statement.
* Fordyce, A. P.:                        Evaluation.
* Frobenius norm:                        Basic Matrix Functions.
* function descriptions:                 A Sample Function Description.
* function file <1>:                     Function Files.
* function file:                         A Sample Function Description.
* function statement:                    Defining Functions.
* functions, user-defined:               Functions and Scripts.
* funding Octave development:            How You Can Contribute to Octave.
* getting a good job:                    Variables.
* global statement:                      Global Variables.
* global variables:                      Global Variables.
* grammar rules:                         Grammar.
* graphics:                              Two-Dimensional Plotting.
* greater than operator:                 Comparison Ops.
* handle, function handles:              Function Handles and Inline.
* header comments:                       Function Headers.
* help, on-line:                         Getting Help.
* help, where to find:                   Service.
* Hermitian operator:                    Arithmetic Ops.
* Hessenberg decomposition:              Matrix Factorizations.
* history:                               Preface.
* history of commands:                   Commands For History.
* if statement:                          The if Statement.
* improving Octave <1>:                  Sending Patches.
* improving Octave:                      Bug Criteria.
* incorrect error messages:              Bug Criteria.
* incorrect output <1>:                  Bug Reporting.
* incorrect output:                      Bug Criteria.
* incorrect results <1>:                 Bug Reporting.
* incorrect results:                     Bug Criteria.
* increment operator:                    Assignment Ops.
* infinity norm:                         Basic Matrix Functions.
* initialization:                        Startup Files.
* inline, inline functions:              Function Handles and Inline.
* input conversions, for scanf:          Table of Input Conversions.
* input history:                         Commands For History.
* installation trouble:                  Trouble.
* installing Octave:                     Installation.
* introduction:                          Introduction.
* invalid input:                         Bug Criteria.
* job hunting:                           Variables.
* keywords:                              Keywords.
* known causes of trouble:               Trouble.
* language definition:                   Grammar.
* less than operator:                    Comparison Ops.
* lists:                                 Lists.
* loadable function:                     A Sample Function Description.
* logging commands and output:           Diary and Echo Commands.
* logical expressions:                   Boolean Expressions.
* logical operators:                     Boolean Expressions.
* loop:                                  The while Statement.
* looping over structure elements:       Looping Over Structure Elements.
* LP:                                    Optimization.
* LU decomposition:                      Matrix Factorizations.
* lvalue:                                Assignment Ops.
* mapping function:                      A Sample Function Description.
* matching failure, in scanf:            Formatted Input.
* matrices:                              Matrices.
* matrix multiplication:                 Arithmetic Ops.
* maximum field width (scanf):           Input Conversion Syntax.
* messages, error:                       Errors.
* minimum field width (printf):          Output Conversion Syntax.
* missing data:                          Missing Data.
* money:                                 Financial Functions.
* multiplication:                        Arithmetic Ops.
* negation:                              Arithmetic Ops.
* NLP:                                   Optimization.
* nonlinear equations:                   Nonlinear Equations.
* nonlinear programming:                 Optimization.
* not operator:                          Boolean Expressions.
* numeric constant <1>:                  Numeric Data Types.
* numeric constant:                      Numeric Objects.
* numeric value <1>:                     Numeric Data Types.
* numeric value:                         Numeric Objects.
* Octave command options:                Command Line Options.
* ODE:                                   Differential Equations.
* on-line help:                          Getting Help.
* operator precedence:                   Operator Precedence.
* operators, arithmetic:                 Arithmetic Ops.
* operators, assignment:                 Assignment Ops.
* operators, boolean:                    Boolean Expressions.
* operators, decrement:                  Assignment Ops.
* operators, increment:                  Assignment Ops.
* operators, logical:                    Boolean Expressions.
* operators, relational:                 Comparison Ops.
* optimization:                          Optimization.
* options, Octave command:               Command Line Options.
* or operator:                           Boolean Expressions.
* oregonator:                            Ordinary Differential Equations.
* otags:                                 Using Octave Mode.
* otherwise statement:                   The switch Statement.
* output conversions, for printf:        Table of Output Conversions.
* partial fraction expansion:            Polynomial Manipulations.
* patches, submitting:                   Sending Patches.
* persistent statement:                  Persistent Variables.
* persistent variables:                  Persistent Variables.
* plotting:                              Two-Dimensional Plotting.
* precision (printf):                    Output Conversion Syntax.
* printing notation:                     Printing Notation.
* program, self contained:               Executable Octave Programs.
* programs:                              Comments.
* prompt customization:                  Customizing the Prompt.
* QP:                                    Optimization.
* QR factorization:                      Matrix Factorizations.
* quadratic programming:                 Optimization.
* quitting octave <1>:                   Quitting Octave.
* quitting octave:                       Running Octave.
* quotient:                              Arithmetic Ops.
* range expressions:                     Ranges.
* relational operators:                  Comparison Ops.
* reporting bugs <1>:                    Bug Lists.
* reporting bugs:                        Reporting Bugs.
* results, incorrect <1>:                Bug Reporting.
* results, incorrect:                    Bug Criteria.
* Schur decomposition:                   Matrix Factorizations.
* script files:                          Functions and Scripts.
* scripts:                               Executable Octave Programs.
* self contained programs:               Executable Octave Programs.
* short-circuit evaluation:              Short-circuit Boolean Operators.
* side effect:                           Assignment Ops.
* singular value decomposition:          Matrix Factorizations.
* speedups:                              Coding Tips.
* standards of coding style:             Tips.
* startup:                               Startup Files.
* startup files:                         Startup Files.
* statements:                            Statements.
* strings <1>:                           Strings.
* strings:                               String Objects.
* structure elements, looping over:      Looping Over Structure Elements.
* structures <1>:                        Data Structures.
* structures:                            Data Structure Objects.
* submitting diffs:                      Sending Patches.
* submitting patches:                    Sending Patches.
* subtraction:                           Arithmetic Ops.
* suggestions:                           Bug Criteria.
* switch statement:                      The switch Statement.
* TAGS:                                  Using Octave Mode.
* tests for equality:                    Comparison Ops.
* tips:                                  Tips.
* transpose:                             Arithmetic Ops.
* transpose, complex-conjugate:          Arithmetic Ops.
* troubleshooting:                       Trouble.
* try statement:                         The try Statement.
* unary minus:                           Arithmetic Ops.
* undefined behavior:                    Bug Criteria.
* undefined function value:              Bug Criteria.
* unwind_protect statement:              The unwind_protect Statement.
* unwind_protect_cleanup:                The unwind_protect Statement.
* use of comments:                       Comments.
* user-defined data types:               User-defined Data Types.
* user-defined functions:                Functions and Scripts.
* user-defined variables:                Variables.
* Utility Functions:                     Utility Functions.
* variable descriptions:                 A Sample Variable Description.
* variable-length argument lists:        Variable-length Argument Lists.
* variable-length return lists:          Variable-length Return Lists.
* variables, global:                     Global Variables.
* variables, persistent:                 Persistent Variables.
* variables, user-defined:               Variables.
* warranty:                              Keywords.
* while statement:                       The while Statement.
* wrong answers <1>:                     Bug Reporting.
* wrong answers:                         Bug Criteria.
* ~/.octaverc:                           Startup Files.


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

Variable Index
**************

* Menu:

* ans:                                   Terminal Output.
* argv:                                  Command Line Options.
* automatic_replot <1>:                  Two-Dimensional Plotting.
* automatic_replot:                      Summary of Built-in Variables.
* beep_on_error <1>:                     Error Handling.
* beep_on_error:                         Summary of Built-in Variables.
* completion_append_char <1>:            Summary of Built-in Variables.
* completion_append_char:                Commands For Completion.
* crash_dumps_octave_core <1>:           Simple File I/O.
* crash_dumps_octave_core:               Summary of Built-in Variables.
* debug_on_error:                        Debugging.
* debug_on_interrupt:                    Debugging.
* debug_on_warning:                      Debugging.
* DEFAULT_LOADPATH <1>:                  Function Files.
* DEFAULT_LOADPATH:                      Summary of Built-in Variables.
* default_save_format <1>:               Simple File I/O.
* default_save_format:                   Summary of Built-in Variables.
* do_what_i_mean_not_what_i_say:         A Sample Variable Description.
* e:                                     Mathematical Constants.
* echo_executing_commands:               Diary and Echo Commands.
* EDITOR <1>:                            Defaults from the Environment.
* EDITOR <2>:                            Summary of Built-in Variables.
* EDITOR:                                Commands For History.
* eps:                                   Mathematical Constants.
* EXEC_PATH <1>:                         Controlling Subprocesses.
* EXEC_PATH:                             Summary of Built-in Variables.
* F_DUPFD:                               Controlling Subprocesses.
* F_GETFD:                               Controlling Subprocesses.
* F_GETFL:                               Controlling Subprocesses.
* F_SETFD:                               Controlling Subprocesses.
* F_SETFL:                               Controlling Subprocesses.
* false:                                 Logical Values.
* fixed_point_format <1>:                Summary of Built-in Variables.
* fixed_point_format:                    Matrices.
* gnuplot_binary <1>:                    Interaction with gnuplot.
* gnuplot_binary:                        Summary of Built-in Variables.
* gnuplot_command_axes:                  Interaction with gnuplot.
* gnuplot_command_end:                   Interaction with gnuplot.
* gnuplot_command_plot:                  Interaction with gnuplot.
* gnuplot_command_replot:                Interaction with gnuplot.
* gnuplot_command_splot:                 Interaction with gnuplot.
* gnuplot_command_title:                 Interaction with gnuplot.
* gnuplot_command_using:                 Interaction with gnuplot.
* gnuplot_command_with:                  Interaction with gnuplot.
* gnuplot_has_frames:                    Interaction with gnuplot.
* history_file <1>:                      Summary of Built-in Variables.
* history_file:                          Commands For History.
* history_size <1>:                      Summary of Built-in Variables.
* history_size:                          Commands For History.
* i:                                     Mathematical Constants.
* I:                                     Mathematical Constants.
* ignore_function_time_stamp <1>:        Function Files.
* ignore_function_time_stamp:            Summary of Built-in Variables.
* IMAGEPATH:                             Image Processing.
* inf:                                   Mathematical Constants.
* Inf:                                   Mathematical Constants.
* INFO_FILE <1>:                         Summary of Built-in Variables.
* INFO_FILE:                             Getting Help.
* INFO_PROGRAM <1>:                      Summary of Built-in Variables.
* INFO_PROGRAM:                          Getting Help.
* j:                                     Mathematical Constants.
* J:                                     Mathematical Constants.
* LOADPATH <1>:                          Function Files.
* LOADPATH:                              Summary of Built-in Variables.
* MAKEINFO_PROGRAM:                      Getting Help.
* max_recursion_depth <1>:               Recursion.
* max_recursion_depth:                   Summary of Built-in Variables.
* NA:                                    Missing Data.
* nan:                                   Mathematical Constants.
* NaN:                                   Mathematical Constants.
* O_APPEND:                              Controlling Subprocesses.
* O_ASYNC:                               Controlling Subprocesses.
* O_NONBLOCK:                            Controlling Subprocesses.
* O_RDONLY:                              Controlling Subprocesses.
* O_RDWR:                                Controlling Subprocesses.
* O_SYNC:                                Controlling Subprocesses.
* O_WRONLY:                              Controlling Subprocesses.
* OCTAVE_EXEC_PATH:                      Defaults from the Environment.
* OCTAVE_HISTFILE:                       Defaults from the Environment.
* OCTAVE_HISTSIZE:                       Defaults from the Environment.
* OCTAVE_HOME:                           Summary of Built-in Variables.
* OCTAVE_INFO_FILE:                      Defaults from the Environment.
* OCTAVE_INFO_PROGRAM:                   Defaults from the Environment.
* OCTAVE_PATH:                           Defaults from the Environment.
* OCTAVE_VERSION:                        System Information.
* output_max_field_width <1>:            Summary of Built-in Variables.
* output_max_field_width:                Matrices.
* output_precision <1>:                  Summary of Built-in Variables.
* output_precision:                      Matrices.
* page_output_immediately:               Input and Output.
* page_screen_output <1>:                Input and Output.
* page_screen_output:                    Summary of Built-in Variables.
* PAGER <1>:                             Input and Output.
* PAGER:                                 Summary of Built-in Variables.
* pi:                                    Mathematical Constants.
* print_answer_id_name <1>:              Terminal Output.
* print_answer_id_name:                  Summary of Built-in Variables.
* print_empty_dimensions <1>:            Summary of Built-in Variables.
* print_empty_dimensions:                Empty Matrices.
* print_rhs_assign_val:                  Assignment Ops.
* program_invocation_name:               Command Line Options.
* program_name:                          Command Line Options.
* PS1 <1>:                               Summary of Built-in Variables.
* PS1:                                   Customizing the Prompt.
* PS2 <1>:                               Summary of Built-in Variables.
* PS2:                                   Customizing the Prompt.
* PS4 <1>:                               Summary of Built-in Variables.
* PS4:                                   Customizing the Prompt.
* realmax:                               Mathematical Constants.
* realmin:                               Mathematical Constants.
* return:                                Returning From a Function.
* return_last_computed_value:            Summary of Built-in Variables.
* save_header_format_string:             Simple File I/O.
* save_precision <1>:                    Simple File I/O.
* save_precision:                        Summary of Built-in Variables.
* saving_history <1>:                    Summary of Built-in Variables.
* saving_history:                        Commands For History.
* SEEK_CUR:                              File Positioning.
* SEEK_END:                              File Positioning.
* SEEK_SET:                              File Positioning.
* sighup_dumps_octave_core <1>:          Simple File I/O.
* sighup_dumps_octave_core:              Summary of Built-in Variables.
* sigterm_dumps_octave_core <1>:         Simple File I/O.
* sigterm_dumps_octave_core:             Summary of Built-in Variables.
* silent_functions <1>:                  Defining Functions.
* silent_functions:                      Summary of Built-in Variables.
* split_long_rows <1>:                   Summary of Built-in Variables.
* split_long_rows:                       Matrices.
* stderr:                                C-Style I/O Functions.
* stdin:                                 C-Style I/O Functions.
* stdout:                                C-Style I/O Functions.
* string_fill_char:                      Creating Strings.
* struct_levels_to_print <1>:            Summary of Built-in Variables.
* struct_levels_to_print:                Data Structures.
* suppress_verbose_help_message <1>:     Summary of Built-in Variables.
* suppress_verbose_help_message:         Getting Help.
* true:                                  Logical Values.
* variables_can_hide_functions:          Dynamically Linked Functions.
* warn_assign_as_truth_value <1>:        The if Statement.
* warn_assign_as_truth_value:            Summary of Built-in Variables.
* warn_comma_in_global_decl:             Summary of Built-in Variables.
* warn_divide_by_zero <1>:               Arithmetic Ops.
* warn_divide_by_zero:                   Summary of Built-in Variables.
* warn_empty_list_elements <1>:          Summary of Built-in Variables.
* warn_empty_list_elements:              Empty Matrices.
* warn_fortran_indexing <1>:             Index Expressions.
* warn_fortran_indexing:                 Summary of Built-in Variables.
* warn_function_name_clash <1>:          Function Files.
* warn_function_name_clash:              Summary of Built-in Variables.
* warn_future_time_stamp:                Function Files.
* warn_imag_to_real <1>:                 Special Utility Matrices.
* warn_imag_to_real:                     Summary of Built-in Variables.
* warn_missing_semicolon <1>:            Defining Functions.
* warn_missing_semicolon:                Summary of Built-in Variables.
* warn_neg_dim_as_zero <1>:              Special Utility Matrices.
* warn_neg_dim_as_zero:                  Summary of Built-in Variables.
* warn_num_to_str <1>:                   Summary of Built-in Variables.
* warn_num_to_str:                       String Conversions.
* warn_reload_forces_clear <1>:          Dynamically Linked Functions.
* warn_reload_forces_clear:              Summary of Built-in Variables.
* warn_resize_on_range_error <1>:        Index Expressions.
* warn_resize_on_range_error:            Summary of Built-in Variables.
* warn_separator_insert <1>:             Summary of Built-in Variables.
* warn_separator_insert:                 Matrices.
* warn_single_quote_string <1>:          Summary of Built-in Variables.
* warn_single_quote_string:              String Conversions.
* warn_str_to_num <1>:                   Summary of Built-in Variables.
* warn_str_to_num:                       String Conversions.
* warn_undefined_return_values <1>:      Multiple Return Values.
* warn_undefined_return_values:          Summary of Built-in Variables.
* warn_variable_switch_label <1>:        The switch Statement.
* warn_variable_switch_label:            Summary of Built-in Variables.
* whos_line_format:                      Status of Variables.


File: octave.info,  Node: Function Index,  Next: Operator Index,  Prev: Variable Index,  Up: Top

Function Index
**************

* Menu:

* ( <1>:                                 Audio Processing.
* (:                                     Signal Processing.
* = <1>:                                 Signal Processing.
* =:                                     Rearranging Matrices.
* [:                                     Coordinate Transformations.
* abcddim:                               sysprop.
* abs:                                   Complex Arithmetic.
* acos:                                  Trigonometry.
* acosh:                                 Trigonometry.
* acot:                                  Trigonometry.
* acoth:                                 Trigonometry.
* acsc:                                  Trigonometry.
* acsch:                                 Trigonometry.
* airy:                                  Special Functions.
* all:                                   Finding Elements and Checking Conditions.
* analdemo:                              sysprop.
* angle:                                 Complex Arithmetic.
* anova:                                 Tests.
* any:                                   Finding Elements and Checking Conditions.
* append:                                Lists.
* arch_fit:                              Signal Processing.
* arch_rnd:                              Signal Processing.
* arch_test:                             Signal Processing.
* are:                                   numerical.
* arg:                                   Complex Arithmetic.
* argnames:                              Inline Functions.
* arma_rnd:                              Signal Processing.
* asctime:                               Timing Utilities.
* asec:                                  Trigonometry.
* asech:                                 Trigonometry.
* asin:                                  Trigonometry.
* asinh:                                 Trigonometry.
* atan:                                  Trigonometry.
* atan2:                                 Trigonometry.
* atanh:                                 Trigonometry.
* atexit:                                Quitting Octave.
* autocor:                               Signal Processing.
* autocov:                               Signal Processing.
* autoreg_matrix:                        Signal Processing.
* axis:                                  Two-Dimensional Plotting.
* axis2dlim:                             misc.
* balance:                               Basic Matrix Functions.
* bar:                                   Specialized Two-Dimensional Plots.
* bartlett:                              Signal Processing.
* bartlett_test:                         Tests.
* base2dec:                              String Conversions.
* bddemo:                                blockdiag.
* besselh:                               Special Functions.
* besseli:                               Special Functions.
* besselj:                               Special Functions.
* besselk:                               Special Functions.
* bessely:                               Special Functions.
* beta:                                  Special Functions.
* beta_cdf:                              Distributions.
* beta_inv:                              Distributions.
* beta_pdf:                              Distributions.
* beta_rnd:                              Distributions.
* betainc:                               Special Functions.
* bincoeff:                              Special Functions.
* binomial_cdf:                          Distributions.
* binomial_inv:                          Distributions.
* binomial_pdf:                          Distributions.
* binomial_rnd:                          Distributions.
* blackman:                              Signal Processing.
* blanks:                                Creating Strings.
* bode:                                  sysfreq.
* bode_bounds:                           sysfreq.
* bottom_title <1>:                      Multiple Plots on One Page.
* bottom_title:                          Plot Annotations.
* bug_report <1>:                        Bug Lists.
* bug_report:                            Reporting Bugs.
* buildssic:                             blockdiag.
* c2d:                                   systime.
* cat:                                   Rearranging Matrices.
* cauchy_cdf:                            Distributions.
* cauchy_inv:                            Distributions.
* cauchy_pdf:                            Distributions.
* cauchy_rnd:                            Distributions.
* cd <1>:                                Current Working Directory.
* cd:                                    A Sample Command Description.
* ceil:                                  Utility Functions.
* cell:                                  Cell Arrays.
* cellstr:                               Cell Arrays.
* center:                                Basic Statistical Functions.
* char:                                  Creating Strings.
* chdir <1>:                             Current Working Directory.
* chdir:                                 A Sample Command Description.
* chisquare_cdf:                         Distributions.
* chisquare_inv:                         Distributions.
* chisquare_pdf:                         Distributions.
* chisquare_rnd:                         Distributions.
* chisquare_test_homogeneity:            Tests.
* chisquare_test_independence:           Tests.
* chol:                                  Matrix Factorizations.
* clc:                                   Cursor Motion.
* clear:                                 Status of Variables.
* clearplot:                             Two-Dimensional Plotting.
* clg:                                   Two-Dimensional Plotting.
* clock:                                 Timing Utilities.
* cloglog:                               Basic Statistical Functions.
* closeplot:                             Two-Dimensional Plotting.
* colloc:                                Orthogonal Collocation.
* colormap:                              Image Processing.
* columns:                               Object Sizes.
* com2str:                               Creating Strings.
* common_size:                           Finding Elements and Checking Conditions.
* commutation_matrix:                    Special Functions.
* compan:                                Polynomial Manipulations.
* complement:                            Sets.
* completion_matches:                    Commands For Completion.
* computer:                              System Information.
* cond:                                  Basic Matrix Functions.
* conj:                                  Complex Arithmetic.
* contour:                               Specialized Two-Dimensional Plots.
* conv:                                  Polynomial Manipulations.
* cor:                                   Basic Statistical Functions.
* cor_test:                              Tests.
* corrcoef:                              Basic Statistical Functions.
* cos:                                   Trigonometry.
* cosh:                                  Trigonometry.
* cot:                                   Trigonometry.
* coth:                                  Trigonometry.
* cov:                                   Basic Statistical Functions.
* cputime:                               Timing Utilities.
* create_set:                            Sets.
* cross:                                 Special Functions.
* csc:                                   Trigonometry.
* csch:                                  Trigonometry.
* ctime:                                 Timing Utilities.
* ctrb:                                  sysprop.
* cumprod:                               Sums and Products.
* cumsum:                                Sums and Products.
* cut:                                   Basic Statistical Functions.
* d2c:                                   systime.
* damp:                                  systime.
* dare:                                  numerical.
* daspk:                                 Differential-Algebraic Equations.
* daspk_options:                         Differential-Algebraic Equations.
* dasrt:                                 Differential-Algebraic Equations.
* dasrt_options:                         Differential-Algebraic Equations.
* date:                                  Timing Utilities.
* dbclear:                               Debugging.
* dbstatus:                              Debugging.
* dbstop:                                Debugging.
* dbtype:                                Debugging.
* dbwhere:                               Debugging.
* dcgain:                                systime.
* deblank:                               Searching and Replacing.
* dec2base:                              String Conversions.
* dec2bin:                               String Conversions.
* dec2hex:                               String Conversions.
* deconv:                                Polynomial Manipulations.
* DEMOcontrol:                           Control Theory.
* det:                                   Basic Matrix Functions.
* detrend:                               Signal Processing.
* dgkfdemo:                              cacsd.
* dgram:                                 numerical.
* diag:                                  Special Utility Matrices.
* diary:                                 Diary and Echo Commands.
* diff:                                  Finding Elements and Checking Conditions.
* discrete_cdf:                          Distributions.
* discrete_inv:                          Distributions.
* discrete_pdf:                          Distributions.
* discrete_rnd:                          Distributions.
* disp:                                  Terminal Output.
* dkalman:                               cacsd.
* dlqe:                                  cacsd.
* dlqr:                                  cacsd.
* dlyap:                                 numerical.
* dmr2d:                                 systime.
* dmult:                                 Basic Matrix Functions.
* do_string_escapes:                     String Conversions.
* document:                              Status of Variables.
* dot:                                   Basic Matrix Functions.
* dre:                                   numerical.
* dup2:                                  Controlling Subprocesses.
* duplication_matrix:                    Special Functions.
* durbinlevinson:                        Signal Processing.
* echo:                                  Diary and Echo Commands.
* edit_history:                          Commands For History.
* eig:                                   Basic Matrix Functions.
* empirical_cdf:                         Distributions.
* empirical_inv:                         Distributions.
* empirical_pdf:                         Distributions.
* empirical_rnd:                         Distributions.
* endgrent:                              Group Database Functions.
* endpwent:                              Password Database Functions.
* erf:                                   Special Functions.
* erfc:                                  Special Functions.
* erfinv:                                Special Functions.
* error:                                 Error Handling.
* errorbar:                              Specialized Two-Dimensional Plots.
* etime:                                 Timing Utilities.
* eval:                                  Evaluation.
* exec:                                  Controlling Subprocesses.
* exist:                                 Status of Variables.
* exit:                                  Quitting Octave.
* exp:                                   Utility Functions.
* expm:                                  Functions of a Matrix.
* exponential_cdf:                       Distributions.
* exponential_inv:                       Distributions.
* exponential_pdf:                       Distributions.
* exponential_rnd:                       Distributions.
* eye:                                   Special Utility Matrices.
* f_cdf:                                 Distributions.
* f_inv:                                 Distributions.
* f_pdf:                                 Distributions.
* f_rnd:                                 Distributions.
* f_test_regression:                     Tests.
* fclose:                                Opening and Closing Files.
* fcntl:                                 Controlling Subprocesses.
* fdisp:                                 Terminal Output.
* feof:                                  EOF and Errors.
* ferror:                                EOF and Errors.
* feval:                                 Evaluation.
* fflush:                                Input and Output.
* fft:                                   Signal Processing.
* fft2:                                  Signal Processing.
* fftconv:                               Signal Processing.
* fftfilt:                               Signal Processing.
* fftn:                                  Signal Processing.
* fftshift:                              Signal Processing.
* fgetl:                                 Line-Oriented Input.
* fgets:                                 Line-Oriented Input.
* fieldnames:                            Data Structures.
* figure:                                Multiple Plot Windows.
* file_in_loadpath:                      Function Files.
* file_in_path:                          Filesystem Utilities.
* filter:                                Signal Processing.
* find:                                  Finding Elements and Checking Conditions.
* findstr:                               Searching and Replacing.
* finite:                                Finding Elements and Checking Conditions.
* fir2sys:                               fir2sys.
* fix:                                   Utility Functions.
* flipdim:                               Rearranging Matrices.
* fliplr:                                Rearranging Matrices.
* flipud:                                Rearranging Matrices.
* floor:                                 Utility Functions.
* fnmatch:                               Filesystem Utilities.
* foo:                                   A Sample Function Description.
* fopen:                                 Opening and Closing Files.
* fork:                                  Controlling Subprocesses.
* format:                                Terminal Output.
* formula:                               Inline Functions.
* fprintf:                               Formatted Output.
* fputs:                                 Simple Output.
* fractdiff:                             Signal Processing.
* frdemo:                                sysfreq.
* fread:                                 Binary I/O.
* freport:                               EOF and Errors.
* freqchkw:                              sysfreq.
* freqz:                                 Signal Processing.
* frewind:                               File Positioning.
* fscanf:                                Formatted Input.
* fseek:                                 File Positioning.
* fsolve:                                Nonlinear Equations.
* fsolve_options:                        Nonlinear Equations.
* ftell:                                 File Positioning.
* func2str:                              Function Handles.
* functions:                             Function Handles.
* fv:                                    Financial Functions.
* fvl:                                   Financial Functions.
* fwrite:                                Binary I/O.
* gamma:                                 Special Functions.
* gamma_cdf:                             Distributions.
* gamma_inv:                             Distributions.
* gamma_pdf:                             Distributions.
* gamma_rnd:                             Distributions.
* gammainc:                              Special Functions.
* gammaln:                               Special Functions.
* gcd:                                   Utility Functions.
* geometric_cdf:                         Distributions.
* geometric_inv:                         Distributions.
* geometric_pdf:                         Distributions.
* geometric_rnd:                         Distributions.
* getegid:                               Process ID Information.
* getenv:                                Environment Variables.
* geteuid:                               Process ID Information.
* getgid:                                Process ID Information.
* getgrent:                              Group Database Functions.
* getgrgid:                              Group Database Functions.
* getgrnam:                              Group Database Functions.
* getpgrp:                               Process ID Information.
* getpid:                                Process ID Information.
* getppid:                               Process ID Information.
* getpwent:                              Password Database Functions.
* getpwnam:                              Password Database Functions.
* getpwuid:                              Password Database Functions.
* getrusage:                             System Information.
* getuid:                                Process ID Information.
* givens:                                Basic Matrix Functions.
* glob:                                  Filesystem Utilities.
* gls:                                   Linear Least Squares.
* gmtime:                                Timing Utilities.
* gplot:                                 Two-Dimensional Plotting.
* gram:                                  numerical.
* graw:                                  Interaction with gnuplot.
* gray:                                  Image Processing.
* gray2ind:                              Image Processing.
* grid:                                  Plot Annotations.
* gset:                                  Two-Dimensional Plotting.
* gshow:                                 Two-Dimensional Plotting.
* gsplot:                                Three-Dimensional Plotting.
* h2norm:                                sysprop.
* h2syn:                                 cacsd.
* hamming:                               Signal Processing.
* hankel:                                Famous Matrices.
* hanning:                               Signal Processing.
* help:                                  Getting Help.
* hess:                                  Matrix Factorizations.
* hex2dec:                               String Conversions.
* hilb:                                  Famous Matrices.
* hinf_ctr:                              cacsd.
* hinfdemo:                              cacsd.
* hinfnorm:                              sysprop.
* hinfsyn:                               cacsd.
* hinfsyn_chk:                           cacsd.
* hinfsyn_ric:                           cacsd.
* hist:                                  Specialized Two-Dimensional Plots.
* history:                               Commands For History.
* hold:                                  Two-Dimensional Plotting.
* home:                                  Cursor Motion.
* horzcat:                               Rearranging Matrices.
* hotelling_test:                        Tests.
* hotelling_test_2:                      Tests.
* housh:                                 Matrix Factorizations.
* HSV_MAP:                               Image Processing.
* hurst:                                 Signal Processing.
* hypergeometric_cdf:                    Distributions.
* hypergeometric_inv:                    Distributions.
* hypergeometric_pdf:                    Distributions.
* hypergeometric_rnd:                    Distributions.
* ifft:                                  Signal Processing.
* ifftn:                                 Signal Processing.
* imag:                                  Complex Arithmetic.
* image:                                 Image Processing.
* imagesc:                               Image Processing.
* impulse:                               systime.
* imshow:                                Image Processing.
* ind2gray:                              Image Processing.
* ind2rgb:                               Image Processing.
* index:                                 Searching and Replacing.
* inline:                                Inline Functions.
* input:                                 Terminal Input.
* int2str:                               Creating Strings.
* intersection:                          Sets.
* inv:                                   Basic Matrix Functions.
* inverse:                               Basic Matrix Functions.
* invhilb:                               Famous Matrices.
* ipermute:                              Rearranging Matrices.
* iqr:                                   Basic Statistical Functions.
* irr:                                   Financial Functions.
* is_abcd:                               sysprop.
* is_controllable:                       sysprop.
* is_detectable:                         sysprop.
* is_dgkf:                               sysprop.
* is_digital:                            sysprop.
* is_duplicate_entry:                    Finding Elements and Checking Conditions.
* is_leap_year:                          Timing Utilities.
* is_nan_or_na:                          Missing Data.
* is_observable:                         sysprop.
* is_sample:                             sysprop.
* is_signal_list:                        sysprop.
* is_siso:                               sysprop.
* is_stabilizable:                       sysprop.
* is_stable:                             sysprop.
* isalnum:                               Character Class Functions.
* isalpha:                               Character Class Functions.
* isascii:                               Character Class Functions.
* isbool:                                Predicates for Numeric Objects.
* iscell:                                Cell Arrays.
* ischar:                                Creating Strings.
* iscntrl:                               Character Class Functions.
* iscomplex:                             Predicates for Numeric Objects.
* isdigit:                               Character Class Functions.
* isempty:                               Object Sizes.
* isfield:                               Data Structures.
* isglobal:                              Global Variables.
* isgraph:                               Character Class Functions.
* ishold:                                Two-Dimensional Plotting.
* isieee:                                System Information.
* isinf:                                 Finding Elements and Checking Conditions.
* isletter:                              Character Class Functions.
* islist:                                Lists.
* islower:                               Character Class Functions.
* ismatrix:                              Predicates for Numeric Objects.
* isna:                                  Missing Data.
* isnan:                                 Finding Elements and Checking Conditions.
* isnumeric:                             Predicates for Numeric Objects.
* isprint:                               Character Class Functions.
* ispunct:                               Character Class Functions.
* isreal:                                Predicates for Numeric Objects.
* isscalar:                              Predicates for Numeric Objects.
* isspace:                               Character Class Functions.
* issquare:                              Predicates for Numeric Objects.
* isstr:                                 Creating Strings.
* isstream:                              I/O Streams.
* isstruct:                              Data Structures.
* issymmetric:                           Predicates for Numeric Objects.
* isupper:                               Character Class Functions.
* isvector:                              Predicates for Numeric Objects.
* isxdigit:                              Character Class Functions.
* jet707:                                blockdiag.
* kbhit:                                 Terminal Input.
* kendall:                               Basic Statistical Functions.
* keyboard:                              Terminal Input.
* kolmogorov_smirnov_cdf:                Distributions.
* kolmogorov_smirnov_test:               Tests.
* kolmogorov_smirnov_test_2:             Tests.
* kron:                                  Functions of a Matrix.
* kruskal_wallis_test:                   Tests.
* krylov:                                Matrix Factorizations.
* kurtosis:                              Basic Statistical Functions.
* laplace_cdf:                           Distributions.
* laplace_inv:                           Distributions.
* laplace_pdf:                           Distributions.
* laplace_rnd:                           Distributions.
* lasterr:                               Error Handling.
* lastwarn:                              Error Handling.
* lcm:                                   Utility Functions.
* length:                                Object Sizes.
* lgamma:                                Special Functions.
* lin2mu:                                Audio Processing.
* link:                                  Filesystem Utilities.
* linspace:                              Special Utility Matrices.
* list:                                  Lists.
* load:                                  Simple File I/O.
* loadaudio:                             Audio Processing.
* loadimage:                             Image Processing.
* localtime:                             Timing Utilities.
* log:                                   Utility Functions.
* log10:                                 Utility Functions.
* log2:                                  Utility Functions.
* logistic_cdf:                          Distributions.
* logistic_inv:                          Distributions.
* logistic_pdf:                          Distributions.
* logistic_regression:                   Models.
* logistic_rnd:                          Distributions.
* logit:                                 Basic Statistical Functions.
* loglog:                                Specialized Two-Dimensional Plots.
* loglogerr:                             Specialized Two-Dimensional Plots.
* logm:                                  Functions of a Matrix.
* lognormal_cdf:                         Distributions.
* lognormal_inv:                         Distributions.
* lognormal_pdf:                         Distributions.
* lognormal_rnd:                         Distributions.
* logspace:                              Special Utility Matrices.
* lqe:                                   cacsd.
* lqg:                                   cacsd.
* lqr:                                   cacsd.
* ls:                                    Current Working Directory.
* lsim:                                  cacsd.
* lsode:                                 Ordinary Differential Equations.
* lsode_options:                         Ordinary Differential Equations.
* lstat:                                 Filesystem Utilities.
* ltifr:                                 sysfreq.
* lu:                                    Matrix Factorizations.
* lyap:                                  numerical.
* mahalanobis:                           Basic Statistical Functions.
* manova:                                Tests.
* max:                                   Utility Functions.
* mcnemar_test:                          Tests.
* mean:                                  Basic Statistical Functions.
* meansq:                                Basic Statistical Functions.
* median:                                Basic Statistical Functions.
* menu:                                  Terminal Input.
* mesh:                                  Three-Dimensional Plotting.
* meshdom:                               Three-Dimensional Plotting.
* meshgrid:                              Three-Dimensional Plotting.
* min:                                   Utility Functions.
* minfo:                                 structaccess.
* mkdir:                                 Filesystem Utilities.
* mkfifo:                                Filesystem Utilities.
* mktime:                                Timing Utilities.
* mod:                                   Utility Functions.
* moddemo:                               misc.
* moment:                                Basic Statistical Functions.
* more:                                  Input and Output.
* mplot:                                 Multiple Plots on One Page.
* mu2lin:                                Audio Processing.
* multiplot:                             Multiple Plots on One Page.
* nargchk:                               Multiple Return Values.
* nargin:                                Defining Functions.
* nargout:                               Multiple Return Values.
* newtroot:                              Evaluation.
* nextpow2:                              Utility Functions.
* norm:                                  Basic Matrix Functions.
* normal_cdf:                            Distributions.
* normal_inv:                            Distributions.
* normal_pdf:                            Distributions.
* normal_rnd:                            Distributions.
* nper:                                  Financial Functions.
* npv:                                   Financial Functions.
* nth:                                   Lists.
* ntsc2rgb:                              Image Processing.
* null:                                  Basic Matrix Functions.
* num2str:                               Creating Strings.
* nyquist:                               sysfreq.
* obsv:                                  sysprop.
* ocean:                                 Image Processing.
* octave_config_info:                    System Information.
* odessa:                                Ordinary Differential Equations.
* odessa_options:                        Ordinary Differential Equations.
* ols:                                   Linear Least Squares.
* oneplot:                               Multiple Plots on One Page.
* ones:                                  Special Utility Matrices.
* ord2:                                  blockdiag.
* orth:                                  Basic Matrix Functions.
* parallel:                              blockdiag.
* pascal_cdf:                            Distributions.
* pascal_inv:                            Distributions.
* pascal_pdf:                            Distributions.
* pascal_rnd:                            Distributions.
* pause:                                 Timing Utilities.
* pclose:                                Controlling Subprocesses.
* periodogram:                           Signal Processing.
* permute:                               Rearranging Matrices.
* perror:                                Error Handling.
* pinv:                                  Basic Matrix Functions.
* pipe:                                  Controlling Subprocesses.
* place:                                 cacsd.
* playaudio:                             Audio Processing.
* plot:                                  Two-Dimensional Plotting.
* plot_border:                           Multiple Plots on One Page.
* pmt:                                   Financial Functions.
* poisson_cdf:                           Distributions.
* poisson_inv:                           Distributions.
* poisson_pdf:                           Distributions.
* poisson_rnd:                           Distributions.
* polar:                                 Specialized Two-Dimensional Plots.
* poly:                                  Polynomial Manipulations.
* polyderiv:                             Polynomial Manipulations.
* polyfit:                               Polynomial Manipulations.
* polyinteg:                             Polynomial Manipulations.
* polyout:                               Polynomial Manipulations.
* polyreduce:                            Polynomial Manipulations.
* polyval:                               Polynomial Manipulations.
* polyvalm:                              Polynomial Manipulations.
* popen:                                 Controlling Subprocesses.
* popen2:                                Controlling Subprocesses.
* postpad:                               Rearranging Matrices.
* pow2:                                  Utility Functions.
* ppplot:                                Basic Statistical Functions.
* prepad:                                Rearranging Matrices.
* printf:                                Formatted Output.
* probit:                                Basic Statistical Functions.
* prod:                                  Sums and Products.
* prompt:                                misc.
* prop_test_2:                           Tests.
* purge_tmp_files:                       Two-Dimensional Plotting.
* putenv:                                Environment Variables.
* puts:                                  Simple Output.
* pv:                                    Financial Functions.
* pvl:                                   Financial Functions.
* pwd:                                   Current Working Directory.
* pzmap:                                 sysprop.
* qconj:                                 Quaternions.
* qcoordinate_plot:                      Quaternions.
* qderiv:                                Quaternions.
* qderivmat:                             Quaternions.
* qinv:                                  Quaternions.
* qmult:                                 Quaternions.
* qqplot:                                Basic Statistical Functions.
* qr:                                    Matrix Factorizations.
* qtrans:                                Quaternions.
* qtransv:                               Quaternions.
* qtransvmat:                            Quaternions.
* quad:                                  Functions of One Variable.
* quad_options:                          Functions of One Variable.
* quaternion:                            Quaternions.
* quit:                                  Quitting Octave.
* qz:                                    Matrix Factorizations.
* qzhess:                                Matrix Factorizations.
* qzval:                                 numerical.
* rand:                                  Special Utility Matrices.
* randn:                                 Special Utility Matrices.
* randperm:                              Special Utility Matrices.
* range:                                 Basic Statistical Functions.
* rank:                                  Basic Matrix Functions.
* ranks:                                 Basic Statistical Functions.
* rate:                                  Financial Functions.
* read_readline_init_file:               Customizing readline.
* readdir:                               Filesystem Utilities.
* readlink:                              Filesystem Utilities.
* real:                                  Complex Arithmetic.
* record:                                Audio Processing.
* rectangle_lw:                          Signal Processing.
* rectangle_sw:                          Signal Processing.
* rehash:                                Function Files.
* rem:                                   Utility Functions.
* rename:                                Filesystem Utilities.
* replot:                                Two-Dimensional Plotting.
* repmat:                                Special Utility Matrices.
* reshape:                               Rearranging Matrices.
* residue:                               Polynomial Manipulations.
* reverse:                               Lists.
* rgb2ind:                               Image Processing.
* rgb2ntsc:                              Image Processing.
* RGB_MAP:                               Image Processing.
* rindex:                                Searching and Replacing.
* rldemo:                                misc.
* rlocus:                                misc.
* rmdir:                                 Filesystem Utilities.
* roots:                                 Polynomial Manipulations.
* rot90:                                 Rearranging Matrices.
* rotdim:                                Rearranging Matrices.
* round:                                 Utility Functions.
* rows:                                  Object Sizes.
* run_count:                             Basic Statistical Functions.
* run_history:                           Commands For History.
* run_test:                              Tests.
* save:                                  Simple File I/O.
* saveaudio:                             Audio Processing.
* saveimage:                             Image Processing.
* schur:                                 Matrix Factorizations.
* sec:                                   Trigonometry.
* sech:                                  Trigonometry.
* semilogx:                              Specialized Two-Dimensional Plots.
* semilogxerr:                           Specialized Two-Dimensional Plots.
* semilogy:                              Specialized Two-Dimensional Plots.
* semilogyerr:                           Specialized Two-Dimensional Plots.
* set:                                   Two-Dimensional Plotting.
* setgrent:                              Group Database Functions.
* setpwent:                              Password Database Functions.
* shg:                                   Two-Dimensional Plotting.
* shift:                                 Rearranging Matrices.
* show:                                  Two-Dimensional Plotting.
* sign:                                  Utility Functions.
* sign_test:                             Tests.
* sin:                                   Trigonometry.
* sinc:                                  Signal Processing.
* sinetone:                              Signal Processing.
* sinewave:                              Signal Processing.
* sinh:                                  Trigonometry.
* size:                                  Object Sizes.
* skewness:                              Basic Statistical Functions.
* sleep:                                 Timing Utilities.
* sort:                                  Rearranging Matrices.
* sortcom:                               misc.
* source:                                Script Files.
* spearman:                              Basic Statistical Functions.
* spectral_adf:                          Signal Processing.
* spectral_xdf:                          Signal Processing.
* spencer:                               Signal Processing.
* splice:                                Lists.
* split:                                 Searching and Replacing.
* sprintf:                               Formatted Output.
* sqrt:                                  Utility Functions.
* sqrtm:                                 Functions of a Matrix.
* ss:                                    ss2sys.
* ss2tf:                                 misc.
* ss2zp:                                 misc.
* sscanf:                                Formatted Input.
* stairs:                                Specialized Two-Dimensional Plots.
* starp:                                 misc.
* stat:                                  Filesystem Utilities.
* statistics:                            Basic Statistical Functions.
* std:                                   Basic Statistical Functions.
* stdnormal_cdf:                         Distributions.
* stdnormal_inv:                         Distributions.
* stdnormal_pdf:                         Distributions.
* stdnormal_rnd:                         Distributions.
* step:                                  systime.
* str2func:                              Function Handles.
* str2mat:                               Creating Strings.
* str2num:                               String Conversions.
* strcat:                                Creating Strings.
* strcmp:                                Searching and Replacing.
* strerror:                              Error Handling.
* strftime:                              Timing Utilities.
* strjust:                               String Conversions.
* strptime:                              Timing Utilities.
* strrep:                                Searching and Replacing.
* studentize:                            Basic Statistical Functions.
* subplot:                               Multiple Plots on One Page.
* substr:                                Searching and Replacing.
* subwindow:                             Multiple Plots on One Page.
* sum:                                   Sums and Products.
* sumsq:                                 Sums and Products.
* svd:                                   Matrix Factorizations.
* syl:                                   Functions of a Matrix.
* sylvester_matrix:                      Famous Matrices.
* symlink:                               Filesystem Utilities.
* synthesis:                             Signal Processing.
* sys2fir:                               fir2sys.
* sys2ss:                                ss2sys.
* sys2tf:                                tf2sys.
* sys2zp:                                zp2sys.
* sysadd:                                blockdiag.
* sysappend:                             blockdiag.
* syschnames:                            structaccess.
* syschtsam:                             structaccess.
* sysconnect:                            blockdiag.
* syscont:                               blockdiag.
* sysdimensions:                         structaccess.
* sysdisc:                               blockdiag.
* sysdup:                                blockdiag.
* sysgetsignals:                         structaccess.
* sysgettsam:                            structaccess.
* sysgettype:                            structaccess.
* sysgroup:                              blockdiag.
* sysmin:                                blockdiag.
* sysmult:                               blockdiag.
* sysout:                                sysdisp.
* sysprune:                              blockdiag.
* sysreorder:                            blockdiag.
* sysrepdemo:                            sysstruct.
* sysscale:                              blockdiag.
* syssetsignals:                         structaccess.
* syssub:                                blockdiag.
* system:                                Controlling Subprocesses.
* sysupdate:                             structaccess.
* t_cdf:                                 Distributions.
* t_inv:                                 Distributions.
* t_pdf:                                 Distributions.
* t_rnd:                                 Distributions.
* t_test:                                Tests.
* t_test_2:                              Tests.
* t_test_regression:                     Tests.
* table:                                 Basic Statistical Functions.
* tan:                                   Trigonometry.
* tanh:                                  Trigonometry.
* tf2ss:                                 misc.
* tf2sys:                                tf2sys.
* tf2zp:                                 misc.
* tfout:                                 sysdisp.
* tic:                                   Timing Utilities.
* tilde_expand:                          Filesystem Utilities.
* time:                                  Timing Utilities.
* title:                                 Plot Annotations.
* tmpfile:                               Temporary Files.
* tmpnam:                                Temporary Files.
* toascii:                               String Conversions.
* toc:                                   Timing Utilities.
* toeplitz:                              Famous Matrices.
* tolower:                               String Conversions.
* top_title:                             Multiple Plots on One Page.
* toupper:                               String Conversions.
* trace:                                 Basic Matrix Functions.
* triangle_lw:                           Signal Processing.
* triangle_sw:                           Signal Processing.
* tril:                                  Rearranging Matrices.
* triu:                                  Rearranging Matrices.
* type:                                  Status of Variables.
* typeinfo:                              Data Types.
* tzero:                                 sysfreq.
* tzero2:                                sysfreq.
* u_test:                                Tests.
* ugain:                                 blockdiag.
* umask:                                 Filesystem Utilities.
* undo_string_escapes:                   String Conversions.
* uniform_cdf:                           Distributions.
* uniform_inv:                           Distributions.
* uniform_pdf:                           Distributions.
* uniform_rnd:                           Distributions.
* union:                                 Sets.
* unlink:                                Filesystem Utilities.
* unwrap:                                Signal Processing.
* usage:                                 Error Handling.
* usleep:                                Timing Utilities.
* values:                                Basic Statistical Functions.
* vander:                                Famous Matrices.
* var:                                   Basic Statistical Functions.
* var_test:                              Tests.
* vec:                                   Rearranging Matrices.
* vech:                                  Rearranging Matrices.
* vertcat:                               Rearranging Matrices.
* vol:                                   Financial Functions.
* waitpid:                               Controlling Subprocesses.
* warning:                               Error Handling.
* weibull_cdf:                           Distributions.
* weibull_inv:                           Distributions.
* weibull_pdf:                           Distributions.
* weibull_rnd:                           Distributions.
* welch_test:                            Tests.
* wgt1o:                                 blockdiag.
* which:                                 Status of Variables.
* who:                                   Status of Variables.
* whos:                                  Status of Variables.
* wiener_rnd:                            Distributions.
* wilcoxon_test:                         Tests.
* xlabel:                                Plot Annotations.
* xor:                                   Finding Elements and Checking Conditions.
* ylabel:                                Plot Annotations.
* yulewalker:                            Signal Processing.
* z_test:                                Tests.
* z_test_2:                              Tests.
* zeros:                                 Special Utility Matrices.
* zgfmul:                                numerical.
* zgfslv:                                numerical.
* zginit:                                numerical.
* zgreduce:                              numerical.
* zgrownorm:                             numerical.
* zgscal:                                numerical.
* zgsgiv:                                numerical.
* zgshsr:                                numerical.
* zlabel:                                Plot Annotations.
* zp2ss:                                 misc.
* zp2sys:                                zp2sys.
* zp2tf:                                 misc.
* zpout:                                 sysdisp.


File: octave.info,  Node: Operator Index,  Prev: Function Index,  Up: Top

Operator Index
**************

* Menu:

* !:                                     Element-by-element Boolean Operators.
* !=:                                    Comparison Ops.
* " <1>:                                 Strings.
* ":                                     String Objects.
* &:                                     Element-by-element Boolean Operators.
* &&:                                    Short-circuit Boolean Operators.
* ' <1>:                                 Arithmetic Ops.
* ' <2>:                                 Strings.
* ':                                     String Objects.
* (:                                     Index Expressions.
* ):                                     Index Expressions.
* *:                                     Arithmetic Ops.
* **:                                    Arithmetic Ops.
* +:                                     Arithmetic Ops.
* ++:                                    Increment Ops.
* ,:                                     Matrices.
* -:                                     Arithmetic Ops.
* --:                                    Increment Ops.
* .':                                    Arithmetic Ops.
* .*:                                    Arithmetic Ops.
* .**:                                   Arithmetic Ops.
* .+:                                    Arithmetic Ops.
* ./:                                    Arithmetic Ops.
* .\:                                    Arithmetic Ops.
* .^:                                    Arithmetic Ops.
* /:                                     Arithmetic Ops.
* ;:                                     Matrices.
* <:                                     Comparison Ops.
* <=:                                    Comparison Ops.
* <>:                                    Comparison Ops.
* =:                                     Assignment Ops.
* ==:                                    Comparison Ops.
* >:                                     Comparison Ops.
* >=:                                    Comparison Ops.
* [:                                     Matrices.
* \:                                     Arithmetic Ops.
* ]:                                     Matrices.
* ^:                                     Arithmetic Ops.
* colon:                                 Ranges.
* |:                                     Element-by-element Boolean Operators.
* ||:                                    Short-circuit Boolean Operators.
* ~:                                     Element-by-element Boolean Operators.
* ~=:                                    Comparison Ops.


