# doc-cache created by Octave 4.0.3
# name: cache
# type: cell
# rows: 3
# columns: 1622
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
@ftp/ascii


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 308
 -- Function File: ascii (F)
     Set the FTP connection F to use ASCII mode for transfers.

     ASCII mode is only appropriate for text files as it will convert the remote host's newline representation to the local host's newline representation.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Set the FTP connection F to use ASCII mode for transfers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
@ftp/binary


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 270
 -- Function File: binary (F)
     Set the FTP connection F to use binary mode for transfers.

     In binary mode there is no conversion of newlines from the remote representation to the local representation.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Set the FTP connection F to use binary mode for transfers.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
@ftp/cd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 456
 -- Function File: cd (F)
 -- Function File: cd (F, PATH)
     Get or set the remote directory on the FTP connection F.

     F is an FTP object returned by the 'ftp' function.

     If PATH is not specified, return the remote current working directory.  Otherwise, set the remote directory to PATH and return the new remote working directory.

     If the directory does not exist, an error message is printed and the working directory is not changed.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Get or set the remote directory on the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
@ftp/close


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
 -- Function File: close (F)
     Close the FTP connection represented by the FTP object F.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Close the FTP connection represented by the FTP object F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
@ftp/delete


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 156
 -- Function File: delete (F, FILE)
     Delete the remote file FILE over the FTP connection F.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Delete the remote file FILE over the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
@ftp/dir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 167
 -- Function File: LST = dir (F)
     List the current directory in verbose form for the FTP connection F.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
List the current directory in verbose form for the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
@ftp/ftp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3633
 -- Function File: F = ftp (HOST)
 -- Function File: F = ftp (HOST, USERNAME, PASSWORD)
     Connect to the FTP server HOST with USERNAME and PASSWORD.

     If USERNAME and PASSWORD are not specified, user "anonymous" with no password is used.  The returned FTP object F represents the established FTP connection.

     The list of actions for an FTP object are shown below.  All functions require an FTP object as the first argument.

     Method                                                                                                                                                     Description
     ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     ascii                                                                                                                                                      Set transfer type to ascii
     binary                                                                                                                                                     Set transfer type to binary
     cd                                                                                                                                                         Change remote working directory
     close                                                                                                                                                      Close FTP connection
     delete                                                                                                                                                     Delete remote file
     dir                                                                                                                                                        List remote directory contents
     mget                                                                                                                                                       Download remote files
     mkdir                                                                                                                                                      Create remote directory
     mput                                                                                                                                                       Upload local files
     rename                                                                                                                                                     Rename remote file or directory
     rmdir                                                                                                                                                      Remove remote directory

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Connect to the FTP server HOST with USERNAME and PASSWORD.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
@ftp/mget


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 573
 -- Function File: mget (F, FILE)
 -- Function File: mget (F, DIR)
 -- Function File: mget (F, REMOTE_NAME, TARGET)
     Download a remote file FILE or directory DIR to the local directory on the FTP connection F.

     F is an FTP object returned by the 'ftp' function.

     The arguments FILE and DIR can include wildcards and any files or directories on the remote server that match will be downloaded.

     If a third argument TARGET is given, then a single file or directory will be downloaded to the local directory and the local name will be changed to TARGET.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 92
Download a remote file FILE or directory DIR to the local directory on the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
@ftp/mkdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function File: mkdir (F, PATH)
     Create the remote directory PATH, over the FTP connection F.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Create the remote directory PATH, over the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
@ftp/mput


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 310
 -- Function File: mput (F, FILE)
     Upload the local file FILE into the current remote directory on the FTP connection F.

     F is an FTP object returned by the ftp function.

     The argument FILE is passed through the 'glob' function and any files that match the wildcards in FILE will be uploaded.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Upload the local file FILE into the current remote directory on the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
@ftp/rename


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 202
 -- Function File: rename (F, OLDNAME, NEWNAME)
     Rename or move the remote file or directory OLDNAME to NEWNAME, over the FTP connection F.

     F is an FTP object returned by the ftp function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Rename or move the remote file or directory OLDNAME to NEWNAME, over the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
@ftp/rmdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 161
 -- Function File: rmdir (F, PATH)
     Remove the remote directory PATH, over the FTP connection F.

     F is an FTP object returned by the 'ftp' function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Remove the remote directory PATH, over the FTP connection F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
lin2mu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 353
 -- Function File: lin2mu (X, N)
     Convert 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 of values in X.

     See also: mu2lin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Convert audio data from linear to mu-law.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mu2lin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 301
 -- Function File: mu2lin (X, N)
     Convert audio data from mu-law to linear.

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

     See also: lin2mu.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Convert audio data from mu-law to linear.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
record


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 387
 -- Function File: record (SEC)
 -- Function File: record (SEC, FS)
     Record SEC seconds of audio from the system's default audio input at a sampling rate of 8000 samples per second.

     If the optional argument FS is given, it specifies the sampling rate for recording.

     For more control over audio recording, use the 'audiorecorder' class.

     See also: sound, soundsc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 112
Record SEC seconds of audio from the system's default audio input at a sampling rate of 8000 samples per second.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
sound


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 588
 -- Function File: sound (Y)
 -- Function File: sound (Y, FS)
 -- Function File: sound (Y, FS, NBITS)
     Play audio data Y at sample rate FS to the default audio device.

     The audio signal Y can be a vector or a two-column array, representing mono or stereo audio, respectively.

     If FS is not given, a default sample rate of 8000 samples per second is used.

     The optional argument NBITS specifies the bit depth to play to the audio device and defaults to 8 bits.

     For more control over audio playback, use the 'audioplayer' class.

     See also: soundsc, record.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Play audio data Y at sample rate FS to the default audio device.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
soundsc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 868
 -- Function File: soundsc (Y)
 -- Function File: soundsc (Y, FS)
 -- Function File: soundsc (Y, FS, NBITS)
 -- Function File: soundsc (..., [YMIN, YMAX])
     Scale the audio data Y and play it at sample rate FS to the default audio device.

     The audio signal Y can be a vector or a two-column array, representing mono or stereo audio, respectively.

     If FS is not given, a default sample rate of 8000 samples per second is used.

     The optional argument NBITS specifies the bit depth to play to the audio device and defaults to 8 bits.

     By default, Y is automatically normalized to the range [-1, 1].  If the range [YMIN, YMAX] is given, then elements of Y that fall within the range YMIN <= Y <= YMAX are scaled to the range [-1, 1] instead.

     For more control over audio playback, use the 'audioplayer' class.

     See also: sound, record.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 81
Scale the audio data Y and play it at sample rate FS to the default audio device.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wavread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1315
 -- Function File: Y = wavread (FILENAME)
 -- Function File: [Y, FS, NBITS] = wavread (FILENAME)
 -- Function File: [...] = wavread (FILENAME, N)
 -- Function File: [...] = wavread (FILENAME, [N1 N2])
 -- Function File: [...] = wavread (..., DATATYPE)
 -- Function File: SZ = wavread (FILENAME, "size")
 -- Function File: [N_SAMP, N_CHAN] = wavread (FILENAME, "size")
     Read the audio signal Y from the RIFF/WAVE sound file FILENAME.

     If the file contains multichannel data, then Y is a matrix with the channels represented as columns.

     If N is specified, only the first N samples of the file are returned.  If [N1 N2] is specified, only the range of samples from N1 to N2 is returned.  A value of 'Inf' can be used to represent the total number of samples in the file.

     If the option "size" is given, then the size of the audio signal is returned instead of the data.  The size is returned in a row vector of the form [SAMPLES CHANNELS].  If there are two output arguments, the number of samples is assigned to the first and the number of channels is assigned to the second.

     The optional return value FS is the sample rate of the audio file in Hz.  The optional return value NBITS is the number of bits per sample as encoded in the file.

     See also: audioread, audiowrite, wavwrite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Read the audio signal Y from the RIFF/WAVE sound file FILENAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
wavwrite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 601
 -- Function File: wavwrite (Y, FILENAME)
 -- Function File: wavwrite (Y, FS, FILENAME)
 -- Function File: wavwrite (Y, FS, NBITS, FILENAME)
     Write the audio signal Y to the RIFF/WAVE sound file FILENAME.

     If Y is a matrix, the columns represent multiple audio channels.

     The optional argument FS specifies the sample rate of the audio signal in Hz.

     The optional argument NBITS specifies the number of bits per sample to write to FILENAME.

     The default sample rate is 8000 Hz and the default bit depth is 16 bits per sample.

     See also: audiowrite, audioread, wavread.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Write the audio signal Y to the RIFF/WAVE sound file FILENAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
@audioplayer/__get_properties__


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function File: PROPERTIES = __get_properties__ (PLAYER)
     Return a struct containing all named properties of the audioplayer object PLAYER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 81
Return a struct containing all named properties of the audioplayer object PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
@audioplayer/audioplayer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 922
 -- Function File: PLAYER = audioplayer (Y, FS)
 -- Function File: PLAYER = audioplayer (Y, FS, NBITS)
 -- Function File: PLAYER = audioplayer (Y, FS, NBITS, ID)
 -- Function File: PLAYER = audioplayer (RECORDER)
 -- Function File: PLAYER = audioplayer (RECORDER, ID)
     Create an audioplayer object that will play back data Y at sample rate FS.

     The optional arguments NBITS, and ID specify the bit depth and player device id, respectively.  Device IDs may be found using the audiodevinfo function.  Given an audioplayer object, use the data from the object to initialize the player.

     The signal Y can be a vector or a two-dimensional array.

     The following example will create an audioplayer object that will play back one second of white noise at 44100 sample rate using 8 bits per sample.

          y = randn (2, 44100) - 0.5;
          player = audioplayer (y, 44100, 8);
          play (player);
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Create an audioplayer object that will play back data Y at sample rate FS.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
@audioplayer/display


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
 -- Function File: display (PLAYER)
     Display the properties of the audioplayer object PLAYER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Display the properties of the audioplayer object PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
@audioplayer/get


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 422
 -- Function File: VALUE = get (PLAYER, NAME)
 -- Function File: VALUES = get (PLAYER)
     Return the VALUE of the property identified by NAME.

     If NAME is a cell array return the values of the properties identified by the elements of the cell array.  Given only the player object, return a scalar structure with values of all properties of PLAYER.  The field names of the structure correspond to property names.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return the VALUE of the property identified by NAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
@audioplayer/isplaying


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
 -- Function File: isplaying (PLAYER)
     Return true if the audioplayer object PLAYER is currently playing back audio and false otherwise.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Return true if the audioplayer object PLAYER is currently playing back audio and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
@audioplayer/pause


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
 -- Function File: pause (PLAYER)
     Pause the audioplayer PLAYER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Pause the audioplayer PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
@audioplayer/play


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 401
 -- Function File: play (PLAYER)
 -- Function File: play (PLAYER, START)
 -- Function File: play (PLAYER, LIMITS)
     Play audio stored in the audioplayer object PLAYER without blocking.

     Given optional argument start, begin playing at START seconds in the recording.  Given a two-element vector LIMITS, begin and end playing at the number of seconds specified by the elements of the vector.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Play audio stored in the audioplayer object PLAYER without blocking.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
@audioplayer/playblocking


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 422
 -- Function File: playblocking (PLAYER)
 -- Function File: playblocking (PLAYER, START)
 -- Function File: playblocking (PLAYER, LIMITS)
     Play audio stored in the audioplayer object PLAYER with blocking.

     Given optional argument start, begin playing at START seconds in the recording.  Given a two-element vector LIMITS, begin and end playing at the number of seconds specified by the elements of the vector.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Play audio stored in the audioplayer object PLAYER with blocking.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
@audioplayer/resume


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
 -- Function File: resume (PLAYER)
     Resume playback for the paused audioplayer object PLAYER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Resume playback for the paused audioplayer object PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
@audioplayer/set


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 503
 -- Function File: set (PLAYER, NAME, VALUE)
 -- Function File: set (PLAYER, PROPERTIES)
 -- Function File: PROPERTIES = set (PLAYER)
     Set the value of property specified by NAME to a given VALUE.

     If NAME and VALUE are cell arrays, set each property to the corresponding value.  Given a structure of PROPERTIES with fields corresponding to property names, set the value of those properties to the field values.  Given only the audioplayer object, return a structure of settable properties.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Set the value of property specified by NAME to a given VALUE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
@audioplayer/stop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
 -- Function File: stop (PLAYER)
     Stop the playback for the audioplayer PLAYER and reset the relevant variables to their starting values.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Stop the playback for the audioplayer PLAYER and reset the relevant variables to their starting values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
@audioplayer/subsasgn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 196
 -- Function File: VALUE = subsasgn (PLAYER, IDX, RHS)
     Perform subscripted assignment on the audio player object PLAYER.

     Assign the value of RHS to the player property named by IDX.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Perform subscripted assignment on the audio player object PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
@audioplayer/subsref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 175
 -- Function File: VALUE = subsref (PLAYER, IDX)
     Perform subscripted selection on the audio player object PLAYER.

     Return the player property value named by IDX.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Perform subscripted selection on the audio player object PLAYER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
@audiorecorder/__get_properties__


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function File: PROPERTIES = __get_properties__ (RECORDER)
     Return a struct containing all named properties of the recorder object RECORDER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return a struct containing all named properties of the recorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
@audiorecorder/audiorecorder


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 482
 -- Function File: RECORDER = audiorecorder ()
 -- Function File: RECORDER = audiorecorder (FS, NBITS, CHANNELS)
 -- Function File: RECORDER = audiorecorder (FS, NBITS, CHANNELS, ID)
     Create an audiorecorder object recording 8 bit mono audio at 8000 Hz sample rate.

     The optional arguments FS, NBITS, CHANNELS, and ID specify the sample rate, bit depth, number of channels and recording device id, respectively.  Device IDs may be found using the audiodevinfo function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 81
Create an audiorecorder object recording 8 bit mono audio at 8000 Hz sample rate.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
@audiorecorder/display


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 107
 -- Function File: display (RECORDER)
     Display the properties of the audiorecorder object RECORDER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Display the properties of the audiorecorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
@audiorecorder/get


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 434
 -- Function File: VALUE = get (RECORDER, NAME)
 -- Function File: VALUES = get (RECORDER)
     Return the VALUE of the property identified by NAME.

     If NAME is a cell array, return the values of the properties corresponding to the elements of the cell array.  Given only the recorder object, return a scalar structure with values of all properties of RECORDER.  The field names of the structure correspond to property names.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return the VALUE of the property identified by NAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
@audiorecorder/getaudiodata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 415
 -- Function File: DATA = getaudiodata (RECORDER)
 -- Function File: DATA = getaudiodata (RECORDER, DATATYPE)
     Return recorder audio data as a matrix with values between -1.0 and 1.0 and with as many columns as there are channels in the recorder.

     Given the optional argument DATATYPE, convert the recorded data to the specified type, which may be one of "double", "single", "int16", "int8" or "uint8".
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Return recorder audio data as a matrix with values between -1.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
@audiorecorder/getplayer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
 -- Function File: PLAYER = getplayer (RECORDER)
     Return an audioplayer object with data recorded by the audiorecorder object RECORDER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Return an audioplayer object with data recorded by the audiorecorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
@audiorecorder/isrecording


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
 -- Function File: isrecording (RECORDER)
     Return true if the audiorecorder object RECORDER is currently recording audio and false otherwise.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 98
Return true if the audiorecorder object RECORDER is currently recording audio and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
@audiorecorder/pause


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 96
 -- Function File: pause (RECORDER)
     Pause recording with audiorecorder object RECORDER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Pause recording with audiorecorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
@audiorecorder/play


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 437
 -- Function File: PLAYER = play (RECORDER)
 -- Function File: PLAYER = play (RECORDER, START)
 -- Function File: PLAYER = play (RECORDER, [START, END])
     Play the audio recorded in RECORDER and return a corresponding audioplayer object.

     If the optional argument START is provided, begin playing START seconds in to the recording.

     If the optional argument END is provided, stop playing at END seconds in the recording.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 82
Play the audio recorded in RECORDER and return a corresponding audioplayer object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
@audiorecorder/record


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: record (RECORDER)
 -- Function File: record (RECORDER, LENGTH)
     Record audio without blocking using the audiorecorder object RECORDER until stopped or paused by the STOP or PAUSE method.

     Given the optional argument LENGTH, record for LENGTH seconds.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
Record audio without blocking using the audiorecorder object RECORDER until stopped or paused by the STOP or PAUSE method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
@audiorecorder/recordblocking


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- Function File: recordblocking (RECORDER, LENGTH)
     Record audio with blocking (synchronous I/O).

     The length of the recording in seconds (LENGTH) must be specified.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Record audio with blocking (synchronous I/O).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
@audiorecorder/resume


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
 -- Function File: resume (RECORDER)
     Resume recording with the paused audiorecorder object RECORDER.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Resume recording with the paused audiorecorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
@audiorecorder/set


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 521
 -- Function File: set (RECORDER, NAME, VALUE)
 -- Function File: set (RECORDER, PROPERTIES)
 -- Function File: PROPERTIES = set (RECORDER)
     Set the value of property specified by NAME to a given VALUE.

     If NAME and VALUE are cell arrays of the same size, set each property to a corresponding value.  Given a structure with fields corresponding to property names, set the value of those properties to the corresponding field values.  Given only the recorder object, return a structure of settable properties.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Set the value of property specified by NAME to a given VALUE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
@audiorecorder/stop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 114
 -- Function File: stop (RECORDER)
     Stop the audiorecorder object RECORDER and clean up any audio streams.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Stop the audiorecorder object RECORDER and clean up any audio streams.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
@audiorecorder/subsasgn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 204
 -- Function File: VALUE = subsasgn (RECORDER, IDX, RHS)
     Perform subscripted assignment on the audio recorder object RECORDER.

     Assign the value of RHS to the recorder property named by IDX.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Perform subscripted assignment on the audio recorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
@audiorecorder/subsref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 183
 -- Function File: VALUE = subsref (RECORDER, IDX)
     Perform subscripted selection on the audio recorder object RECORDER.

     Return the recorder property value named by IDX.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Perform subscripted selection on the audio recorder object RECORDER.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bicubic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 479
 -- Function File: ZI = bicubic (X, Y, Z, XI, YI, EXTRAPVAL)

     'bicubic' is deprecated and will be removed in Octave version 4.4.  Use 'interp2 (..., "spline")' for the equivalent functionality.

     Return a matrix ZI corresponding to the bicubic interpolations at XI and YI of the data supplied as X, Y and Z.  Points outside the grid are set to EXTRAPVAL.

     See <http://wiki.woodpecker.org.cn/moin/Octave/Bicubic> for further information.

     See also: interp2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
'bicubic' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
default_save_options


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 298
 -- Built-in Function: VAL = default_save_options ()
 -- Built-in Function: OLD_VAL = default_save_options (NEW_VAL)
 -- Built-in Function: default_save_options (NEW_VAL, "local")
     This function has been deprecated.  Use 'save_default_options' instead.

     See also: save_default_options.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
delaunay3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1403
 -- Function File: TETR = delaunay3 (X, Y, Z)
 -- Function File: TETR = delaunay3 (X, Y, Z, OPTIONS)

     'delaunay3' is deprecated and will be removed in Octave version 4.4.  Please use 'delaunay' in all new code.

     Compute the Delaunay triangulation for a 3-D set of points.  The return value TETR is a set of tetrahedrons which satisfies the Delaunay circum-circle criterion, i.e., only a single data point from [X, Y, Z] is within the circum-circle of the defining tetrahedron.

     The set of tetrahedrons TETR is a matrix of size [n, 4].  Each row defines a tetrahedron and the four columns are the four vertices of the tetrahedron.  The value of 'TETR(i,j)' is an index into X, Y, Z for the location of the j-th vertex of the i-th tetrahedron.

     An optional fourth argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.  The default options are '{"Qt", "Qbb", "Qc", "Qz"}'.

     If OPTIONS is not present or '[]' then the default arguments are used.  Otherwise, OPTIONS replaces the default argument list.  To append user options to the defaults it is necessary to repeat the default arguments in OPTIONS.  Use a null string to pass no arguments.

     See also: delaunay, delaunayn, convhull, voronoi, tetramesh.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
'delaunay3' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
dump_prefs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 485
 -- Function File: dump_prefs ()
 -- Function File: dump_prefs (FID)

     'dump_prefs' is deprecated and will be removed in Octave version 4.4.  Please use individual preference get/set routines in all new code.

     Dump the current settings of all user preferences to stdout in a format that can be parsed by Octave later.

     If the optional argument FID is given then the results are written to the file specified by file descriptor FID.

     See also: octave_config_info.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
'dump_prefs' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
find_dir_in_path


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 207
 -- Built-in Function: find_dir_in_path (DIR)
 -- Built-in Function: find_dir_in_path (DIR, "all")
     This function has been deprecated.  Use 'dir_in_loadpath' instead.

     See also: dir_in_loadpath.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
finite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 395
 -- Mapping Function: finite (X)

     'finite' is deprecated and will be removed in Octave version 4.4.  Please use 'isfinite' in all new code.

     Return a logical array which is true where the elements of X are finite values and false where they are not.  For example:

          finite ([13, Inf, NA, NaN])
               => [ 1, 0, 0, 0 ]

     See also: isfinite, isinf, isnan, isna.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
'finite' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fmod


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 408
 -- Mapping Function: fmod (X, Y)

     'fmod' is deprecated and will be removed in Octave version 4.4.  Please use 'rem' in all new code.

     Return the remainder of the division 'X / Y', computed using the expression

          x - y .* fix (x ./ y)

     An error message is printed if the dimensions of the arguments do not agree, or if either of the arguments is complex.

     See also: rem, mod.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
'fmod' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fnmatch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 470
 -- Built-in Function: fnmatch (PATTERN, STRING)

     'fnmatch' is deprecated and will be removed in Octave version 4.4.  Please use 'glob' or 'regexp' in all new code.

     Return true or false 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 ]

     See also: glob, regexp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
'fnmatch' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
gen_doc_cache


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
 -- Function File: gen_doc_cache (OUT_FILE, DIRECTORY)
     This function has been deprecated.  Use 'doc_cache_create' instead.

     See also: doc_cache_create.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gmap40


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 550
 -- Function File: MAP = gmap40 ()
 -- Function File: MAP = gmap40 (N)

     'gmap40' is deprecated and will be removed in Octave version 4.4.

     Create color colormap.  The colormap consists of red, green, blue, yellow, magenta and cyan.

     This colormap is specifically designed for users of gnuplot 4.0 where these 6 colors are the allowable ones for patch objects.

     The argument N must be a scalar.  If unspecified, a length of 6 is assumed.  Larger values of N result in a repetition of the above colors.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
'gmap40' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
interp1q


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 762
 -- Function File: YI = interp1q (X, Y, XI)
     One-dimensional linear interpolation without error checking.  Interpolates Y, defined at the points X, at the points XI.  The sample points X must be a strictly monotonically increasing column vector.  If Y is a matrix or an N-dimensional array, the interpolation is performed on each column of Y.  If Y is a vector, it must be a column vector of the same length as X.

     Values of XI beyond the endpoints of the interpolation result in NA being returned.

     Note that the error checking is only a significant portion of the execution time of this 'interp1' if the size of the input arguments is relatively small.  Therefore, the benefit of using 'interp1q' is relatively small.

     See also: interp1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
One-dimensional linear interpolation without error checking.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
isequalwithequalnans


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: isequalwithequalnans (X1, X2, ...)
     This function has been deprecated.  Use 'isequaln' instead.

     See also: isequaln.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
isstr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 93
 -- Function File: isstr (A)
     This function has been deprecated.  Use ischar instead.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
java_convert_matrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 626
 -- Built-in Function: VAL = java_convert_matrix ()
 -- Built-in Function: OLD_VAL = java_convert_matrix (NEW_VAL)
 -- Built-in Function: java_convert_matrix (NEW_VAL, "local")
     Query or set the internal variable that controls whether Java arrays are automatically converted to Octave matrices.  The default value is false.

     When called from inside a function with the "local" option, the variable is changed locally for the function and any subroutines it calls.  The original variable value is restored when exiting the function.

     See also: java_matrix_autoconversion, java_unsigned_conversion, java_debug.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
Query or set the internal variable that controls whether Java arrays are automatically converted to Octave matrices.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
java_debug


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 609
 -- Built-in Function: VAL = java_debug ()
 -- Built-in Function: OLD_VAL = java_debug (NEW_VAL)
 -- Built-in Function: java_debug (NEW_VAL, "local")
     Query or set the internal variable that determines whether extra debugging information regarding the initialization of the JVM and any Java exceptions is printed.

     When called from inside a function with the "local" option, the variable is changed locally for the function and any subroutines it calls.  The original variable value is restored when exiting the function.

     See also: debug_java, java_convert_matrix, java_unsigned_conversion.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 162
Query or set the internal variable that determines whether extra debugging information regarding the initialization of the JVM and any Java exceptions is printed.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
java_invoke


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 690
 -- Built-in Function: RET = java_invoke (OBJ, METHODNAME)
 -- Built-in Function: RET = java_invoke (OBJ, METHODNAME, ARG1, ...)
     Invoke the method METHODNAME on the Java object OBJ with the arguments ARG1, ... For static methods, OBJ can be a string representing the fully qualified name of the corresponding class.  The function returns the result of the method invocation.

     When OBJ is a regular Java object, structure-like indexing can be used as a shortcut syntax.  For instance, the two following statements are equivalent

            ret = java_invoke (x, "method1", 1.0, "a string")
            ret = x.method1 (1.0, "a string")

     See also: javaMethod, javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Invoke the method METHODNAME on the Java object OBJ with the arguments ARG1, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
java_new


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 -- Loadable Function: OBJ = java_new (NAME)
 -- Loadable Function: OBJ = java_new (NAME, ARG1, ...)
     Create a Java object of class NAME, by calling the class constructor with the arguments ARG1, ...

            x = java_new ("java.lang.StringBuffer")
            x = java_new ("java.lang.StringBuffer", "Initial string")

     See also: javaObject, javaMethod.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Create a Java object of class NAME, by calling the class constructor with the arguments ARG1, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
java_unsigned_conversion


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 736
 -- Built-in Function: VAL = java_unsigned_conversion ()
 -- Built-in Function: OLD_VAL = java_unsigned_conversion (NEW_VAL)
 -- Built-in Function: java_unsigned_conversion (NEW_VAL, "local")
     Query or set the internal variable that controls how integer classes are converted when Java matrix autoconversion is enabled.  When enabled, Java arrays of class Byte or Integer are converted to matrices of class uint8 or uint32 respectively.

     When called from inside a function with the "local" option, the variable is changed locally for the function and any subroutines it calls.  The original variable value is restored when exiting the function.

     See also: java_unsigned_autoconversion, java_convert_matrix, debug_java.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
Query or set the internal variable that controls how integer classes are converted when Java matrix autoconversion is enabled.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
javafields


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 347
 -- Function File: javafields (JAVAOBJ)
 -- Function File: javafields ("CLASSNAME")
 -- Function File: FLD_NAMES = javafields (...)
     Return the fields of a Java object or Java class in the form of a cell array of strings.  If no output is requested, print the result to the standard output.

     See also: fieldnames, methods, javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 88
Return the fields of a Java object or Java class in the form of a cell array of strings.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
javamethods


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 363
 -- Function File: javamethods (JAVAOBJ)
 -- Function File: javamethods ("CLASSNAME")
 -- Function File: MTD_NAMES = javamethods (...)
     Return the methods of a Java object or Java class in the form of a cell array of strings.  If no output is requested, print the result to the standard output.

     See also: methods, fieldnames, javaMethod, javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Return the methods of a Java object or Java class in the form of a cell array of strings.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
loadaudio


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 628
 -- Function File: loadaudio (NAME, EXT, BPS)

     'loadaudio' is deprecated and will be removed in Octave version 4.4.  Please use 'audioread' in all new code.

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

     See also: lin2mu, mu2lin, saveaudio, playaudio, setaudio, record.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
'loadaudio' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
luinc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2405
 -- Built-in Function: [L, U, P, Q] = luinc (A, '0')
 -- Built-in Function: [L, U, P, Q] = luinc (A, DROPTOL)
 -- Built-in Function: [L, U, P, Q] = luinc (A, OPTS)

     'luinc' is deprecated and will be removed in Octave version 4.4.  Please use 'ilu' or 'ichol' in all new code.

     Produce the incomplete LU factorization of the sparse matrix A.  Two types of incomplete factorization are possible, and the type is determined by the second argument to 'luinc'.

     Called with a second argument of '0', the zero-level incomplete LU factorization is produced.  This creates a factorization of A where the position of the nonzero arguments correspond to the same positions as in the matrix A.

     Alternatively, the fill-in of the incomplete LU factorization can be controlled through the variable DROPTOL or the structure OPTS.  The UMFPACK multifrontal factorization code by Tim A. Davis is used for the incomplete LU factorization, (availability <http://www.cise.ufl.edu/research/sparse/umfpack/>)

     DROPTOL determines the values below which the values in the LU  factorization are dropped and replaced by zero.  It must be a positive scalar, and any values in the factorization whose absolute value are less than this value are dropped, expect if leaving them increase the sparsity of the matrix.  Setting DROPTOL to zero results in a complete LU factorization which is the default.

     OPTS is a structure containing one or more of the fields

     'droptol'
          The drop tolerance as above.  If OPTS only contains 'droptol' then this is equivalent to using the variable DROPTOL.

     'milu'
          A logical variable flagging whether to use the modified incomplete LU  factorization.  In the case that 'milu' is true, the dropped values are subtracted from the diagonal of the matrix U of the factorization.  The default is 'false'.

     'udiag'
          A logical variable that flags whether zero elements on the diagonal of U should be replaced with DROPTOL to attempt to avoid singular factors.  The default is 'false'.

     'thresh'
          Defines the pivot threshold in the interval [0,1].  Values outside that range are ignored.

     All other fields in OPTS are ignored.  The outputs from 'luinc' are the same as for 'lu'.

     Given the string argument \"vector\", 'luinc' returns the values of P Q as vector values.

     See also: ilu, ichol, lu, sparse.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
'luinc' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
mouse_wheel_zoom


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 390
 -- Loadable Function: OLD_VAL = mouse_wheel_zoom (NEW_VAL)
     Query or set the mouse wheel zoom factor.

     The zoom factor is a number in the range (0,1) which is the percentage of the current axis limits that will be used when zooming.  For example, if the current x-axis limits are [0, 50] and 'mouse_wheel_zoom' is 0.4 (40%), then a zoom operation will change the limits by 20.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Query or set the mouse wheel zoom factor.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nfields


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 220
 -- Function File: nfields (S)
     Return the number of fields of the structure S.

     *Warning:* 'nfields' is scheduled for removal in version 4.4.  Use 'numfields' instead.

     See also: numfields, fieldnames.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Return the number of fields of the structure S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
octave_tmp_file_name


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 680
 -- Built-in Function: FNAME = octave_tmp_file_name ()
 -- Built-in Function: FNAME = octave_tmp_file_name (DIR)
 -- Built-in Function: FNAME = octave_tmp_file_name (DIR, PREFIX)

     'octave_tmp_file_name' is deprecated and will be removed in Octave version 4.4.  Use 'tempname' for equivalent functionality.

     Return a unique temporary file name as a string.

     If PREFIX is omitted, a value of "oct-" is used.  If DIR is also omitted, the default directory for temporary files ('P_tmpdir' is used.  If DIR is provided, it must exist, otherwise the default directory for temporary files is used.

     See also: tempname, tmpnam, mkstemp, tempdir, P_tmpdir, tmpfile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
'octave_tmp_file_name' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
playaudio


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 346
 -- Function File: playaudio (NAME, EXT)
 -- Function File: playaudio (X)

     'playaudio' is deprecated and will be removed in Octave version 4.4.  Please use 'audioplayer' in all new code.

     Play the audio file 'NAME.EXT' or the audio data stored in the vector X.

     See also: lin2mu, mu2lin, loadaudio, saveaudio, setaudio, record.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
'playaudio' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
re_read_readline_init_file


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 184
 -- Built-in Function: re_read_readline_init_file (FILE)
     This function has been deprecated.  Use 'readline_re_read_init_file' instead.

     See also: readline_read_init_file.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
read_readline_init_file


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 178
 -- Built-in Function: read_readline_init_file (FILE)
     This function has been deprecated.  Use 'readline_read_init_file' instead.

     See also: readline_read_init_file.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
saveaudio


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 477
 -- Function File: saveaudio (NAME, X, EXT, BPS)

     'saveaudio' is deprecated and will be removed in Octave version 4.4.  Please use 'audiowrite' in all new code.

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

     See also: lin2mu, mu2lin, loadaudio, playaudio, setaudio, record.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
'saveaudio' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
saving_history


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 264
 -- Built-in Function: VAL = saving_history ()
 -- Built-in Function: OLD_VAL = saving_history (NEW_VAL)
 -- Built-in Function: saving_history (NEW_VAL, "local")
     This function has been deprecated.  Use 'history_save' instead.

     See also: history_save.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
This function has been deprecated.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
setaudio


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 412
 -- Function File: setaudio ()
 -- Function File: setaudio (W_TYPE)
 -- Function File: setaudio (W_TYPE, VALUE)

     'setaudio' is deprecated and will be removed in Octave version 4.4.  Please scale the audio signal in all new code or use the operating system's native tools to adjust audio input and output levels.

     Execute the shell command 'mixer', possibly with optional arguments W_TYPE and VALUE.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
'setaudio' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
syl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 403
 -- Built-in Function: X = syl (A, B, C)

     'syl' is deprecated and will be removed in Octave version 4.4.  Use 'sylvester' for the equivalent functionality.

     Solve the Sylvester equation

          A X + X B + C = 0

     using standard LAPACK subroutines.  For example:

          syl ([1, 2; 3, 4], [5, 6; 7, 8], [9, 10; 11, 12])
             => [ -0.50000, -0.66667; -0.66667, -0.50000 ]
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
'syl' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
usage


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 959
 -- Built-in Function: usage (MSG)

     'usage' is deprecated and will be removed in Octave version 4.4.  Please use 'print_usage' in all new code.

     Print the message MSG, prefixed by the string 'usage: ', and set Octave's internal error state such that control will return to the top level without evaluating any more commands.  This is useful for aborting from functions.

     After 'usage' is evaluated, Octave will print a traceback of all the function calls leading to the usage message.

     You should use this function for reporting problems errors that result from an improper call to a function, such as calling a function with an incorrect number of arguments, or with arguments of the wrong type.  For example, most functions distributed with Octave begin with code like this

          if (nargin != 2)
            usage (\"foo (a, b)\");
          endif

     to check for the proper number of arguments.

     See also: print_usage.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
'usage' is deprecated and will be removed in Octave version 4.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
acosd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 -- Function File: acosd (X)
     Compute the inverse cosine in degrees for each element of X.

     See also: cosd, acos.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Compute the inverse cosine in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
acot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 131
 -- Mapping Function: acot (X)
     Compute the inverse cotangent in radians for each element of X.

     See also: cot, acotd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Compute the inverse cotangent in radians for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
acotd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
 -- Function File: acotd (X)
     Compute the inverse cotangent in degrees for each element of X.

     See also: cotd, acot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Compute the inverse cotangent in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
acoth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
 -- Mapping Function: acoth (X)
     Compute the inverse hyperbolic cotangent of each element of X.

     See also: coth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Compute the inverse hyperbolic cotangent of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
acsc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 130
 -- Mapping Function: acsc (X)
     Compute the inverse cosecant in radians for each element of X.

     See also: csc, acscd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Compute the inverse cosecant in radians for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
acscd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
 -- Function File: acscd (X)
     Compute the inverse cosecant in degrees for each element of X.

     See also: cscd, acsc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Compute the inverse cosecant in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
acsch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 124
 -- Mapping Function: acsch (X)
     Compute the inverse hyperbolic cosecant of each element of X.

     See also: csch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Compute the inverse hyperbolic cosecant of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
asec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
 -- Mapping Function: asec (X)
     Compute the inverse secant in radians for each element of X.

     See also: sec, asecd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Compute the inverse secant in radians for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
asecd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
 -- Function File: asecd (X)
     Compute the inverse secant in degrees for each element of X.

     See also: secd, asec.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Compute the inverse secant in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
asech


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
 -- Mapping Function: asech (X)
     Compute the inverse hyperbolic secant of each element of X.

     See also: sech.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Compute the inverse hyperbolic secant of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
asind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 124
 -- Function File: asind (X)
     Compute the inverse sine in degrees for each element of X.

     See also: sind, asin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Compute the inverse sine in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
atan2d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
 -- Function File: atan2d (Y, X)
     Compute atan2 (Y / X) in degrees for corresponding elements from Y and X.

     See also: tand, atan2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Compute atan2 (Y / X) in degrees for corresponding elements from Y and X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
atand


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 -- Function File: atand (X)
     Compute the inverse tangent in degrees for each element of X.

     See also: tand, atan.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Compute the inverse tangent in degrees for each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cosd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 183
 -- Function File: cosd (X)
     Compute the cosine for each element of X in degrees.

     Returns zero for elements where '(X-90)/180' is an integer.

     See also: acosd, cos.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute the cosine for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
cot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
 -- Mapping Function: cot (X)
     Compute the cotangent for each element of X in radians.

     See also: acot, cotd, coth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Compute the cotangent for each element of X in radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cotd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 120
 -- Function File: cotd (X)
     Compute the cotangent for each element of X in degrees.

     See also: acotd, cot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Compute the cotangent for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
coth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
 -- Mapping Function: coth (X)
     Compute the hyperbolic cotangent of each element of X.

     See also: acoth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Compute the hyperbolic cotangent of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
csc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
 -- Mapping Function: csc (X)
     Compute the cosecant for each element of X in radians.

     See also: acsc, cscd, csch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Compute the cosecant for each element of X in radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cscd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 119
 -- Function File: cscd (X)
     Compute the cosecant for each element of X in degrees.

     See also: acscd, csc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Compute the cosecant for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
csch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
 -- Mapping Function: csch (X)
     Compute the hyperbolic cosecant of each element of X.

     See also: acsch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compute the hyperbolic cosecant of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
sec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
 -- Mapping Function: sec (X)
     Compute the secant for each element of X in radians.

     See also: asec, secd, sech.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute the secant for each element of X in radians.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
secd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
 -- Function File: secd (X)
     Compute the secant for each element of X in degrees.

     See also: asecd, sec.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute the secant for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
sech


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 114
 -- Mapping Function: sech (X)
     Compute the hyperbolic secant of each element of X.

     See also: asech.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Compute the hyperbolic secant of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
sind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 176
 -- Function File: sind (X)
     Compute the sine for each element of X in degrees.

     Returns zero for elements where 'X/180' is an integer.

     See also: asind, sin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Compute the sine for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tand


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 235
 -- Function File: tand (X)
     Compute the tangent for each element of X in degrees.

     Returns zero for elements where 'X/180' is an integer and 'Inf' for elements where '(X-90)/180' is an integer.

     See also: atand, tan.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compute the tangent for each element of X in degrees.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
accumarray


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3911
 -- Function File: accumarray (SUBS, VALS, SZ, FUNC, FILLVAL, ISSPARSE)
 -- Function File: accumarray (SUBS, VALS, ...)

     Create an array by accumulating the elements of a vector into the positions defined by their subscripts.

     The subscripts are defined by the rows of the matrix SUBS and the values by VALS.  Each row of SUBS corresponds to one of the values in VALS.  If VALS is a scalar, it will be used for each of the row of SUBS.  If SUBS is a cell array of vectors, all vectors must be of the same length, and the subscripts in the Kth vector must correspond to the Kth dimension of the result.

     The size of the matrix will be determined by the subscripts themselves.  However, if SZ is defined it determines the matrix size.  The length of SZ must correspond to the number of columns in SUBS.  An exception is if SUBS has only one column, in which case SZ may be the dimensions of a vector and the subscripts of SUBS are taken as the indices into it.

     The default action of 'accumarray' is to sum the elements with the same subscripts.  This behavior can be modified by defining the FUNC function.  This should be a function or function handle that accepts a column vector and returns a scalar.  The result of the function should not depend on the order of the subscripts.

     The elements of the returned array that have no subscripts associated with them are set to zero.  Defining FILLVAL to some other value allows these values to be defined.  This behavior changes, however, for certain values of FUNC.  If FUNC is 'min' (respectively, 'max') then the result will be filled with the minimum (respectively, maximum) integer if VALS is of integral type, logical false (respectively, logical true) if VALS is of logical type, zero if FILLVAL is zero and all values are non-positive (respectively, non-negative), and NaN otherwise.

     By default 'accumarray' returns a full matrix.  If ISSPARSE is logically true, then a sparse matrix is returned instead.

     The following 'accumarray' example constructs a frequency table that in the first column counts how many occurrences each number in the second column has, taken from the vector X.  Note the usage of 'unique' for assigning to all repeated elements of X the same index (*note unique: XREFunique.).

          X = [91, 92, 90, 92, 90, 89, 91, 89, 90, 100, 100, 100];
          [U, ~, J] = unique (X);
          [accumarray(J', 1), U']
            =>  2    89
                3    90
                2    91
                2    92
                3   100

     Another example, where the result is a multi-dimensional 3-D array and the default value (zero) appears in the output:

          accumarray ([1, 1, 1;
                       2, 1, 2;
                       2, 3, 2;
                       2, 1, 2;
                       2, 3, 2], 101:105)
          => ans(:,:,1) = [101, 0, 0; 0, 0, 0]
          => ans(:,:,2) = [0, 0, 0; 206, 0, 208]

     The sparse option can be used as an alternative to the 'sparse' constructor (*note sparse: XREFsparse.).  Thus

          sparse (I, J, SV)

     can be written with 'accumarray' as

          accumarray ([I, J], SV', [], [], 0, true)

     For repeated indices, 'sparse' adds the corresponding value.  To take the minimum instead, use 'min' as an accumulator function:

          accumarray ([I, J], SV', [], @min, 0, true)

     The complexity of accumarray in general for the non-sparse case is generally O(M+N), where N is the number of subscripts and M is the maximum subscript (linearized in multi-dimensional case).  If FUNC is one of '@sum' (default), '@max', '@min' or '@(x) {x}', an optimized code path is used.  Note that for general reduction function the interpreter overhead can play a major part and it may be more efficient to do multiple accumarray calls and compute the results in a vectorized manner.

     See also: accumdim, unique, sparse.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 104
Create an array by accumulating the elements of a vector into the positions defined by their subscripts.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
accumdim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1581
 -- Function File: accumdim (SUBS, VALS, DIM, N, FUNC, FILLVAL)
     Create an array by accumulating the slices of an array into the positions defined by their subscripts along a specified dimension.

     The subscripts are defined by the index vector SUBS.  The dimension is specified by DIM.  If not given, it defaults to the first non-singleton dimension.  The length of SUBS must be equal to 'size (VALS, DIM)'.

     The extent of the result matrix in the working dimension will be determined by the subscripts themselves.  However, if N is defined it determines this extent.

     The default action of 'accumdim' is to sum the subarrays with the same subscripts.  This behavior can be modified by defining the FUNC function.  This should be a function or function handle that accepts an array and a dimension, and reduces the array along this dimension.  As a special exception, the built-in 'min' and 'max' functions can be used directly, and 'accumdim' accounts for the middle empty argument that is used in their calling.

     The slices of the returned array that have no subscripts associated with them are set to zero.  Defining FILLVAL to some other value allows these values to be defined.

     An example of the use of 'accumdim' is:

          accumdim ([1, 2, 1, 2, 1], [ 7, -10,   4;
                                      -5, -12,   8;
                                     -12,   2,   8;
                                     -10,   9,  -3;
                                      -5,  -3, -13])
          => [-10,-11,-1;-15,-3,5]

     See also: accumarray.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 130
Create an array by accumulating the slices of an array into the positions defined by their subscripts along a specified dimension.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bincoeff


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 502
 -- Mapping Function: bincoeff (N, K)
     Return the binomial coefficient of N and K, defined as

           /   \
           | n |    n (n-1) (n-2) ... (n-k+1)
           |   |  = -------------------------
           | k |               k!
           \   /

     For example:

          bincoeff (5, 2)
             => 10

     In most cases, the 'nchoosek' function is faster for small scalar integer arguments.  It also warns about loss of precision for big arguments.

     See also: nchoosek.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Return the binomial coefficient of N and K, defined as 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bitcmp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 367
 -- Function File: bitcmp (A, K)
     Return the K-bit complement of integers in A.

     If K is omitted 'k = log2 (bitmax) + 1' is assumed.

          bitcmp (7,4)
            => 8
          dec2bin (11)
            => 1011
          dec2bin (bitcmp (11, 6))
            => 110100

     See also: bitand, bitor, bitxor, bitset, bitget, bitcmp, bitshift, bitmax.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Return the K-bit complement of integers in A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bitget


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 289
 -- Function File: C = bitget (A, N)
     Return the status of bit(s) N of the unsigned integers in A.

     The least significant bit is N = 1.

          bitget (100, 8:-1:1)
          => 0  1  1  0  0  1  0  0

     See also: bitand, bitor, bitxor, bitset, bitcmp, bitshift, bitmax.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Return the status of bit(s) N of the unsigned integers in A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bitset


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 403
 -- Function File: C = bitset (A, N)
 -- Function File: C = bitset (A, N, VAL)
     Set or reset bit(s) N of the unsigned integers in A.

     VAL = 0 resets and VAL = 1 sets the bits.  The least significant bit is N = 1.  All variables must be the same size or scalars.

          dec2bin (bitset (10, 1))
            => 1011

     See also: bitand, bitor, bitxor, bitget, bitcmp, bitshift, bitmax.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Set or reset bit(s) N of the unsigned integers in A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
blkdiag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 298
 -- Function File: blkdiag (A, B, C, ...)
     Build a block diagonal matrix from A, B, C, ...

     All arguments must be numeric and either two-dimensional matrices or scalars.  If any argument is of type sparse, the output will also be sparse.

     See also: diag, horzcat, vertcat, sparse.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Build a block diagonal matrix from A, B, C, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cart2pol


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 804
 -- Function File: [THETA, R] = cart2pol (X, Y)
 -- Function File: [THETA, R, Z] = cart2pol (X, Y, Z)
 -- Function File: [THETA, R] = cart2pol (C)
 -- Function File: [THETA, R, Z] = cart2pol (C)
 -- Function File: P = cart2pol (...)

     Transform Cartesian coordinates to polar or cylindrical coordinates.

     The inputs X, Y (, and Z) must be the same shape, or scalar.  If called with a single matrix argument then each row of C represents the Cartesian coordinate (X, Y (, Z)).

     THETA describes the angle relative to the positive x-axis.

     R is the distance to the z-axis (0, 0, z).

     If only a single return argument is requested then return a matrix P where each row represents one polar/(cylindrical) coordinate (THETA, PHI (, Z)).

     See also: pol2cart, cart2sph, sph2cart.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Transform Cartesian coordinates to polar or cylindrical coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cart2sph


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 733
 -- Function File: [THETA, PHI, R] = cart2sph (X, Y, Z)
 -- Function File: [THETA, PHI, R] = cart2sph (C)
 -- Function File: S = cart2sph (...)
     Transform Cartesian coordinates to spherical coordinates.

     The inputs X, Y, and Z must be the same shape, or scalar.  If called with a single matrix argument then each row of C represents the Cartesian coordinate (X, Y, Z).

     THETA describes the angle relative to the positive x-axis.

     PHI is the angle relative to the xy-plane.

     R is the distance to the origin (0, 0, 0).

     If only a single return argument is requested then return a matrix S where each row represents one spherical coordinate (THETA, PHI, R).

     See also: sph2cart, cart2pol, pol2cart.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Transform Cartesian coordinates to spherical coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cell2mat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 322
 -- Function File: M = cell2mat (C)
     Convert the cell array C into a matrix by concatenating all elements of C into a hyperrectangle.

     Elements of C must be numeric, logical, or char matrices; or cell arrays; or structs; and 'cat' must be able to concatenate them together.

     See also: mat2cell, num2cell.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 96
Convert the cell array C into a matrix by concatenating all elements of C into a hyperrectangle.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
celldisp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 552
 -- Function File: celldisp (C)
 -- Function File: celldisp (C, NAME)
     Recursively display the contents of a cell array.

     By default the values are displayed with the name of the variable C.  However, this name can be replaced with the variable NAME.  For example:

          c = {1, 2, {31, 32}};
          celldisp (c, "b")
             =>
                b{1} =
                 1
                b{2} =
                 2
                b{3}{1} =
                 31
                b{3}{2} =
                 32

     See also: disp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Recursively display the contents of a cell array.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
chop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 334
 -- Function File: chop (X, NDIGITS, BASE)
     Truncate elements of X to a length of NDIGITS such that the resulting numbers are exactly divisible by BASE.

     If BASE is not specified it defaults to 10.

          chop (-pi, 5, 10)
             => -3.14200000000000
          chop (-pi, 5, 5)
             => -3.14150000000000
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
Truncate elements of X to a length of NDIGITS such that the resulting numbers are exactly divisible by BASE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
circshift


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 772
 -- Function File: Y = circshift (X, N)
     Circularly shift the values of the array X.

     N must be a vector of integers no longer than the number of dimensions in X.  The values of N can be either positive or negative, which determines the direction in which the values or X are shifted.  If an element of N is zero, then the corresponding dimension of X will not be shifted.  For example:

          x = [1, 2, 3; 4, 5, 6; 7, 8, 9];
          circshift (x, 1)
          =>  7, 8, 9
              1, 2, 3
              4, 5, 6
          circshift (x, -2)
          =>  7, 8, 9
              1, 2, 3
              4, 5, 6
          circshift (x, [0,1])
          =>  3, 1, 2
              6, 4, 5
              9, 7, 8

     See also: permute, ipermute, shiftdim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Circularly shift the values of the array X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
common_size


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 627
 -- Function File: [ERR, Y1, ...] = common_size (X1, ...)
     Determine if all input arguments are either scalar or of common size.

     If true, ERR is zero, and YI is a matrix of the common size with all entries equal to XI if this is a scalar or XI otherwise.  If the inputs cannot be brought to a common size, ERR is 1, and YI is XI.  For example:

          [errorcode, a, b] = common_size ([1 2; 3 4], 5)
               => errorcode = 0
               => a = [ 1, 2; 3, 4 ]
               => b = [ 5, 5; 5, 5 ]

     This is useful for implementing functions where arguments can either be scalars or of common size.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Determine if all input arguments are either scalar or of common size.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cplxpair


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 931
 -- Function File: cplxpair (Z)
 -- Function File: cplxpair (Z, TOL)
 -- Function File: cplxpair (Z, TOL, DIM)
     Sort the numbers Z into complex conjugate pairs ordered by increasing real part.

     The negative imaginary complex numbers are placed first within each pair.  All real numbers (those with 'abs (imag (Z) / Z) < TOL') are placed after the complex pairs.

     If TOL is unspecified the default value is 100*'eps'.

     By default the complex pairs are sorted along the first non-singleton dimension of Z.  If DIM is specified, then the complex pairs are sorted along this dimension.

     Signal an error if some complex numbers could not be paired.  Signal an error if all complex numbers are not exact conjugates (to within TOL).  Note that there is no defined order for pairs with identical real parts but differing imaginary parts.

          cplxpair (exp(2i*pi*[0:4]'/5)) == exp(2i*pi*[3; 2; 4; 1; 0]/5)
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Sort the numbers Z into complex conjugate pairs ordered by increasing real part.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cumtrapz


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 965
 -- Function File: Q = cumtrapz (Y)
 -- Function File: Q = cumtrapz (X, Y)
 -- Function File: Q = cumtrapz (..., DIM)
     Cumulative numerical integration of points Y using the trapezoidal method.

     'cumtrapz (Y)' computes the cumulative integral of Y along the first non-singleton dimension.  Where 'trapz' reports only the overall integral sum, 'cumtrapz' reports the current partial sum value at each point of Y.

     When the argument X is omitted an equally spaced X vector with unit spacing (1) is assumed.  'cumtrapz (X, Y)' evaluates the integral with respect to the spacing in X and the values in Y.  This is useful if the points in Y have been sampled unevenly.

     If the optional DIM argument is given, operate along this dimension.

     Application Note: If X is not specified then unit spacing will be used.  To scale the integral to the correct value you must multiply by the actual spacing value (deltaX).

     See also: trapz, cumsum.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Cumulative numerical integration of points Y using the trapezoidal method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
curl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 987
 -- Function File: [CX, CY, CZ, V] = curl (X, Y, Z, FX, FY, FZ)
 -- Function File: [CZ, V] = curl (X, Y, FX, FY)
 -- Function File: [...] = curl (FX, FY, FZ)
 -- Function File: [...] = curl (FX, FY)
 -- Function File: V = curl (...)
     Calculate curl of vector field given by the arrays FX, FY, and FZ or FX, FY respectively.

                            / d         d       d         d       d         d     \
          curl F(x,y,z)  =  | -- Fz  -  -- Fy,  -- Fx  -  -- Fz,  -- Fy  -  -- Fx |
                            \ dy        dz      dz        dx      dx        dy    /

     The coordinates of the vector field can be given by the arguments X, Y, Z or X, Y respectively.  V calculates the scalar component of the angular velocity vector in direction of the z-axis for two-dimensional input.  For three-dimensional input the scalar rotation is calculated at each grid point in direction of the vector field at that point.

     See also: divergence, gradient, del2, cross.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Calculate curl of vector field given by the arrays FX, FY, and FZ or FX, FY respectively.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dblquad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1203
 -- Function File: dblquad (F, XA, XB, YA, YB)
 -- Function File: dblquad (F, XA, XB, YA, YB, TOL)
 -- Function File: dblquad (F, XA, XB, YA, YB, TOL, QUADF)
 -- Function File: dblquad (F, XA, XB, YA, YB, TOL, QUADF, ...)
     Numerically evaluate the double integral of F.

     F is a function handle, inline function, or string containing the name of the function to evaluate.  The function F must have the form z = f(x,y) where X is a vector and Y is a scalar.  It should return a vector of the same length and orientation as X.

     XA, YA and XB, YB are the lower and upper limits of integration for x and y respectively.  The underlying integrator determines whether infinite bounds are accepted.

     The optional argument TOL defines the absolute tolerance used to integrate each sub-integral.  The default value is 1e^{-6}.

     The optional argument QUADF specifies which underlying integrator function to use.  Any choice but 'quad' is available and the default is 'quadcc'.

     Additional arguments, are passed directly to F.  To use the default value for TOL or QUADF one may pass ':' or an empty matrix ([]).

     See also: triplequad, quad, quadv, quadl, quadgk, quadcc, trapz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Numerically evaluate the double integral of F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
deal


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 954
 -- Function File: [R1, R2, ..., RN] = deal (A)
 -- Function File: [R1, R2, ..., RN] = deal (A1, A2, ..., AN)

     Copy the input parameters into the corresponding output parameters.

     If only a single input parameter is supplied, its value is copied to each of the outputs.

     For example,

          [a, b, c] = deal (x, y, z);

     is equivalent to

          a = x;
          b = y;
          c = z;

     and

          [a, b, c] = deal (x);

     is equivalent to

          a = b = c = x;

     Programming Note: 'deal' is often used with comma separated lists derived from cell arrays or structures.  This is unnecessary as the interpreter can perform the same action without the overhead of a function call.  For example:

          c = {[1 2], "Three", 4};
          [x, y, z ] = c{:}
          =>
             x =

                1   2

             y = Three
             z =  4

     See also: cell2struct, struct2cell, repmat.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Copy the input parameters into the corresponding output parameters.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
del2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1138
 -- Function File: D = del2 (M)
 -- Function File: D = del2 (M, H)
 -- Function File: D = del2 (M, DX, DY, ...)

     Calculate the discrete Laplace operator.

     For a 2-dimensional matrix M this is defined as

                1    / d^2            d^2         \
          D  = --- * | ---  M(x,y) +  ---  M(x,y) |
                4    \ dx^2           dy^2        /

     For N-dimensional arrays the sum in parentheses is expanded to include second derivatives over the additional higher dimensions.

     The spacing between evaluation points may be defined by H, which is a scalar defining the equidistant spacing in all dimensions.  Alternatively, the spacing in each dimension may be defined separately by DX, DY, etc.  A scalar spacing argument defines equidistant spacing, whereas a vector argument can be used to specify variable spacing.  The length of the spacing vectors must match the respective dimension of M.  The default spacing value is 1.

     At least 3 data points are needed for each dimension.  Boundary points are calculated from the linear extrapolation of interior points.

     See also: gradient, diff.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Calculate the discrete Laplace operator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
display


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 321
 -- Function File: display (A)
     Display the contents of an object.

     If A is an object of the class "myclass", then 'display' is called in a case like

          myclass (...)

     where Octave is required to display the contents of a variable of the type "myclass".

     See also: class, subsref, subsasgn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Display the contents of an object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
divergence


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 652
 -- Function File: DIV = divergence (X, Y, Z, FX, FY, FZ)
 -- Function File: DIV = divergence (FX, FY, FZ)
 -- Function File: DIV = divergence (X, Y, FX, FY)
 -- Function File: DIV = divergence (FX, FY)
     Calculate divergence of a vector field given by the arrays FX, FY, and FZ or FX, FY respectively.

                            d               d               d
          div F(x,y,z)  =   -- F(x,y,z)  +  -- F(x,y,z)  +  -- F(x,y,z)
                            dx              dy              dz

     The coordinates of the vector field can be given by the arguments X, Y, Z or X, Y respectively.

     See also: curl, gradient, del2, dot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Calculate divergence of a vector field given by the arrays FX, FY, and FZ or FX, FY respectively.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
fieldnames


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 673
 -- Function File: NAMES = fieldnames (STRUCT)
 -- Function File: NAMES = fieldnames (OBJ)
 -- Function File: NAMES = fieldnames (JAVAOBJ)
 -- Function File: NAMES = fieldnames ("JCLASSNAME")
     Return a cell array of strings with the names of the fields in the specified input.

     When the input is a structure STRUCT, the names are the elements of the structure.

     When the input is an Octave object OBJ, the names are the public properties of the object.

     When the input is a Java object JAVAOBJ or Java classname JCLASSNAME the name are the public data elements of the object or class.

     See also: numfields, isfield, orderfields, struct, methods.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Return a cell array of strings with the names of the fields in the specified input.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
flip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 635
 -- Function File: flip (X)
 -- Function File: flip (X, DIM)
     Flip array across dimension DIM.

     Return a copy of X flipped about the dimension DIM.  DIM defaults to the first non-singleton dimension.  For example:

          flip ([1  2  3  4])
                =>  4  3  2  1

          flip ([1; 2; 3; 4])
                =>  4
                    3
                    2
                    1

          flip ([1 2; 3 4])
                =>  3  4
                    1  2

          flip ([1 2; 3 4], 2)
                =>  2  1
                    4  3

     See also: fliplr, flipud, rot90, rotdim, permute, transpose.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Flip array across dimension DIM.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
flipdim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 299
 -- Function File: flipdim (X)
 -- Function File: flipdim (X, DIM)
     Flip array across dimension DIM.

     This function is an alias for 'flip' and exists for backwards and MATLAB compatibility.  See 'flip' for complete usage information.

     See also: flip, fliplr, flipud, rot90, rotdim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Flip array across dimension DIM.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
fliplr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 336
 -- Function File: fliplr (X)
     Flip array left to right.

     Return a copy of X with the order of the columns reversed.  In other words, X is flipped left-to-right about a vertical axis.  For example:

          fliplr ([1, 2; 3, 4])
               =>  2  1
                   4  3

     See also: flipud, flip, rot90, rotdim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Flip array left to right.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
flipud


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 331
 -- Function File: flipud (X)
     Flip array upside down.

     Return a copy of X with the order of the rows reversed.  In other words, X is flipped upside-down about a horizontal axis.  For example:

          flipud ([1, 2; 3, 4])
               =>  3  4
                   1  2

     See also: fliplr, flip, rot90, rotdim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Flip array upside down.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
gradient


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1794
 -- Function File: DX = gradient (M)
 -- Function File: [DX, DY, DZ, ...] = gradient (M)
 -- Function File: [...] = gradient (M, S)
 -- Function File: [...] = gradient (M, X, Y, Z, ...)
 -- Function File: [...] = gradient (F, X0)
 -- Function File: [...] = gradient (F, X0, S)
 -- Function File: [...] = gradient (F, X0, X, Y, ...)

     Calculate the gradient of sampled data or a function.

     If M is a vector, calculate the one-dimensional gradient of M.  If M is a matrix the gradient is calculated for each dimension.

     '[DX, DY] = gradient (M)' calculates the one-dimensional gradient for X and Y direction if M is a matrix.  Additional return arguments can be use for multi-dimensional matrices.

     A constant spacing between two points can be provided by the S parameter.  If S is a scalar, it is assumed to be the spacing for all dimensions.  Otherwise, separate values of the spacing can be supplied by the X, ... arguments.  Scalar values specify an equidistant spacing.  Vector values for the X, ... arguments specify the coordinate for that dimension.  The length must match their respective dimension of M.

     At boundary points a linear extrapolation is applied.  Interior points are calculated with the first approximation of the numerical gradient

          y'(i) = 1/(x(i+1)-x(i-1)) * (y(i-1)-y(i+1)).

     If the first argument F is a function handle, the gradient of the function at the points in X0 is approximated using central difference.  For example, 'gradient (@cos, 0)' approximates the gradient of the cosine function in the point x0 = 0.  As with sampled data, the spacing values between the points from which the gradient is estimated can be set via the S or DX, DY, ... arguments.  By default a spacing of 1 is used.

     See also: diff, del2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Calculate the gradient of sampled data or a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
idivide


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1317
 -- Function File: idivide (X, Y, OP)
     Integer division with different rounding rules.

     The standard behavior of integer division such as 'A ./ B' is to round the result to the nearest integer.  This is not always the desired behavior and 'idivide' permits integer element-by-element division to be performed with different treatment for the fractional part of the division as determined by the OP flag.  OP is a string with one of the values:

     "fix"
          Calculate 'A ./ B' with the fractional part rounded towards zero.

     "round"
          Calculate 'A ./ B' with the fractional part rounded towards the nearest integer.

     "floor"
          Calculate 'A ./ B' with the fractional part rounded towards negative infinity.

     "ceil"
          Calculate 'A ./ B' with the fractional part rounded towards positive infinity.

     If OP is not given it defaults to "fix".  An example demonstrating these rounding rules is

          idivide (int8 ([-3, 3]), int8 (4), "fix")
            => int8 ([0, 0])
          idivide (int8 ([-3, 3]), int8 (4), "round")
            => int8 ([-1, 1])
          idivide (int8 ([-3, 3]), int8 (4), "floor")
            => int8 ([-1, 0])
          idivide (int8 ([-3, 3]), int8 (4), "ceil")
            => int8 ([0, 1])

     See also: ldivide, rdivide.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Integer division with different rounding rules.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
inputParser


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4761
 -- Function File: P = inputParser ()
     Create object P of the inputParser class.

     This class is designed to allow easy parsing of function arguments.  The class supports four types of arguments:

       1. mandatory (see 'addRequired');

       2. optional (see 'addOptional');

       3. named (see 'addParamValue');

       4. switch (see 'addSwitch').

     After defining the function API with these methods, the supplied arguments can be parsed with the 'parse' method and the parsing results accessed with the 'Results' accessor.

 -- Accessor method: inputParser.Parameters
     Return list of parameter names already defined.

 -- Accessor method: inputParser.Results
     Return structure with argument names as fieldnames and corresponding values.

 -- Accessor method: inputParser.Unmatched
     Return structure similar to 'Results', but for unmatched parameters.  See the 'KeepUnmatched' property.

 -- Accessor method: inputParser.UsingDefaults
     Return cell array with the names of arguments that are using default values.

 -- Class property: inputParser.CaseSensitive = BOOLEAN
     Set whether matching of argument names should be case sensitive.  Defaults to false.

 -- Class property: inputParser.FunctionName = NAME
     Set function name to be used in error messages; Defaults to empty string.

 -- Class property: inputParser.KeepUnmatched = BOOLEAN
     Set whether an error should be given for non-defined arguments.  Defaults to false.  If set to true, the extra arguments can be accessed through 'Unmatched' after the 'parse' method.  Note that since 'Switch' and 'ParamValue' arguments can be mixed, it is not possible to know the unmatched type.  If argument is found unmatched it is assumed to be of the 'ParamValue' type and it is expected to be followed by a value.

 -- Class property: inputParser.StructExpand = BOOLEAN
     Set whether a structure can be passed to the function instead of parameter/value pairs.  Defaults to true.  Not implemented yet.

     The following example shows how to use this class:

          function check (varargin)
            p = inputParser ();                      # create object
            p.FunctionName = "check";                # set function name
            p.addRequired ("pack", @ischar);         # mandatory argument
            p.addOptional ("path", pwd(), @ischar);  # optional argument

            ## create a function handle to anonymous functions for validators
            val_mat = @(x) isvector (x) && all (x <= 1) && all (x >= 0);
            p.addOptional ("mat", [0 0], val_mat);

            ## create two arguments of type "ParamValue"
            val_type = @(x) any (strcmp (x, {"linear", "quadratic"}));
            p.addParamValue ("type", "linear", val_type);
            val_verb = @(x) any (strcmp (x, {"low", "medium", "high"}));
            p.addParamValue ("tolerance", "low", val_verb);

            ## create a switch type of argument
            p.addSwitch ("verbose");

            p.parse (varargin{:});  # Run created parser on inputs

            ## the rest of the function can access inputs by using p.Results.
            ## for example, get the tolerance input with p.Results.tolerance
          endfunction

          check ("mech");           # valid, use defaults for other arguments
          check ();                 # error, one argument is mandatory
          check (1);                # error, since ! ischar
          check ("mech", "~/dev");  # valid, use defaults for other arguments

          check ("mech", "~/dev", [0 1 0 0], "type", "linear");  # valid

          ## following is also valid.  Note how the Switch argument type can
          ## be mixed into or before the ParamValue argument type (but it
          ## must still appear after any Optional argument).
          check ("mech", "~/dev", [0 1 0 0], "verbose", "tolerance", "high");

          ## following returns an error since not all optional arguments,
          ## `path' and `mat', were given before the named argument `type'.
          check ("mech", "~/dev", "type", "linear");

     _Note 1_: A function can have any mixture of the four API types but they must appear in a specific order.  'Required' arguments must be first and can be followed by any 'Optional' arguments.  Only the 'ParamValue' and 'Switch' arguments may be mixed together and they must appear at the end.

     _Note 2_: If both 'Optional' and 'ParamValue' arguments are mixed in a function API then once a string Optional argument fails to validate it will be considered the end of the 'Optional' arguments.  The remaining arguments will be compared against any 'ParamValue' or 'Switch' arguments.

     See also: nargin, validateattributes, validatestring, varargin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Create object P of the inputParser class.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
int2str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 697
 -- Function File: int2str (N)
     Convert an integer (or array of integers) to a string (or a character array).

          int2str (123)
               => "123"

          s = int2str ([1, 2, 3; 4, 5, 6])
               => s =
                  1  2  3
                  4  5  6

          whos s
               =>
                Attr Name        Size                     Bytes  Class
                ==== ====        ====                     =====  =====
                     s           2x7                         14  char

     This function is not very flexible.  For better control over the results, use 'sprintf' (*note Formatted Output::).

     See also: sprintf, num2str, mat2str.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Convert an integer (or array of integers) to a string (or a character array).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
interp1


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3161
 -- Function File: YI = interp1 (X, Y, XI)
 -- Function File: YI = interp1 (Y, XI)
 -- Function File: YI = interp1 (..., METHOD)
 -- Function File: YI = interp1 (..., EXTRAP)
 -- Function File: YI = interp1 (..., "left")
 -- Function File: YI = interp1 (..., "right")
 -- Function File: PP = interp1 (..., "pp")

     One-dimensional interpolation.

     Interpolate input data to determine the value of YI at the points XI.  If not specified, X is taken to be the indices of Y ('1:length (Y)').  If Y is a matrix or an N-dimensional array, the interpolation is performed on each column of Y.

     The interpolation METHOD is one of:

     "nearest"
          Return the nearest neighbor.

     "previous"
          Return the previous neighbor.

     "next"
          Return the next neighbor.

     "linear" (default)
          Linear interpolation from nearest neighbors.

     "pchip"
          Piecewise cubic Hermite interpolating polynomial--shape-preserving interpolation with smooth first derivative.

     "cubic"
          Cubic interpolation (same as "pchip").

     "spline"
          Cubic spline interpolation--smooth first and second derivatives throughout the curve.

     Adding '*' to the start of any method above forces 'interp1' to assume that X is uniformly spaced, and only 'X(1)' and 'X(2)' are referenced.  This is usually faster, and is never slower.  The default method is "linear".

     If EXTRAP is the string "extrap", then extrapolate values beyond the endpoints using the current METHOD.  If EXTRAP is a number, then replace values beyond the endpoints with that number.  When unspecified, EXTRAP defaults to 'NA'.

     If the string argument "pp" is specified, then XI should not be supplied and 'interp1' returns a piecewise polynomial object.  This object can later be used with 'ppval' to evaluate the interpolation.  There is an equivalence, such that 'ppval (interp1 (X, Y, METHOD, "pp"), XI) == interp1 (X, Y, XI, METHOD, "extrap")'.

     Duplicate points in X specify a discontinuous interpolant.  There may be at most 2 consecutive points with the same value.  If X is increasing, the default discontinuous interpolant is right-continuous.  If X is decreasing, the default discontinuous interpolant is left-continuous.  The continuity condition of the interpolant may be specified by using the options "left" or "right" to select a left-continuous or right-continuous interpolant, respectively.  Discontinuous interpolation is only allowed for "nearest" and "linear" methods; in all other cases, the X-values must be unique.

     An example of the use of 'interp1' is

          xf = [0:0.05:10];
          yf = sin (2*pi*xf/5);
          xp = [0:10];
          yp = sin (2*pi*xp/5);
          lin = interp1 (xp, yp, xf);
          near = interp1 (xp, yp, xf, "nearest");
          pch = interp1 (xp, yp, xf, "pchip");
          spl = interp1 (xp, yp, xf, "spline");
          plot (xf,yf,"r", xf,near,"g", xf,lin,"b", xf,pch,"c", xf,spl,"m",
                xp,yp,"r*");
          legend ("original", "nearest", "linear", "pchip", "spline");

     See also: pchip, spline, interpft, interp2, interp3, interpn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
One-dimensional interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
interp2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2196
 -- Function File: ZI = interp2 (X, Y, Z, XI, YI)
 -- Function File: ZI = interp2 (Z, XI, YI)
 -- Function File: ZI = interp2 (Z, N)
 -- Function File: ZI = interp2 (Z)
 -- Function File: ZI = interp2 (..., METHOD)
 -- Function File: ZI = interp2 (..., METHOD, EXTRAP)

     Two-dimensional interpolation.

     Interpolate reference data X, Y, Z to determine ZI at the coordinates XI, YI.  The reference data X, Y can be matrices, as returned by 'meshgrid', in which case the sizes of X, Y, and Z must be equal.  If X, Y are vectors describing a grid then 'length (X) == columns (Z)' and 'length (Y) == rows (Z)'.  In either case the input data must be strictly monotonic.

     If called without X, Y, and just a single reference data matrix Z, the 2-D region 'X = 1:columns (Z), Y = 1:rows (Z)' is assumed.  This saves memory if the grid is regular and the distance between points is not important.

     If called with a single reference data matrix Z and a refinement value N, then perform interpolation over a grid where each original interval has been recursively subdivided N times.  This results in '2^N-1' additional points for every interval in the original grid.  If N is omitted a value of 1 is used.  As an example, the interval [0,1] with 'N==2' results in a refined interval with points at [0, 1/4, 1/2, 3/4, 1].

     The interpolation METHOD is one of:

     "nearest"
          Return the nearest neighbor.

     "linear" (default)
          Linear interpolation from nearest neighbors.

     "pchip"
          Piecewise cubic Hermite interpolating polynomial--shape-preserving interpolation with smooth first derivative.

     "cubic"
          Cubic interpolation (same as "pchip").

     "spline"
          Cubic spline interpolation--smooth first and second derivatives throughout the curve.

     EXTRAP is a scalar number.  It replaces values beyond the endpoints with EXTRAP.  Note that if EXTRAPVAL is used, METHOD must be specified as well.  If EXTRAP is omitted and the METHOD is "spline", then the extrapolated values of the "spline" are used.  Otherwise the default EXTRAP value for any other METHOD is "NA".

     See also: interp1, interp3, interpn, meshgrid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Two-dimensional interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
interp3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2261
 -- Function File: VI = interp3 (X, Y, Z, V, XI, YI, ZI)
 -- Function File: VI = interp3 (V, XI, YI, ZI)
 -- Function File: VI = interp3 (V, N)
 -- Function File: VI = interp3 (V)
 -- Function File: VI = interp3 (..., METHOD)
 -- Function File: VI = interp3 (..., METHOD, EXTRAPVAL)

     Three-dimensional interpolation.

     Interpolate reference data X, Y, Z, V to determine VI at the coordinates XI, YI, ZI.  The reference data X, Y, Z can be matrices, as returned by 'meshgrid', in which case the sizes of X, Y, Z, and V must be equal.  If X, Y, Z are vectors describing a cubic grid then 'length (X) == columns (V)', 'length (Y) == rows (V)', and 'length (Z) == size (V, 3)'.  In either case the input data must be strictly monotonic.

     If called without X, Y, Z, and just a single reference data matrix V, the 3-D region 'X = 1:columns (V), Y = 1:rows (V), Z = 1:size (V, 3)' is assumed.  This saves memory if the grid is regular and the distance between points is not important.

     If called with a single reference data matrix V and a refinement value N, then perform interpolation over a 3-D grid where each original interval has been recursively subdivided N times.  This results in '2^N-1' additional points for every interval in the original grid.  If N is omitted a value of 1 is used.  As an example, the interval [0,1] with 'N==2' results in a refined interval with points at [0, 1/4, 1/2, 3/4, 1].

     The interpolation METHOD is one of:

     "nearest"
          Return the nearest neighbor.

     "linear" (default)
          Linear interpolation from nearest neighbors.

     "cubic"
          Piecewise cubic Hermite interpolating polynomial--shape-preserving interpolation with smooth first derivative (not implemented yet).

     "spline"
          Cubic spline interpolation--smooth first and second derivatives throughout the curve.

     EXTRAPVAL is a scalar number.  It replaces values beyond the endpoints with EXTRAPVAL.  Note that if EXTRAPVAL is used, METHOD must be specified as well.  If EXTRAPVAL is omitted and the METHOD is "spline", then the extrapolated values of the "spline" are used.  Otherwise the default EXTRAPVAL value for any other METHOD is "NA".

     See also: interp1, interp2, interpn, meshgrid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Three-dimensional interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
interpft


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 539
 -- Function File: interpft (X, N)
 -- Function File: interpft (X, N, DIM)

     Fourier interpolation.

     If X is a vector then X is resampled with N points.  The data in X is assumed to be equispaced.  If X is a matrix or an N-dimensional array, the interpolation is performed on each column of X.

     If DIM is specified, then interpolate along the dimension DIM.

     'interpft' assumes that the interpolated function is periodic, and so assumptions are made about the endpoints of the interpolation.

     See also: interp1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Fourier interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
interpn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1993
 -- Function File: VI = interpn (X1, X2, ..., V, Y1, Y2, ...)
 -- Function File: VI = interpn (V, Y1, Y2, ...)
 -- Function File: VI = interpn (V, M)
 -- Function File: VI = interpn (V)
 -- Function File: VI = interpn (..., METHOD)
 -- Function File: VI = interpn (..., METHOD, EXTRAPVAL)

     Perform N-dimensional interpolation, where N is at least two.

     Each element of the N-dimensional array V represents a value at a location given by the parameters X1, X2, ..., XN.  The parameters X1, X2, ..., XN are either N-dimensional arrays of the same size as the array V in the "ndgrid" format or vectors.  The parameters Y1, etc.  respect a similar format to X1, etc., and they represent the points at which the array VI is interpolated.

     If X1, ..., XN are omitted, they are assumed to be 'x1 = 1 : size (V, 1)', etc.  If M is specified, then the interpolation adds a point half way between each of the interpolation points.  This process is performed M times.  If only V is specified, then M is assumed to be '1'.

     The interpolation METHOD is one of:

     "nearest"
          Return the nearest neighbor.

     "linear" (default)
          Linear interpolation from nearest neighbors.

     "pchip"
          Piecewise cubic Hermite interpolating polynomial--shape-preserving interpolation with smooth first derivative (not implemented yet).

     "cubic"
          Cubic interpolation (same as "pchip" [not implemented yet]).

     "spline"
          Cubic spline interpolation--smooth first and second derivatives throughout the curve.

     The default method is "linear".

     EXTRAPVAL is a scalar number.  It replaces values beyond the endpoints with EXTRAPVAL.  Note that if EXTRAPVAL is used, METHOD must be specified as well.  If EXTRAPVAL is omitted and the METHOD is "spline", then the extrapolated values of the "spline" are used.  Otherwise the default EXTRAPVAL value for any other METHOD is "NA".

     See also: interp1, interp2, interp3, spline, ndgrid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Perform N-dimensional interpolation, where N is at least two.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
isdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function File: isdir (F)
     Return true if F is a directory.

     See also: exist, stat, is_absolute_filename, is_rooted_relative_filename.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Return true if F is a directory.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
isequal


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 120
 -- Function File: isequal (X1, X2, ...)
     Return true if all of X1, X2, ... are equal.

     See also: isequaln.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Return true if all of X1, X2, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
isequaln


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 215
 -- Function File: isequaln (X1, X2, ...)
     Return true if all of X1, X2, ... are equal under the additional assumption that NaN == NaN (no comparison of NaN placeholders in dataset).

     See also: isequal.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Return true if all of X1, X2, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
loadobj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 485
 -- Function File: B = loadobj (A)
     Method of a class to manipulate an object after loading it from a file.

     The function 'loadobj' is called when the object A is loaded using the 'load' function.  An example of the use of 'saveobj' might be to add fields to an object that don't make sense to be saved.  For example:

          function b = loadobj (a)
            b = a;
            b.addmissingfield = addfield (b);
          endfunction

     See also: saveobj, class.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Method of a class to manipulate an object after loading it from a file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
logspace


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 531
 -- Function File: logspace (A, B)
 -- Function File: logspace (A, B, N)
 -- Function File: logspace (A, pi, N)
     Return a row vector with N elements logarithmically spaced from 10^A to 10^B.

     If N is unspecified it defaults to 50.

     If B is equal to pi, the points are between 10^A and pi, _not_ 10^A and 10^pi, in order to be compatible with the corresponding MATLAB function.

     Also for compatibility with MATLAB, return the second argument B if fewer than two values are requested.

     See also: linspace.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Return a row vector with N elements logarithmically spaced from 10^A to 10^B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
methods


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- Function File: methods (OBJ)
 -- Function File: methods ("CLASSNAME")
 -- Function File: MTDS = methods (...)

     Return a cell array containing the names of the methods for the object OBJ or the named class CLASSNAME.

     OBJ may be an Octave class object or a Java object.

     See also: fieldnames.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 104
Return a cell array containing the names of the methods for the object OBJ or the named class CLASSNAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nargchk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 605
 -- Function File: MSGSTR = nargchk (MINARGS, MAXARGS, NARGS)
 -- Function File: MSGSTR = nargchk (MINARGS, MAXARGS, NARGS, "string")
 -- Function File: MSGSTRUCT = nargchk (MINARGS, MAXARGS, NARGS, "struct")
     Return an appropriate error message string (or structure) if the number of inputs requested is invalid.

     This is useful for checking to see that the number of input arguments supplied to a function is within an acceptable range.

     *Caution*: 'nargchk' is scheduled for deprecation.  Use 'narginchk' in all new code.

     See also: narginchk, nargoutchk, error, nargin, nargout.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Return an appropriate error message string (or structure) if the number of inputs requested is invalid.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
narginchk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- Function File: narginchk (MINARGS, MAXARGS)
     Check for correct number of input arguments.

     Generate an error message if the number of arguments in the calling function is outside the range MINARGS and MAXARGS.  Otherwise, do nothing.

     Both MINARGS and MAXARGS must be scalar numeric values.  Zero, Inf, and negative values are all allowed, and MINARGS and MAXARGS may be equal.

     Note that this function evaluates 'nargin' on the caller.

     See also: nargoutchk, error, nargout, nargin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Check for correct number of input arguments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
nargoutchk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1032
 -- Function File: nargoutchk (MINARGS, MAXARGS)
 -- Function File: MSGSTR = nargoutchk (MINARGS, MAXARGS, NARGS)
 -- Function File: MSGSTR = nargoutchk (MINARGS, MAXARGS, NARGS, "string")
 -- Function File: MSGSTRUCT = nargoutchk (MINARGS, MAXARGS, NARGS, "struct")
     Check for correct number of output arguments.

     In the first form, return an error if the number of arguments is not between MINARGS and MAXARGS.  Otherwise, do nothing.  Note that this function evaluates the value of 'nargout' on the caller so its value must have not been tampered with.

     Both MINARGS and MAXARGS must be numeric scalars.  Zero, Inf, and negative are all valid, and they can have the same value.

     For backwards compatibility, the other forms return an appropriate error message string (or structure) if the number of outputs requested is invalid.

     This is useful for checking to that the number of output arguments supplied to a function is within an acceptable range.

     See also: narginchk, error, nargout, nargin.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Check for correct number of output arguments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
nextpow2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 240
 -- Function File: nextpow2 (X)
     Compute the exponent for the smallest power of two larger than the input.

     For each element in the input array X, return the first integer N such that 2^n >= abs (x).

     See also: pow2, log2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Compute the exponent for the smallest power of two larger than the input.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
nthargout


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1255
 -- Function File: nthargout (N, FUNC, ...)
 -- Function File: nthargout (N, NTOT, FUNC, ...)
     Return the Nth output argument of the function specified by the function handle or string FUNC.

     Any additional arguments are passed directly to FUNC.  The total number of arguments to call FUNC with can be passed in NTOT; by default NTOT is N.  The input N can also be a vector of indices of the output, in which case the output will be a cell array of the requested output arguments.

     The intended use 'nthargout' is to avoid intermediate variables.  For example, when finding the indices of the maximum entry of a matrix, the following two compositions of nthargout

          M = magic (5);
          cell2mat (nthargout ([1, 2], @ind2sub, size (M),
                               nthargout (2, @max, M(:))))
          => 5   3

     are completely equivalent to the following lines:

          M = magic (5);
          [~, idx] = max (M(:));
          [i, j] = ind2sub (size (M), idx);
          [i, j]
          => 5   3

     It can also be helpful to have all output arguments in a single cell in the following manner:

          USV = nthargout ([1:3], @svd, hilb (5));

     See also: nargin, nargout, varargin, varargout, isargout.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Return the Nth output argument of the function specified by the function handle or string FUNC.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
num2str


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1433
 -- Function File: num2str (X)
 -- Function File: num2str (X, PRECISION)
 -- Function File: num2str (X, FORMAT)
     Convert a number (or array) to a string (or a character array).

     The optional second argument may either give the number of significant digits (PRECISION) to be used in the output or a format template string (FORMAT) as in 'sprintf' (*note Formatted Output::).  'num2str' can also process complex numbers.

     Examples:

          num2str (123.456)
               => "123.46"

          num2str (123.456, 4)
               => "123.5"

          s = num2str ([1, 1.34; 3, 3.56], "%5.1f")
               => s =
                  1.0  1.3
                  3.0  3.6
          whos s
               =>
                Attr Name        Size                     Bytes  Class
                ==== ====        ====                     =====  =====
                     s           2x8                         16  char

          num2str (1.234 + 27.3i)
               => "1.234+27.3i"

     Notes:

     For MATLAB compatibility, leading spaces are stripped before returning the string.

     The 'num2str' function is not very flexible.  For better control over the results, use 'sprintf' (*note Formatted Output::).

     For complex X, the format string may only contain one output conversion specification and nothing else.  Otherwise, results will be unpredictable.

     See also: sprintf, int2str, mat2str.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Convert a number (or array) to a string (or a character array).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
pol2cart


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 796
 -- Function File: [X, Y] = pol2cart (THETA, R)
 -- Function File: [X, Y, Z] = pol2cart (THETA, R, Z)
 -- Function File: [X, Y] = pol2cart (P)
 -- Function File: [X, Y, Z] = pol2cart (P)
 -- Function File: C = pol2cart (...)
     Transform polar or cylindrical coordinates to Cartesian coordinates.

     The inputs THETA, R, (and Z) must be the same shape, or scalar.  If called with a single matrix argument then each row of P represents the polar/(cylindrical) coordinate (THETA, R (, Z)).

     THETA describes the angle relative to the positive x-axis.

     R is the distance to the z-axis (0, 0, z).

     If only a single return argument is requested then return a matrix C where each row represents one Cartesian coordinate (X, Y (, Z)).

     See also: cart2pol, sph2cart, cart2sph.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Transform polar or cylindrical coordinates to Cartesian coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
polyarea


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 478
 -- Function File: polyarea (X, Y)
 -- Function File: polyarea (X, Y, DIM)

     Determine area of a polygon by triangle method.

     The variables X and Y define the vertex pairs, and must therefore have the same shape.  They can be either vectors or arrays.  If they are arrays then the columns of X and Y are treated separately and an area returned for each.

     If the optional DIM argument is given, then 'polyarea' works along this dimension of the arrays X and Y.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Determine area of a polygon by triangle method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
postpad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 606
 -- Function File: postpad (X, L)
 -- Function File: postpad (X, L, C)
 -- Function File: postpad (X, L, C, DIM)
     Append the scalar value C to the vector X until it is of length L.  If C is not given, a value of 0 is used.

     If 'length (X) > L', elements from the end of X are removed until a vector of length L is obtained.

     If X is a matrix, elements are appended or removed from each row.

     If the optional argument DIM is given, operate along this dimension.

     If DIM is larger than the dimensions of X, the result will have DIM dimensions.

     See also: prepad, cat, resize.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Append the scalar value C to the vector X until it is of length L.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
prepad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 612
 -- Function File: prepad (X, L)
 -- Function File: prepad (X, L, C)
 -- Function File: prepad (X, L, C, DIM)
     Prepend the scalar value C to the vector X until it is of length L.  If C is not given, a value of 0 is used.

     If 'length (X) > L', elements from the beginning of X are removed until a vector of length L is obtained.

     If X is a matrix, elements are prepended or removed from each row.

     If the optional argument DIM is given, operate along this dimension.

     If DIM is larger than the dimensions of X, the result will have DIM dimensions.

     See also: postpad, cat, resize.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Prepend the scalar value C to the vector X until it is of length L.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
profexplore


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 460
 -- Function File: profexplore ()
 -- Function File: profexplore (DATA)
     Interactively explore hierarchical profiler output.

     Assuming DATA is the structure with profile data returned by 'profile ("info")', this command opens an interactive prompt that can be used to explore the call-tree.  Type 'help' to get a list of possible commands.  If DATA is omitted, 'profile ("info")' is called and used in its place.

     See also: profile, profshow.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Interactively explore hierarchical profiler output.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
profile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1474
 -- Command: profile on
 -- Command: profile off
 -- Command: profile resume
 -- Command: profile clear
 -- Function File: S = profile ("status")
 -- Function File: T = profile ("info")
     Control the built-in profiler.

     'profile on'
          Start the profiler, clearing all previously collected data if there is any.

     'profile off'
          Stop profiling.  The collected data can later be retrieved and examined with 'T = profile ("info")'.

     'profile clear'
          Clear all collected profiler data.

     'profile resume'
          Restart profiling without clearing the old data.  All newly collected statistics are added to the existing ones.

     'S = profile ("status")'
          Return a structure with information about the current status of the profiler.  At the moment, the only field is 'ProfilerStatus' which is either "on" or "off".

     'T = profile ("info")'
          Return the collected profiling statistics in the structure T.  The flat profile is returned in the field 'FunctionTable' which is an array of structures, each entry corresponding to a function which was called and for which profiling statistics are present.  In addition, the field 'Hierarchical' contains the hierarchical call tree.  Each node has an index into the 'FunctionTable' identifying the function it corresponds to as well as data fields for number of calls and time spent at this level in the call tree.

          See also: profshow, profexplore.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Control the built-in profiler.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
profshow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 695
 -- Function File: profshow (DATA)
 -- Function File: profshow (DATA, N)
 -- Function File: profshow ()
 -- Function File: profshow (N)
     Display flat per-function profiler results.

     Print out profiler data (execution time, number of calls) for the most critical N functions.  The results are sorted in descending order by the total time spent in each function.  If N is unspecified it defaults to 20.

     The input DATA is the structure returned by 'profile ("info")'.  If unspecified, 'profshow' will use the current profile dataset.

     The attribute column displays 'R' for recursive functions, and is blank for all other function types.

     See also: profexplore, profile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Display flat per-function profiler results.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
quadgk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3764
 -- Function File: Q = quadgk (F, A, B)
 -- Function File: Q = quadgk (F, A, B, ABSTOL)
 -- Function File: Q = quadgk (F, A, B, ABSTOL, TRACE)
 -- Function File: Q = quadgk (F, A, B, PROP, VAL, ...)
 -- Function File: [Q, ERR] = quadgk (...)

     Numerically evaluate the integral of F from A to B using adaptive Gauss-Konrod quadrature.

     F is a function handle, inline function, or string containing the name of the function to evaluate.  The function F must be vectorized and return a vector of output values when given a vector of input values.

     A and B are the lower and upper limits of integration.  Either or both limits may be infinite or contain weak end singularities.  Variable transformation will be used to treat any infinite intervals and weaken the singularities.  For example:

          quadgk (@(x) 1 ./ (sqrt (x) .* (x + 1)), 0, Inf)

     Note that the formulation of the integrand uses the element-by-element operator './' and all user functions to 'quadgk' should do the same.

     The optional argument TOL defines the absolute tolerance used to stop the integration procedure.  The default value is 1e-10.

     The algorithm used by 'quadgk' involves subdividing the integration interval and evaluating each subinterval.  If TRACE is true then after computing each of these partial integrals display: (1) the number of subintervals at this step, (2) the current estimate of the error ERR, (3) the current estimate for the integral Q.

     Alternatively, properties of 'quadgk' can be passed to the function as pairs "PROP", VAL.  Valid properties are

     'AbsTol'
          Define the absolute error tolerance for the quadrature.  The default absolute tolerance is 1e-10.

     'RelTol'
          Define the relative error tolerance for the quadrature.  The default relative tolerance is 1e-5.

     'MaxIntervalCount'
          'quadgk' initially subdivides the interval on which to perform the quadrature into 10 intervals.  Subintervals that have an unacceptable error are subdivided and re-evaluated.  If the number of subintervals exceeds 650 subintervals at any point then a poor convergence is signaled and the current estimate of the integral is returned.  The property "MaxIntervalCount" can be used to alter the number of subintervals that can exist before exiting.

     'WayPoints'
          Discontinuities in the first derivative of the function to integrate can be flagged with the "WayPoints" property.  This forces the ends of a subinterval to fall on the breakpoints of the function and can result in significantly improved estimation of the error in the integral, faster computation, or both.  For example,

               quadgk (@(x) abs (1 - x.^2), 0, 2, "Waypoints", 1)

          signals the breakpoint in the integrand at 'X = 1'.

     'Trace'
          If logically true 'quadgk' prints information on the convergence of the quadrature at each iteration.

     If any of A, B, or WAYPOINTS is complex then the quadrature is treated as a contour integral along a piecewise continuous path defined by the above.  In this case the integral is assumed to have no edge singularities.  For example,

          quadgk (@(z) log (z), 1+1i, 1+1i, "WayPoints",
                  [1-1i, -1,-1i, -1+1i])

     integrates 'log (z)' along the square defined by '[1+1i, 1-1i, -1-1i, -1+1i]'.

     The result of the integration is returned in Q.

     ERR is an approximate bound on the error in the integral 'abs (Q - I)', where I is the exact value of the integral.

     Reference: L.F. Shampine, '"Vectorized adaptive quadrature in MATLAB"', Journal of Computational and Applied Mathematics, pp.  131-140, Vol 211, Issue 2, Feb 2008.

     See also: quad, quadv, quadl, quadcc, trapz, dblquad, triplequad.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Numerically evaluate the integral of F from A to B using adaptive Gauss-Konrod quadrature.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
quadl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1403
 -- Function File: Q = quadl (F, A, B)
 -- Function File: Q = quadl (F, A, B, TOL)
 -- Function File: Q = quadl (F, A, B, TOL, TRACE)
 -- Function File: Q = quadl (F, A, B, TOL, TRACE, P1, P2, ...)

     Numerically evaluate the integral of F from A to B using an adaptive Lobatto rule.

     F is a function handle, inline function, or string containing the name of the function to evaluate.  The function F must be vectorized and return a vector of output values when given a vector of input values.

     A and B are the lower and upper limits of integration.  Both limits must be finite.

     The optional argument TOL defines the relative tolerance with which to perform the integration.  The default value is 'eps'.

     The algorithm used by 'quadl' involves recursively subdividing the integration interval.  If TRACE is defined then for each subinterval display: (1) the left end of the subinterval, (2) the length of the subinterval, (3) the approximation of the integral over the subinterval.

     Additional arguments P1, etc., are passed directly to the function F.  To use default values for TOL and TRACE, one may pass empty matrices ([]).

     Reference: W. Gander and W. Gautschi, 'Adaptive Quadrature - Revisited', BIT Vol.  40, No.  1, March 2000, pp.  84-101.  <http://www.inf.ethz.ch/personal/gander/>

     See also: quad, quadv, quadgk, quadcc, trapz, dblquad, triplequad.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 82
Numerically evaluate the integral of F from A to B using an adaptive Lobatto rule.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
quadv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1723
 -- Function File: Q = quadv (F, A, B)
 -- Function File: Q = quadv (F, A, B, TOL)
 -- Function File: Q = quadv (F, A, B, TOL, TRACE)
 -- Function File: Q = quadv (F, A, B, TOL, TRACE, P1, P2, ...)
 -- Function File: [Q, NFUN] = quadv (...)

     Numerically evaluate the integral of F from A to B using an adaptive Simpson's rule.

     F is a function handle, inline function, or string containing the name of the function to evaluate.  'quadv' is a vectorized version of 'quad' and the function defined by F must accept a scalar or vector as input and return a scalar, vector, or array as output.

     A and B are the lower and upper limits of integration.  Both limits must be finite.

     The optional argument TOL defines the absolute tolerance used to stop the adaptation procedure.  The default value is 1e-6.

     The algorithm used by 'quadv' involves recursively subdividing the integration interval and applying Simpson's rule on each subinterval.  If TRACE is true then after computing each of these partial integrals display: (1) the total number of function evaluations, (2) the left end of the subinterval, (3) the length of the subinterval, (4) the approximation of the integral over the subinterval.

     Additional arguments P1, etc., are passed directly to the function F.  To use default values for TOL and TRACE, one may pass empty matrices ([]).

     The result of the integration is returned in Q

     NFUN indicates the number of function evaluations that were made.

     Note: 'quadv' is written in Octave's scripting language and can be used recursively in 'dblquad' and 'triplequad', unlike the 'quad' function.

     See also: quad, quadl, quadgk, quadcc, trapz, dblquad, triplequad.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
Numerically evaluate the integral of F from A to B using an adaptive Simpson's rule.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
randi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1228
 -- Function File: randi (IMAX)
 -- Function File: randi (IMAX, N)
 -- Function File: randi (IMAX, M, N, ...)
 -- Function File: randi ([IMIN IMAX], ...)
 -- Function File: randi (..., "CLASS")
     Return random integers in the range 1:IMAX.

     Additional arguments determine the shape of the return matrix.  When no arguments are specified a single random integer is returned.  If one argument N is specified then a square matrix (N x N) is returned.  Two or more arguments will return a multi-dimensional matrix (M x N x ...).

     The integer range may optionally be described by a two element matrix with a lower and upper bound in which case the returned integers will be on the interval [IMIN, IMAX].

     The optional argument CLASS will return a matrix of the requested type.  The default is "double".

     The following example returns 150 integers in the range 1-10.

          ri = randi (10, 150, 1)

     Implementation Note: 'randi' relies internally on 'rand' which uses class "double" to represent numbers.  This limits the maximum integer (IMAX) and range (IMAX - IMIN) to the value returned by the 'flintmax' function.  For IEEE floating point numbers this value is 2^{53} - 1.

     See also: rand.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Return random integers in the range 1:IMAX.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
rat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 488
 -- Function File: S = rat (X, TOL)
 -- Function File: [N, D] = rat (X, TOL)

     Find a rational approximation to X within the tolerance defined by TOL using a continued fraction expansion.

     For example:

          rat (pi) = 3 + 1/(7 + 1/16) = 355/113
          rat (e) = 3 + 1/(-4 + 1/(2 + 1/(5 + 1/(-2 + 1/(-7)))))
                  = 1457/536

     When called with two output arguments return the numerator and denominator separately as two matrices.

     See also: rats.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
Find a rational approximation to X within the tolerance defined by TOL using a continued fraction expansion.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
repmat


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 514
 -- Function File: repmat (A, M)
 -- Function File: repmat (A, M, N)
 -- Function File: repmat (A, M, N, P ...)
 -- Function File: repmat (A, [M N])
 -- Function File: repmat (A, [M N P ...])
     Form a block matrix of size M by N, with a copy of matrix A as each element.

     If N is not specified, form an M by M block matrix.  For copying along more than two dimensions, specify the number of times to copy across each dimension M, N, P, ..., in a vector in the second argument.

     See also: repelems.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Form a block matrix of size M by N, with a copy of matrix A as each element.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
rot90


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 902
 -- Function File: rot90 (A)
 -- Function File: rot90 (A, K)
     Rotate array by 90 degree increments.

     Return a copy of A with the elements rotated counterclockwise in 90-degree increments.

     The second argument is optional, and specifies how many 90-degree rotations are to be applied (the default value is 1).  Negative values of K rotate the matrix in a clockwise direction.  For example,

          rot90 ([1, 2; 3, 4], -1)
              =>  3  1
                  4  2

     rotates the given matrix clockwise by 90 degrees.  The following are all equivalent statements:

          rot90 ([1, 2; 3, 4], -1)
          rot90 ([1, 2; 3, 4], 3)
          rot90 ([1, 2; 3, 4], 7)

     The rotation is always performed on the plane of the first two dimensions, i.e., rows and columns.  To perform a rotation on any other plane, use 'rotdim'.

     See also: rotdim, fliplr, flipud, flip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Rotate array by 90 degree increments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rotdim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1037
 -- Function File: rotdim (X)
 -- Function File: rotdim (X, N)
 -- Function File: rotdim (X, N, PLANE)
     Return a copy of X with the elements rotated counterclockwise in 90-degree increments.

     The second argument N is optional, and specifies how many 90-degree rotations are to be applied (the default value is 1).  Negative values of N rotate the matrix in a clockwise direction.

     The third argument is also optional and defines the plane of the rotation.  If present, PLANE is a two element vector containing two different valid dimensions of the matrix.  When PLANE is not given the first two non-singleton dimensions are used.

     For example,

          rotdim ([1, 2; 3, 4], -1, [1, 2])
               =>  3  1
                   4  2

     rotates the given matrix clockwise by 90 degrees.  The following are all equivalent statements:

          rotdim ([1, 2; 3, 4], -1, [1, 2])
          rotdim ([1, 2; 3, 4], 3, [1, 2])
          rotdim ([1, 2; 3, 4], 7, [1, 2])

     See also: rot90, fliplr, flipud, flip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Return a copy of X with the elements rotated counterclockwise in 90-degree increments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
saveobj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 642
 -- Function File: B = saveobj (A)
     Method of a class to manipulate an object prior to saving it to a file.

     The function 'saveobj' is called when the object A is saved using the 'save' function.  An example of the use of 'saveobj' might be to remove fields of the object that don't make sense to be saved or it might be used to ensure that certain fields of the object are initialized before the object is saved.  For example:

          function b = saveobj (a)
            b = a;
            if (isempty (b.field))
               b.field = initfield (b);
            endif
          endfunction

     See also: loadobj, class.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Method of a class to manipulate an object prior to saving it to a file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
shift


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 287
 -- Function File: shift (X, B)
 -- Function File: shift (X, B, DIM)
     If X is a vector, perform a circular shift of length B of the elements of X.

     If X is a matrix, do the same for each column of X.

     If the optional DIM argument is given, operate along this dimension.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
If X is a vector, perform a circular shift of length B of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
shiftdim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 887
 -- Function File: Y = shiftdim (X, N)
 -- Function File: [Y, NS] = shiftdim (X)
     Shift the dimensions of X by N, where N must be an integer scalar.

     When N is positive, the dimensions of X are shifted to the left, with the leading dimensions circulated to the end.  If N is negative, then the dimensions of X are shifted to the right, with N leading singleton dimensions added.

     Called with a single argument, 'shiftdim', removes the leading singleton dimensions, returning the number of dimensions removed in the second output argument NS.

     For example:

          x = ones (1, 2, 3);
          size (shiftdim (x, -1))
             => [1, 1, 2, 3]
          size (shiftdim (x, 1))
             => [2, 3]
          [b, ns] = shiftdim (x)
             => b = [1, 1, 1; 1, 1, 1]
             => ns = 1

     See also: reshape, permute, ipermute, circshift, squeeze.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Shift the dimensions of X by N, where N must be an integer scalar.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
sortrows


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 735
 -- Function File: [S, I] = sortrows (A)
 -- Function File: [S, I] = sortrows (A, C)
     Sort the rows of the matrix A according to the order of the columns specified in C.

     By default (C omitted, or a particular column unspecified in C) an ascending sort order is used.  However, if elements of C are negative then the corresponding column is sorted in descending order.  If the elements of A are strings then a lexicographical sort is used.

     Example: sort by column 2 in descending order, then 3 in ascending order

          x = [ 7, 1, 4;
                8, 3, 5;
                9, 3, 6 ];
          sortrows (x, [-2, 3])
             => 8  3  5
                9  3  6
                7  1  4

     See also: sort.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Sort the rows of the matrix A according to the order of the columns specified in C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
sph2cart


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 733
 -- Function File: [X, Y, Z] = sph2cart (THETA, PHI, R)
 -- Function File: [X, Y, Z] = sph2cart (S)
 -- Function File: C = sph2cart (...)
     Transform spherical coordinates to Cartesian coordinates.

     The inputs THETA, PHI, and R must be the same shape, or scalar.  If called with a single matrix argument then each row of S represents the spherical coordinate (THETA, PHI, R).

     THETA describes the angle relative to the positive x-axis.

     PHI is the angle relative to the xy-plane.

     R is the distance to the origin (0, 0, 0).

     If only a single return argument is requested then return a matrix C where each row represents one Cartesian coordinate (X, Y, Z).

     See also: cart2sph, pol2cart, cart2pol.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Transform spherical coordinates to Cartesian coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
structfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1900
 -- Function File: structfun (FUNC, S)
 -- Function File: [A, ...] = structfun (...)
 -- Function File: structfun (..., "ErrorHandler", ERRFUNC)
 -- Function File: structfun (..., "UniformOutput", VAL)

     Evaluate the function named NAME on the fields of the structure S.  The fields of S are passed to the function FUNC individually.

     'structfun' accepts an arbitrary function FUNC in the form of an inline function, function handle, or the name of a function (in a character string).  In the case of a character string argument, the function must accept a single argument named X, and it must return a string value.  If the function returns more than one argument, they are returned as separate output variables.

     If the parameter "UniformOutput" is set to true (the default), then the function must return a single element which will be concatenated into the return value.  If "UniformOutput" is false, the outputs are placed into a structure with the same fieldnames as the input structure.

          s.name1 = "John Smith";
          s.name2 = "Jill Jones";
          structfun (@(x) regexp (x, '(\w+)$', "matches"){1}, s,
                     "UniformOutput", false)
          =>
             {
               name1 = Smith
               name2 = Jones
             }

     Given the parameter "ErrorHandler", ERRFUNC defines a function to call in case FUNC generates an error.  The form of the function is

          function [...] = errfunc (SE, ...)

     where there is an additional input argument to ERRFUNC relative to FUNC, given by SE.  This is a structure with the elements "identifier", "message" and "index", giving respectively the error identifier, the error message, and the index into the input arguments of the element that caused the error.  For an example on how to use an error handler, *note cellfun: XREFcellfun.

     See also: cellfun, arrayfun, spfun.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Evaluate the function named NAME on the fields of the structure S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
subsindex


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 829
 -- Function File: IDX = subsindex (A)
     Convert an object to an index vector.

     When A is a class object defined with a class constructor, then 'subsindex' is the overloading method that allows the conversion of this class object to a valid indexing vector.  It is important to note that 'subsindex' must return a zero-based real integer vector of the class "double".  For example, if the class constructor

          function b = myclass (a)
            b = class (struct ("a", a), "myclass");
          endfunction

     then the 'subsindex' function

          function idx = subsindex (a)
            idx = double (a.a) - 1.0;
          endfunction

     can then be used as follows

          a = myclass (1:4);
          b = 1:10;
          b(a)
          => 1  2  3  4

     See also: class, subsref, subsasgn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Convert an object to an index vector.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
trapz


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1239
 -- Function File: Q = trapz (Y)
 -- Function File: Q = trapz (X, Y)
 -- Function File: Q = trapz (..., DIM)

     Numerically evaluate the integral of points Y using the trapezoidal method.

     'trapz (Y)' computes the integral of Y along the first non-singleton dimension.  When the argument X is omitted an equally spaced X vector with unit spacing (1) is assumed.  'trapz (X, Y)' evaluates the integral with respect to the spacing in X and the values in Y.  This is useful if the points in Y have been sampled unevenly.

     If the optional DIM argument is given, operate along this dimension.

     Application Note: If X is not specified then unit spacing will be used.  To scale the integral to the correct value you must multiply by the actual spacing value (deltaX). As an example, the integral of x^3 over the range [0, 1] is x^4/4 or 0.25.  The following code uses 'trapz' to calculate the integral in three different ways.

          x = 0:0.1:1;
          y = x.^3;
          q = trapz (y)
            => q = 2.525   # No scaling
          q * 0.1
            => q = 0.2525  # Approximation to integral by scaling
          trapz (x, y)
            => q = 0.2525  # Same result by specifying X

     See also: cumtrapz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Numerically evaluate the integral of points Y using the trapezoidal method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
triplequad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1291
 -- Function File: triplequad (F, XA, XB, YA, YB, ZA, ZB)
 -- Function File: triplequad (F, XA, XB, YA, YB, ZA, ZB, TOL)
 -- Function File: triplequad (F, XA, XB, YA, YB, ZA, ZB, TOL, QUADF)
 -- Function File: triplequad (F, XA, XB, YA, YB, ZA, ZB, TOL, QUADF, ...)
     Numerically evaluate the triple integral of F.

     F is a function handle, inline function, or string containing the name of the function to evaluate.  The function F must have the form w = f(x,y,z) where either X or Y is a vector and the remaining inputs are scalars.  It should return a vector of the same length and orientation as X or Y.

     XA, YA, ZA and XB, YB, ZB are the lower and upper limits of integration for x, y, and z respectively.  The underlying integrator determines whether infinite bounds are accepted.

     The optional argument TOL defines the absolute tolerance used to integrate each sub-integral.  The default value is 1e-6.

     The optional argument QUADF specifies which underlying integrator function to use.  Any choice but 'quad' is available and the default is 'quadcc'.

     Additional arguments, are passed directly to F.  To use the default value for TOL or QUADF one may pass ':' or an empty matrix ([]).

     See also: dblquad, quad, quadv, quadl, quadgk, quadcc, trapz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Numerically evaluate the triple integral of F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
validateattributes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4152
 -- Function File: validateattributes (A, CLASSES, ATTRIBUTES)
 -- Function File: validateattributes (A, CLASSES, ATTRIBUTES, ARG_IDX)
 -- Function File: validateattributes (A, CLASSES, ATTRIBUTES, FUNC_NAME)
 -- Function File: validateattributes (A, CLASSES, ATTRIBUTES, FUNC_NAME, ARG_NAME)
 -- Function File: validateattributes (A, CLASSES, ATTRIBUTES, FUNC_NAME, ARG_NAME, ARG_IDX)
     Check validity of input argument.

     Confirms that the argument A is valid by belonging to one of CLASSES, and holding all of the ATTRIBUTES.  If it does not, an error is thrown, with a message formatted accordingly.  The error message can be made further complete by the function name FUN_NAME, the argument name ARG_NAME, and its position in the input ARG_IDX.

     CLASSES must be a cell array of strings (an empty cell array is allowed) with the name of classes (remember that a class name is case sensitive).  In addition to the class name, the following categories names are also valid:

     "float"
          Floating point value comprising classes "double" and "single".

     "integer"
          Integer value comprising classes (u)int8, (u)int16, (u)int32, (u)int64.

     "numeric"
          Numeric value comprising either a floating point or integer value.

     ATTRIBUTES must be a cell array with names of checks for A.  Some of them require an additional value to be supplied right after the name (see details for each below).

     "<="
          All values are less than or equal to the following value in ATTRIBUTES.

     "<"
          All values are less than the following value in ATTRIBUTES.

     ">="
          All values are greater than or equal to the following value in ATTRIBUTES.

     ">"
          All values are greater than the following value in ATTRIBUTES.

     "2d"
          A 2-dimensional matrix.  Note that vectors and empty matrices have 2 dimensions, one of them being of length 1, or both length 0.

     "3d"
          Has no more than 3 dimensions.  A 2-dimensional matrix is a 3-D matrix whose 3rd dimension is of length 1.

     "binary"
          All values are either 1 or 0.

     "column"
          Values are arranged in a single column.

     "decreasing"
          No value is NAN, and each is less than the preceding one.

     "even"
          All values are even numbers.

     "finite"
          All values are finite.

     "increasing"
          No value is NAN, and each is greater than the preceding one.

     "integer"
          All values are integer.  This is different than using 'isinteger' which only checks its an integer type.  This checks that each value in A is an integer value, i.e., it has no decimal part.

     "ncols"
          Has exactly as many columns as the next value in ATTRIBUTES.

     "ndims"
          Has exactly as many dimensions as the next value in ATTRIBUTES.

     "nondecreasing"
          No value is NAN, and each is greater than or equal to the preceding one.

     "nonempty"
          It is not empty.

     "nonincreasing"
          No value is NAN, and each is less than or equal to the preceding one.

     "nonnan"
          No value is a 'NaN'.

     "nonnegative"
          All values are non negative.

     "nonsparse"
          It is not a sparse matrix.

     "nonzero"
          No value is zero.

     "nrows"
          Has exactly as many rows as the next value in ATTRIBUTES.

     "numel"
          Has exactly as many elements as the next value in ATTRIBUTES.

     "odd"
          All values are odd numbers.

     "positive"
          All values are positive.

     "real"
          It is a non-complex matrix.

     "row"
          Values are arranged in a single row.

     "scalar"
          It is a scalar.

     "size"
          Its size has length equal to the values of the next in ATTRIBUTES.  The next value must is an array with the length for each dimension.  To ignore the check for a certain dimension, the value of 'NaN' can be used.

     "square"
          Is a square matrix.

     "vector"
          Values are arranged in a single vector (column or vector).

     See also: isa, validatestring, inputParser.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Check validity of input argument.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
convhull


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 877
 -- Function File: H = convhull (X, Y)
 -- Function File: H = convhull (X, Y, OPTIONS)
     Compute the convex hull of the set of points defined by the arrays X and Y.  The hull H is an index vector into the set of points and specifies which points form the enclosing hull.

     An optional third argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.  The default option is '{"Qt"}'.

     If OPTIONS is not present or '[]' then the default arguments are used.  Otherwise, OPTIONS replaces the default argument list.  To append user options to the defaults it is necessary to repeat the default arguments in OPTIONS.  Use a null string to pass no arguments.

     See also: convhulln, delaunay, voronoi.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Compute the convex hull of the set of points defined by the arrays X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
delaunayn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1454
 -- Function File: T = delaunayn (PTS)
 -- Function File: T = delaunayn (PTS, OPTIONS)
     Compute the Delaunay triangulation for an N-dimensional set of points.

     The Delaunay triangulation is a tessellation of the convex hull of a set of points such that no N-sphere defined by the N-triangles contains any other points from the set.

     The input matrix PTS of size [n, dim] contains n points in a space of dimension dim.  The return matrix T has size [m, dim+1].  Each row of T contains a set of indices back into the original set of points PTS which describes a simplex of dimension dim.  For example, a 2-D simplex is a triangle and 3-D simplex is a tetrahedron.

     An optional second argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.  The default options depend on the dimension of the input:

        * 2-D and 3-D: OPTIONS = '{"Qt", "Qbb", "Qc", "Qz"}'

        * 4-D and higher: OPTIONS = '{"Qt", "Qbb", "Qc", "Qx"}'

     If OPTIONS is not present or '[]' then the default arguments are used.  Otherwise, OPTIONS replaces the default argument list.  To append user options to the defaults it is necessary to repeat the default arguments in OPTIONS.  Use a null string to pass no arguments.

     See also: delaunay, convhulln, voronoin, trimesh, tetramesh.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Compute the Delaunay triangulation for an N-dimensional set of points.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
delaunay


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2226
 -- Function File: TRI = delaunay (X, Y)
 -- Function File: TETR = delaunay (X, Y, Z)
 -- Function File: TRI = delaunay (X)
 -- Function File: TRI = delaunay (..., OPTIONS)
     Compute the Delaunay triangulation for a 2-D or 3-D set of points.

     For 2-D sets, the return value TRI is a set of triangles which satisfies the Delaunay circum-circle criterion, i.e., only a single data point from [X, Y] is within the circum-circle of the defining triangle.  The set of triangles TRI is a matrix of size [n, 3].  Each row defines a triangle and the three columns are the three vertices of the triangle.  The value of 'TRI(i,j)' is an index into X and Y for the location of the j-th vertex of the i-th triangle.

     For 3-D sets, the return value TETR is a set of tetrahedrons which satisfies the Delaunay circum-circle criterion, i.e., only a single data point from [X, Y, Z] is within the circum-circle of the defining tetrahedron.  The set of tetrahedrons is a matrix of size [n, 4].  Each row defines a tetrahedron and the four columns are the four vertices of the tetrahedron.  The value of 'TETR(i,j)' is an index into X, Y, Z for the location of the j-th vertex of the i-th tetrahedron.

     The input X may also be a matrix with two or three columns where the first column contains x-data, the second y-data, and the optional third column contains z-data.

     The optional last argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.  The default options are '{"Qt", "Qbb", "Qc", "Qz"}'.

     If OPTIONS is not present or '[]' then the default arguments are used.  Otherwise, OPTIONS replaces the default argument list.  To append user options to the defaults it is necessary to repeat the default arguments in OPTIONS.  Use a null string to pass no arguments.

          x = rand (1, 10);
          y = rand (1, 10);
          tri = delaunay (x, y);
          triplot (tri, x, y);
          hold on;
          plot (x, y, "r*");
          axis ([0,1,0,1]);

     See also: delaunayn, convhull, voronoi, triplot, trimesh, tetramesh, trisurf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Compute the Delaunay triangulation for a 2-D or 3-D set of points.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
dsearch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 305
 -- Function File: IDX = dsearch (X, Y, TRI, XI, YI)
 -- Function File: IDX = dsearch (X, Y, TRI, XI, YI, S)
     Return the index IDX of the closest point in 'X, Y' to the elements '[XI(:), YI(:)]'.

     The variable S is accepted for compatibility but is ignored.

     See also: dsearchn, tsearch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Return the index IDX of the closest point in 'X, Y' to the elements '[XI(:), YI(:)]'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dsearchn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 473
 -- Function File: IDX = dsearchn (X, TRI, XI)
 -- Function File: IDX = dsearchn (X, TRI, XI, OUTVAL)
 -- Function File: IDX = dsearchn (X, XI)
 -- Function File: [IDX, D] = dsearchn (...)
     Return the index IDX of the closest point in X to the elements XI.

     If OUTVAL is supplied, then the values of XI that are not contained within one of the simplices TRI are set to OUTVAL.  Generally, TRI is returned from 'delaunayn (X)'.

     See also: dsearch, tsearch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Return the index IDX of the closest point in X to the elements XI.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
griddata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 647
 -- Function File: ZI = griddata (X, Y, Z, XI, YI)
 -- Function File: ZI = griddata (X, Y, Z, XI, YI, METHOD)
 -- Function File: [XI, YI, ZI] = griddata (...)

     Generate a regular mesh from irregular data using interpolation.

     The function is defined by 'Z = f (X, Y)'.  Inputs 'X, Y, Z' are vectors of the same length or 'X, Y' are vectors and 'Z' is matrix.

     The interpolation points are all '(XI, YI)'.  If XI, YI are vectors then they are made into a 2-D mesh.

     The interpolation method can be "nearest", "cubic" or "linear".  If method is omitted it defaults to "linear".

     See also: griddata3, griddatan, delaunay.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Generate a regular mesh from irregular data using interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
griddata3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 752
 -- Function File: VI = griddata3 (X, Y, Z, V, XI, YI, ZI)
 -- Function File: VI = griddata3 (X, Y, Z, V, XI, YI, ZI, METHOD)
 -- Function File: VI = griddata3 (X, Y, Z, V, XI, YI, ZI, METHOD, OPTIONS)

     Generate a regular mesh from irregular data using interpolation.

     The function is defined by 'V = f (X, Y, Z)'.  The interpolation points are specified by XI, YI, ZI.

     The interpolation method can be "nearest" or "linear".  If method is omitted it defaults to "linear".

     The optional argument OPTIONS is passed directly to Qhull when computing the Delaunay triangulation used for interpolation.  See 'delaunayn' for information on the defaults and how to pass different values.

     See also: griddata, griddatan, delaunayn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Generate a regular mesh from irregular data using interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
griddatan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 687
 -- Function File: YI = griddatan (X, Y, XI)
 -- Function File: YI = griddatan (X, Y, XI, METHOD)
 -- Function File: YI = griddatan (X, Y, XI, METHOD, OPTIONS)

     Generate a regular mesh from irregular data using interpolation.

     The function is defined by 'Y = f (X)'.  The interpolation points are all XI.

     The interpolation method can be "nearest" or "linear".  If method is omitted it defaults to "linear".

     The optional argument OPTIONS is passed directly to Qhull when computing the Delaunay triangulation used for interpolation.  See 'delaunayn' for information on the defaults and how to pass different values.

     See also: griddata, griddata3, delaunayn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Generate a regular mesh from irregular data using interpolation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
inpolygon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 473
 -- Function File: IN = inpolygon (X, Y, XV, YV)
 -- Function File: [IN, ON] = inpolygon (X, Y, XV, YV)

     For a polygon defined by vertex points '(XV, YV)', return true if the points '(X, Y)' are inside (or on the boundary) of the polygon; Otherwise, return false.

     The input variables X and Y, must have the same dimension.

     The optional output ON returns true if the points are exactly on the polygon edge, and false otherwise.

     See also: delaunay.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 158
For a polygon defined by vertex points '(XV, YV)', return true if the points '(X, Y)' are inside (or on the boundary) of the polygon; Otherwise, return false.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
rectint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 922
 -- Function File: AREA = rectint (A, B)
     Compute area or volume of intersection of rectangles or N-D boxes.

     Compute the area of intersection of rectangles in A and rectangles in B.  N-dimensional boxes are supported in which case the volume, or hypervolume is computed according to the number of dimensions.

     2-dimensional rectangles are defined as '[xpos ypos width height]' where xpos and ypos are the position of the bottom left corner.  Higher dimensions are supported where the coordinates for the minimum value of each dimension follow the length of the box in that dimension, e.g., '[xpos ypos zpos kpos ... width height depth k_length ...]'.

     Each row of A and B define a rectangle, and if both define multiple rectangles, then the output, AREA, is a matrix where the i-th row corresponds to the i-th row of a and the j-th column corresponds to the j-th row of b.

     See also: polyarea.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Compute area or volume of intersection of rectangles or N-D boxes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
tsearchn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 415
 -- Function File: IDX = tsearchn (X, T, XI)
 -- Function File: [IDX, P] = tsearchn (X, T, XI)
     Search for the enclosing Delaunay convex hull.

     For 'T = delaunayn (X)', finds the index in T containing the points XI.  For points outside the convex hull, IDX is NaN.

     If requested 'tsearchn' also returns the Barycentric coordinates P of the enclosing triangles.

     See also: delaunay, delaunayn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Search for the enclosing Delaunay convex hull.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
voronoi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1323
 -- Function File: voronoi (X, Y)
 -- Function File: voronoi (X, Y, OPTIONS)
 -- Function File: voronoi (..., "linespec")
 -- Function File: voronoi (HAX, ...)
 -- Function File: H = voronoi (...)
 -- Function File: [VX, VY] = voronoi (...)
     Plot the Voronoi diagram of points '(X, Y)'.

     The Voronoi facets with points at infinity are not drawn.

     The OPTIONS argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.

     If "linespec" is given it is used to set the color and line style of the plot.

     If an axis graphics handle HAX is supplied then the Voronoi diagram is drawn on the specified axis rather than in a new figure.

     If a single output argument is requested then the Voronoi diagram will be plotted and a graphics handle H to the plot is returned.

     [VX, VY] = voronoi (...) returns the Voronoi vertices instead of plotting the diagram.

          x = rand (10, 1);
          y = rand (size (x));
          h = convhull (x, y);
          [vx, vy] = voronoi (x, y);
          plot (vx, vy, "-b", x, y, "o", x(h), y(h), "-g");
          legend ("", "points", "hull");

     See also: voronoin, delaunay, convhull.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Plot the Voronoi diagram of points '(X, Y)'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
voronoin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1086
 -- Function File: [C, F] = voronoin (PTS)
 -- Function File: [C, F] = voronoin (PTS, OPTIONS)
     Compute N-dimensional Voronoi facets.

     The input matrix PTS of size [n, dim] contains n points in a space of dimension dim.

     C contains the points of the Voronoi facets.  The list F contains, for each facet, the indices of the Voronoi points.

     An optional second argument, which must be a string or cell array of strings, contains options passed to the underlying qhull command.  See the documentation for the Qhull library for details <http://www.qhull.org/html/qh-quick.htm#options>.

     The default options depend on the dimension of the input:

        * 2-D and 3-D: OPTIONS = '{"Qbb"}'

        * 4-D and higher: OPTIONS = '{"Qbb", "Qx"}'

     If OPTIONS is not present or '[]' then the default arguments are used.  Otherwise, OPTIONS replaces the default argument list.  To append user options to the defaults it is necessary to repeat the default arguments in OPTIONS.  Use a null string to pass no arguments.

     See also: voronoi, convhulln, delaunayn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Compute N-dimensional Voronoi facets.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
errordlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 685
 -- Function File: H = errordlg (MSG)
 -- Function File: H = errordlg (MSG, TITLE)
 -- Function File: H = errordlg (MSG, TITLE, CREATEMODE)
     Display MSG using an error dialog box.

     The message may have multiple lines separated by newline characters ("\n"), or it may be a cellstr array with one element for each line.

     The optional input TITLE (character string) can be used to set the dialog caption.  The default title is "Error Dialog".

     The return value is always 1.

     Compatibility Note: The optional argument CREATEMODE is accepted for MATLAB compatibility, but is not implemented.

     See also: helpdlg, inputdlg, listdlg, msgbox, questdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Display MSG using an error dialog box.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
guidata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 502
 -- Function File: DATA = guidata (H)
 -- Function File: guidata (H, DATA)
     Query or set user-custom GUI data.

     The GUI data is stored in the figure handle H.  If H is not a figure handle then it's parent figure will be used for storage.

     DATA must be a single object which means it is usually preferable for it to be a data container such as a cell array or struct so that additional data items can be added easily.

     See also: getappdata, setappdata, get, set, getpref, setpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Query or set user-custom GUI data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
guihandles


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 661
 -- Function File: HDATA = guihandles (H)
 -- Function File: HDATA = guihandles
     Return a structure of object handles for the figure associated with handle H.

     If no handle is specified the current figure returned by 'gcf' is used.

     The fieldname for each entry of HDATA is taken from the "tag" property of the graphic object.  If the tag is empty then the handle is not returned.  If there are multiple graphic objects with the same tag then the entry in HDATA will be a vector of handles.  'guihandles' includes all possible handles, including those for which "HandleVisibility" is "off".

     See also: guidata, findobj, findall, allchild.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Return a structure of object handles for the figure associated with handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
helpdlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 500
 -- Function File: H = helpdlg (MSG)
 -- Function File: H = helpdlg (MSG, TITLE)
     Display MSG in a help dialog box.

     The message may have multiple lines separated by newline characters ("\n"), or it may be a cellstr array with one element for each line.

     The optional input TITLE (character string) can be used to set the dialog caption.  The default title is "Help Dialog".

     The return value is always 1.

     See also: errordlg, inputdlg, listdlg, msgbox, questdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Display MSG in a help dialog box.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
inputdlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1364
 -- Function File: CSTR = inputdlg (PROMPT)
 -- Function File: CSTR = inputdlg (PROMPT, TITLE)
 -- Function File: CSTR = inputdlg (PROMPT, TITLE, ROWSCOLS)
 -- Function File: CSTR = inputdlg (PROMPT, TITLE, ROWSCOLS, DEFAULTS)
     Return user input from a multi-textfield dialog box in a cell array of strings, or an empty cell array if the dialog is closed by the Cancel button.

     Inputs:

     PROMPT
          A cell array with strings labeling each text field.  This input is required.

     TITLE
          String to use for the caption of the dialog.  The default is "Input Dialog".

     ROWSCOLS
          Specifies the size of the text fields and can take three forms:

            1. a scalar value which defines the number of rows used for each text field.

            2. a vector which defines the individual number of rows used for each text field.

            3. a matrix which defines the individual number of rows and columns used for each text field.  In the matrix each row describes a single text field.  The first column specifies the number of input rows to use and the second column specifies the text field width.

     DEFAULTS
          A list of default values to place in each text fields.  It must be a cell array of strings with the same size as PROMPT.

     See also: errordlg, helpdlg, listdlg, msgbox, questdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
Return user input from a multi-textfield dialog box in a cell array of strings, or an empty cell array if the dialog is closed by the Cancel button.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
listdlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1663
 -- Function File: [SEL, OK] = listdlg (KEY, VALUE, ...)
     Return user inputs from a list dialog box in a vector of selection indices SEL and a flag OK indicating how the user closed the dialog box.

     The value of OK is 1 if the user closed the box with the OK button, otherwise it is 0 and SEL is empty.

     The indices in SEL are 1-based.

     The arguments are specified in form of KEY, VALUE pairs.  The "ListString" argument pair must be specified.

     Valid KEY and VALUE pairs are:

     "ListString"
          a cell array of strings comprising the content of the list.

     "SelectionMode"
          can be either "Single" or "Multiple" (default).

     "ListSize"
          a vector with two elements WIDTH and HEIGHT defining the size of the list field in pixels.  Default is [160 300].

     "InitialValue"
          a vector containing 1-based indices of preselected elements.  Default is 1 (first item).

     "Name"
          a string to be used as the dialog caption.  Default is "".

     "PromptString"
          a cell array of strings to be displayed above the list field.  Default is {}.

     "OKString"
          a string used to label the OK button.  Default is "OK".

     "CancelString"
          a string used to label the Cancel button.  Default is "Cancel".

     Example:

          [sel, ok] = listdlg ("ListString", {"An item", "another", "yet another"},
                               "SelectionMode", "Multiple");
          if (ok == 1)
            for i = 1:numel (sel)
              disp (sel(i));
            endfor
          endif

     See also: menu, errordlg, helpdlg, inputdlg, msgbox, questdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 139
Return user inputs from a list dialog box in a vector of selection indices SEL and a flag OK indicating how the user closed the dialog box.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
msgbox


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 811
 -- Function File: H = msgbox (MSG)
 -- Function File: H = msgbox (MSG, TITLE)
 -- Function File: H = msgbox (MSG, TITLE, ICON)
 -- Function File: H = msgbox (..., CREATEMODE)
     Display MSG using a message dialog box.

     The message may have multiple lines separated by newline characters ("\n"), or it may be a cellstr array with one element for each line.

     The optional input TITLE (character string) can be used to decorate the dialog caption.

     The optional argument ICON selects a dialog icon.  It can be one of "none" (default), "error", "help", or "warn".

     The return value is always 1.

     Compatibility Note: The optional argument CREATEMODE is accepted for MATLAB compatibility, but is not implemented.

     See also: errordlg, helpdlg, inputdlg, listdlg, questdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Display MSG using a message dialog box.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
questdlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1154
 -- Function File: BTN = questdlg (MSG)
 -- Function File: BTN = questdlg (MSG, TITLE)
 -- Function File: BTN = questdlg (MSG, TITLE, DEFAULT)
 -- Function File: BTN = questdlg (MSG, TITLE, BTN1, BTN2, DEFAULT)
 -- Function File: BTN = questdlg (MSG, TITLE, BTN1, BTN2, BTN3, DEFAULT)
     Display MSG using a question dialog box and return the caption of the activated button.

     The dialog may contain two or three buttons which will all close the dialog.

     The message may have multiple lines separated by newline characters ("\n"), or it may be a cellstr array with one element for each line.

     The optional TITLE (character string) can be used to decorate the dialog caption.

     The string DEFAULT identifies the default button, which is activated by pressing the <ENTER> key.  It must match one of the strings given in BTN1, BTN2, or BTN3.

     If only MSG and TITLE are specified, three buttons with the default captions "Yes", "No", and "Cancel" are used.

     If only two button captions, BTN1 and BTN2, are specified the dialog will have only these two buttons.

     See also: errordlg, helpdlg, inputdlg, listdlg, warndlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 87
Display MSG using a question dialog box and return the caption of the activated button.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
uicontextmenu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 971
 -- Function File: HUI = uicontextmenu (PROPERTY, VALUE, ...)
 -- Function File: HUI = uicontextmenu (H, PROPERTY, VALUE, ...)

     Create a uicontextmenu object and return a handle to it.

     If H is omitted then a uicontextmenu for the current figure is created.  If no figure is available, a new figure is created first.

     If H is given then a uicontextmenu relative to H is created.

     Any provided property value pairs will override the default values of the created uicontextmenu object.

     Examples:

          % create figure and uicontextmenu
          f = figure;
          c = uicontextmenu (f);

          % create menus in the context menu
          m1 = uimenu ("parent",c,"label","Menu item 1","callback","disp('menu item 1')");
          m2 = uimenu ("parent",c,"label","Menu item 2","callback","disp('menu item 2')");

          % set the context menu for the figure
          set (f, "uicontextmenu", c);

     See also: figure, uimenu.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Create a uicontextmenu object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
uicontrol


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2455
 -- Function File: HUI = uicontrol (PROPERTY, VALUE, ...)
 -- Function File: HUI = uicontrol (PARENT, PROPERTY, VALUE, ...)
 -- Function File: uicontrol (H)

     Create a uicontrol object and return a handle to it.

     uicontrols are used to create simple interactive controls such as push buttons, checkboxes, edit and list controls.

     If PARENT is omitted then a uicontrol for the current figure is created.  If no figure is available, a new figure is created first.

     If PARENT is given then a uicontrol relative to PARENT is created.

     Any provided property value pairs will override the default values of the created uicontrol object.

     Control of the type of uicontrol created is through the use of the STYLE property.  If no style property is provided, a push button will be created.

     Valid styles for uicontrol are:

     "checkbox"
          Create a checkbox control that allows user on/off selection.

     "edit"
          Create a edit control that allows user input of single or multiple lines of text.

     "listbox"
          Create a listbox control that displays a lit of items and allows user slelection of single or multiple items.

     "popupmenu"
          Create a popupmenu control that displays a list of options that can be selected when the user clicks on the control.

     "pushbutton"
          Create a push button control that allows user to press to cause an action.

     "radiobutton"
          Create a radio button control intended to be used for mutually exclusive input in a group of of radiobutton controls.

     "slider"
          Create a slider control that allows user selection from a range of values by sliding knob on the control.

     "text"
          Create a static text control to display single or multiple lines of text.

     "togglebutton"
          Create a toggle button control that appears like a push button but allows the user to select between two states.

     Examples:

          % create figure and panel on it
          f = figure;
          % create a button (default style)
          b1 = uicontrol (f, "string", "A Button", "position",[10 10 150 40]);
          % create an edit control
          e1 = uicontrol (f, "style", "edit", "string", "editable text", "position",[10 60 300 40]);
          % create a checkbox
          c1 = uicontrol (f, "style", "checkbox", "string", "a checkbox", "position",[10 120 150 40]);

     See also: figure, uipanel.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Create a uicontrol object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
uigetdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 377
 -- Function File: DIRNAME = uigetdir ()
 -- Function File: DIRNAME = uigetdir (INIT_PATH)
 -- Function File: DIRNAME = uigetdir (INIT_PATH, DIALOG_NAME)
     Open a GUI dialog for selecting a directory.

     If INIT_PATH is not given the current working directory is used.

     DIALOG_NAME may be used to customize the dialog title.

     See also: uigetfile, uiputfile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Open a GUI dialog for selecting a directory.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
uigetfile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1797
 -- Function File: [FNAME, FPATH, FLTIDX] = uigetfile ()
 -- Function File: [...] = uigetfile (FLT)
 -- Function File: [...] = uigetfile (FLT, DIALOG_NAME)
 -- Function File: [...] = uigetfile (FLT, DIALOG_NAME, DEFAULT_FILE)
 -- Function File: [...] = uigetfile (..., "Position", [PX PY])
 -- Function File: [...] = uigetfile (..., "MultiSelect", MODE)

     Open a GUI dialog for selecting a file and return the filename FNAME, the path to this file FPATH, and the filter index FLTIDX.

     FLT contains a (list of) file filter string(s) in one of the following formats:

     "/path/to/filename.ext"
          If a filename is given then the file extension is extracted and used as filter.  In addition, the path is selected as current path and the filename is selected as default file.  Example: 'uigetfile ("myfun.m")'

     A single file extension "*.ext"
          Example: 'uigetfile ("*.ext")'

     A 2-column cell array
          containing a file extension in the first column and a brief description in the second column.  Example: 'uigetfile ({"*.ext", "My Description";"*.xyz", "XYZ-Format"})'

          The filter string can also contain a semicolon separated list of filter extensions.  Example: 'uigetfile ({"*.gif;*.png;*.jpg", "Supported Picture Formats"})'

     DIALOG_NAME can be used to customize the dialog title.

     If DEFAULT_FILE is given then it will be selected in the GUI dialog.  If, in addition, a path is given it is also used as current path.

     The screen position of the GUI dialog can be set using the "Position" key and a 2-element vector containing the pixel coordinates.  Two or more files can be selected when setting the "MultiSelect" key to "on".  In that case FNAME is a cell array containing the files.

     See also: uiputfile, uigetdir.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 127
Open a GUI dialog for selecting a file and return the filename FNAME, the path to this file FPATH, and the filter index FLTIDX.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
uimenu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1962
 -- Function File: HUI = uimenu (PROPERTY, VALUE, ...)
 -- Function File: HUI = uimenu (H, PROPERTY, VALUE, ...)
     Create a uimenu object and return a handle to it.

     If H is omitted then a top-level menu for the current figure is created.  If H is given then a submenu relative to H is created.

     uimenu objects have the following specific properties:

     "accelerator"
          A string containing the key combination together with CTRL to execute this menu entry (e.g., "x" for CTRL+x).

     "callback"
          Is the function called when this menu entry is executed.  It can be either a function string (e.g., "myfun"), a function handle (e.g., @myfun) or a cell array containing the function handle and arguments for the callback function (e.g., {@myfun, arg1, arg2}).

     "checked"
          Can be set "on" or "off".  Sets a mark at this menu entry.

     "enable"
          Can be set "on" or "off".  If disabled the menu entry cannot be selected and it is grayed out.

     "foregroundcolor"
          A color value setting the text color for this menu entry.

     "label"
          A string containing the label for this menu entry.  A "&"-symbol can be used to mark the "accelerator" character (e.g., "E&xit")

     "position"
          An scalar value containing the relative menu position.  The entry with the lowest value is at the first position starting from left or top.

     "separator"
          Can be set "on" or "off".  If enabled it draws a separator line above the current position.  It is ignored for top level entries.

     Examples:

          f = uimenu ("label", "&File", "accelerator", "f");
          e = uimenu ("label", "&Edit", "accelerator", "e");
          uimenu (f, "label", "Close", "accelerator", "q", ...
                     "callback", "close (gcf)");
          uimenu (e, "label", "Toggle &Grid", "accelerator", "g", ...
                     "callback", "grid (gca)");

     See also: figure.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Create a uimenu object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
uipanel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 984
 -- Function File: HUI = uipanel (PROPERTY, VALUE, ...)
 -- Function File: HUI = uipanel (PARENT, "PROPERTY, VALUE, ...)

     Create a uipanel object and return a handle to it.

     uipanels are used as containers to group other uicontrol objects.

     If PARENT is omitted then a uipanel for the current figure is created.  If no figure is available, a new figure is created first.

     If PARENT is given then a uipanel relative to PARENT is created.

     Any provided property value pairs will override the default values of the created uipanel object.

     Examples:

          % create figure and panel on it
          f = figure;
          p = uipanel ("title", "Panel Title", "position", [.25 .25 .5 .5]);

          % add two buttons to the panel
          b1 = uicontrol ("parent", p, "string", "A Button", "position",[18 10 150 36]);
          b2 = uicontrol ("parent", p, "string", "Another Button", "position",[18 60 150 36]);


     See also: figure, uicontrol.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Create a uipanel object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
uipushtool


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1185
 -- Function File: HUI = uipushtool (PROPERTY, VALUE, ...)
 -- Function File: HUI = uipushtool (PARENT, PROPERTY, VALUE, ...)

     Create a uipushtool object and return a handle to it.

     uipushtools are buttons that appear on a figure toolbar.  The button is created with a border that is shown when the user hovers over the button.  An image can be set using the cdata property.

     If PARENT is omitted then a uipushtool for the current figure is created.  If no figure is available, a new figure is created first.  If a figure is available, but does not contain a uitoolbar, a uitoolbar will be created.

     If PARENT is given then a uipushtools is created on the PARENT uitoolbar.

     Any provided property value pairs will override the default values of the created uipushtool object.

     Examples:

          % create figure without a default toolbar
          f = figure ("toolbar", "none");
          % create empty toolbar
          t = uitoolbar (f);
          % create a 19x19x3 black square
          img=zeros(19,19,3);
          % add pushtool button to toolbar
          b = uipushtool (t, "cdata", img);

     See also: figure, uitoolbar, uitoggletool.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Create a uipushtool object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
uiputfile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1362
 -- Function File: [FNAME, FPATH, FLTIDX] = uiputfile ()
 -- Function File: [FNAME, FPATH, FLTIDX] = uiputfile (FLT)
 -- Function File: [FNAME, FPATH, FLTIDX] = uiputfile (FLT, DIALOG_NAME)
 -- Function File: [FNAME, FPATH, FLTIDX] = uiputfile (FLT, DIALOG_NAME, DEFAULT_FILE)
     Open a GUI dialog for selecting a file.

     FLT contains a (list of) file filter string(s) in one of the following formats:

     "/path/to/filename.ext"
          If a filename is given the file extension is extracted and used as filter.  In addition the path is selected as current path and the filename is selected as default file.  Example: 'uiputfile ("myfun.m")'

     "*.ext"
          A single file extension.  Example: 'uiputfile ("*.ext")'

     '{"*.ext", "My Description"}'
          A 2-column cell array containing the file extension in the 1st column and a brief description in the 2nd column.  Example: 'uiputfile ({"*.ext","My Description";"*.xyz", "XYZ-Format"})'

     The filter string can also contain a semicolon separated list of filter extensions.  Example: 'uiputfile ({"*.gif;*.png;*.jpg", "Supported Picture Formats"})'

     DIALOG_NAME can be used to customize the dialog title.  If DEFAULT_FILE is given it is preselected in the GUI dialog.  If, in addition, a path is given it is also used as current path.

     See also: uigetfile, uigetdir.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Open a GUI dialog for selecting a file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
uiresume


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 304
 -- Function File: uiresume (H)
     Resume program execution suspended with 'uiwait'.

     The handle H must be the same as the on specified in 'uiwait'.  If the handle is invalid or there is no 'uiwait' call pending for the figure with handle H, this function does nothing.

     See also: uiwait.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Resume program execution suspended with 'uiwait'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
uitoggletool


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1207
 -- Function File: HUI = uitoggletool (PROPERTY, VALUE, ...)
 -- Function File: HUI = uitoggletool (PARENT, PROPERTY, VALUE, ...)

     Create a uitoggletool object and return a handle to it.

     uitoggletool are togglebuttons that appear on a figure toolbar.  The button is created with a border that is shown when the user hovers over the button.  An image can be set using the cdata property.

     If PARENT is omitted then a uitoggletool for the current figure is created.  If no figure is available, a new figure is created first.  If a figure is available, but does not contain a uitoolbar, a uitoolbar will be created.

     If PARENT is given then a uitoggletool is created on the PARENT uitoolbar.

     Any provided property value pairs will override the default values of the created uitoggletool object.

     Examples:

          % create figure without a default toolbar
          f = figure ("toolbar", "none");
          % create empty toolbar
          t = uitoolbar (f);
          % create a 19x19x3 black square
          img=zeros(19,19,3);
          % add uitoggletool button to toolbar
          b = uitoggletool (t, "cdata", img);

     See also: figure, uitoolbar, uipushtool.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Create a uitoggletool object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
uitoolbar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 785
 -- Function File: HUI = uitoolbar (PROPERTY, VALUE, ...)
 -- Function File: HUI = uitoolbar (PARENT, PROPERTY, VALUE, ...)

     Create a uitoolbar object and return a handle to it.  A uitoolbar displays uitoggletool and uipushtool buttons.

     If PARENT is omitted then a uitoolbar for the current figure is created.  If no figure is available, a new figure is created first.

     If PARENT is given then a uitoolbar relative to PARENT is created.

     Any provided property value pairs will override the default values of the created uitoolbar object.

     Examples:

          % create figure without a default toolbar
          f = figure ("toolbar", "none");
          % create empty toolbar
          t = uitoolbar (f);

     See also: figure, uitoggletool, uipushtool.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Create a uitoolbar object and return a handle to it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
uiwait


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 806
 -- Function File: uiwait
 -- Function File: uiwait (H)
 -- Function File: uiwait (H, TIMEOUT)
     Suspend program execution until the figure with handle H is deleted or 'uiresume' is called.

     When no figure handle is specified this function uses the current figure.  If the figure handle is invalid or there is no current figure, this functions returns immediately.

     When specified, TIMEOUT defines the number of seconds to wait for the figure deletion or the 'uiresume' call.  The timeout value must be at least 1.  If a smaller value is specified, a warning is issued and a timeout value of 1 is used instead.  If a non-integer value is specified, it is truncated towards 0.  If TIMEOUT is not specified, the program execution is suspended indefinitely.

     See also: uiresume, waitfor.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 92
Suspend program execution until the figure with handle H is deleted or 'uiresume' is called.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
waitbar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 842
 -- Function File: H = waitbar (FRAC)
 -- Function File: H = waitbar (FRAC, MSG)
 -- Function File: H = waitbar (..., "FigureProperty", "Value", ...)
 -- Function File: waitbar (FRAC)
 -- Function File: waitbar (FRAC, HWBAR)
 -- Function File: waitbar (FRAC, HWBAR, MSG)
     Return a handle H to a new waitbar object.

     The waitbar is filled to fraction FRAC which must be in the range [0, 1].

     The optional message MSG is centered and displayed above the waitbar.

     The appearance of the waitbar figure window can be configured by passing property/value pairs to the function.

     When called with a single input the current waitbar, if it exists, is updated to the new value FRAC.  If there are multiple outstanding waitbars they can be updated individually by passing the handle HWBAR of the specific waitbar to modify.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Return a handle H to a new waitbar object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
waitforbuttonpress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 290
 -- Function File: waitforbuttonpress ()
 -- Function File: B = waitforbuttonpress ()
     Wait for mouse click or key press over the current figure window.

     The return value of B is 0 if a mouse button was pressed or 1 if a key was pressed.

     See also: waitfor, ginput, kbhit.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Wait for mouse click or key press over the current figure window.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
warndlg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 668
 -- Function File: H = warndlg (MSG)
 -- Function File: H = warndlg (MSG, TITLE)
 -- Function File: H = warndlg (MSG, TITLE, CREATEMODE)
     Display MSG using a warning dialog box.

     The message may have multiple lines separated by newline characters ("\n"), or it may be a cellstr array with one element for each line.

     The optional input TITLE (character string) can be used to set the dialog caption.  The default title is "Warning Dialog".

     The return value is always 1.

     Compatibility Note: The optional argument CREATEMODE is accepted for MATLAB compatibility, but is not implemented.

     See also: helpdlg, inputdlg, listdlg, questdlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Display MSG using a warning dialog box.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
doc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 518
 -- Command: doc FUNCTION_NAME
 -- Command: doc
     Display documentation for the function FUNCTION_NAME directly from an online version of the printed manual, using the GNU Info browser.

     If invoked without an argument, the manual is shown from the beginning.

     For example, the command 'doc rand' starts the GNU Info browser at the 'rand' node in the online version of the manual.

     Once the GNU Info browser is running, help for using it is available using the command 'C-h'.

     See also: help.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 135
Display documentation for the function FUNCTION_NAME directly from an online version of the printed manual, using the GNU Info browser.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
doc_cache_create


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 656
 -- Function File: doc_cache_create (OUT_FILE, DIRECTORY)
 -- Function File: doc_cache_create (OUT_FILE)
 -- Function File: doc_cache_create ()
     Generate documentation cache for all functions in DIRECTORY.

     A documentation cache is generated for all functions in DIRECTORY which may be a single string or a cell array of strings.  The cache is used to speed up the function 'lookfor'.

     The cache is saved in the file OUT_FILE which defaults to the value 'doc-cache' if not given.

     If no directory is given (or it is the empty matrix), a cache for built-in operators, etc.  is generated.

     See also: doc_cache_file, lookfor, path.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Generate documentation cache for all functions in DIRECTORY.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
get_first_help_sentence


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 876
 -- Function File: TEXT = get_first_help_sentence (NAME)
 -- Function File: TEXT = get_first_help_sentence (NAME, MAX_LEN)
 -- Function File: [TEXT, STATUS] = get_first_help_sentence (...)
     Return the first sentence of a function's help text.

     The first sentence is defined as the text after the function declaration until either the first period (".")  or the first appearance of two consecutive newlines ("\n\n").  The text is truncated to a maximum length of MAX_LEN, which defaults to 80.

     The optional output argument STATUS returns the status reported by 'makeinfo'.  If only one output argument is requested, and STATUS is nonzero, a warning is displayed.

     As an example, the first sentence of this help text is

          get_first_help_sentence ("get_first_help_sentence")
          -| ans = Return the first sentence of a function's help text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return the first sentence of a function's help text.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
help


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 908
 -- Command: help NAME
 -- Command: help '--list'
 -- Command: help '.'
 -- Command: help
     Display the help text for NAME.

     For example, the command 'help help' prints a short message describing the 'help' command.

     Given the single argument '--list', list all operators, keywords, built-in functions, and loadable functions available in the current session of Octave.

     Given the single argument '.', list all operators available in the current session of Octave.

     If invoked without any arguments, 'help' display instructions on how to access help from the command line.

     The help command can provide information about most operators, for example 'help +', but not the comma and semicolon characters which are used by the Octave interpreter as command separators.  For help on either of these type 'help comma' or 'help semicolon'.

     See also: doc, lookfor, which, info.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Display the help text for NAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
lookfor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1364
 -- Command: lookfor STR
 -- Command: lookfor -all STR
 -- Function File: [FCN, HELP1STR] = lookfor (STR)
 -- Function File: [FCN, HELP1STR] = lookfor ("-all", STR)
     Search for the string STR in the documentation of all functions in the current function search path.

     By default, 'lookfor' looks for STR in just the first sentence of the help string for each function found.  The entire help text of each function can be searched by using the "-all" argument.  All searches are case insensitive.

     When called with no output arguments, 'lookfor' prints the list of matching functions to the terminal.  Otherwise, the output argument FCNS contains the function names and HELP1STR contains the first sentence from the help string of each function.

     Programming Note: The ability of 'lookfor' to correctly identify the first sentence of the help text is dependent on the format of the function's help.  All Octave core functions are correctly formatted, but the same can not be guaranteed for external packages and user-supplied functions.  Therefore, the use of the "-all" argument may be necessary to find related functions that are not a part of Octave.

     The speed of lookup is greatly enhanced by having a cached documentation file.  See 'doc_cache_create' for more information.

     See also: help, doc, which, path, doc_cache_create.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 100
Search for the string STR in the documentation of all functions in the current function search path.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
print_usage


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: print_usage ()
 -- Function File: print_usage (NAME)
     Print the usage message for the function NAME.

     When called with no input arguments the 'print_usage' function displays the usage message of the currently executing function.

     See also: help.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Print the usage message for the function NAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
type


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 558
 -- Command: type NAME ...
 -- Command: type -q NAME ...
 -- Function File: text = type ("NAME", ...)
     Display the contents of NAME which may be a file, function (m-file), variable, operator, or keyword.

     'type' normally prepends a header line describing the category of NAME such as function or variable; The '-q' option suppresses this behavior.

     If no output variable is used the contents are displayed on screen.  Otherwise, a cell array of strings is returned, where each element corresponds to the contents of each requested function.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 100
Display the contents of NAME which may be a file, function (m-file), variable, operator, or keyword.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
which


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 190
 -- Command: which name ...
     Display the type of each NAME.

     If NAME is defined from a function file, the full name of the file is also displayed.

     See also: help, lookfor.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Display the type of each NAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
autumn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 293
 -- Function File: MAP = autumn ()
 -- Function File: MAP = autumn (N)
     Create color colormap.  This colormap ranges from red through orange to yellow.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
bone


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 297
 -- Function File: MAP = bone ()
 -- Function File: MAP = bone (N)
     Create color colormap.  This colormap varies from black to white with gray-blue shades.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
brighten


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 703
 -- Function File: MAP_OUT = brighten (BETA)
 -- Function File: MAP_OUT = brighten (MAP, BETA)
 -- Function File: MAP_OUT = brighten (H, BETA)
 -- Function File: brighten (...)
     Brighten or darken a colormap.

     The argument BETA must be a scalar between -1 and 1, where a negative value darkens and a positive value brightens the colormap.

     If the MAP argument is omitted, the function is applied to the current colormap.

     The first argument can also be a valid graphics handle H, in which case 'brighten' is applied to the colormap associated with this handle.

     If no output is specified then the result is written to the current colormap.

     See also: colormap, contrast.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Brighten or darken a colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cmpermute


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 -- Function File: [Y, NEWMAP] = cmpermute (X, MAP)
 -- Function File: [Y, NEWMAP] = cmpermute (X, MAP, INDEX)
     Reorder colors in a colormap.

     When called with only two arguments, 'cmpermute' randomly rearranges the colormap MAP and returns a new colormap NEWMAP.  It also returns the indexed image Y which is the equivalent of the original input image X when displayed using NEWMAP.

     When called with an optional third argument the order of colors in the new colormap is defined by INDEX.

     *Caution:* 'index' should not have repeated elements or the function will fail.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Reorder colors in a colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cmunique


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1381
 -- Function File: [Y, NEWMAP] = cmunique (X, MAP)
 -- Function File: [Y, NEWMAP] = cmunique (RGB)
 -- Function File: [Y, NEWMAP] = cmunique (I)
     Convert an input image X to an ouput indexed image Y which uses the smallest colormap possible NEWMAP.

     When the input is an indexed image (X with colormap MAP) the output is a colormap NEWMAP from which any repeated rows have been eliminated.  The output image, Y, is the original input image with the indices adjusted to match the new, possibly smaller, colormap.

     When the input is an RGB image (an MxNx3 array), the output colormap will contain one entry for every unique color in the original image.  In the worst case the new map could have as many rows as the number of pixels in the original image.

     When the input is a grayscale image I, the output colormap will contain one entry for every unique intensity value in the original image.  In the worst case the new map could have as many rows as the number of pixels in the original image.

     Implementation Details:

     NEWMAP is always an Mx3 matrix, even if the input image is an intensity grayscale image I (all three RGB planes are assigned the same value).

     The output image is of class uint8 if the size of the new colormap is less than or equal to 256.  Otherwise, the output image is of class double.

     See also: rgb2ind, gray2ind.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 102
Convert an input image X to an ouput indexed image Y which uses the smallest colormap possible NEWMAP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
colorcube


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 512
 -- Function File: MAP = colorcube ()
 -- Function File: MAP = colorcube (N)
     Create color colormap.  This colormap is composed of as many equally spaced colors (not grays) in the RGB color space as possible.

     If there are not a perfect number N of regularly spaced colors then the remaining entries in the colormap are gradients of pure red, green, blue, and gray.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
colormap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1442
 -- Function File: CMAP = colormap ()
 -- Function File: CMAP = colormap (MAP)
 -- Function File: CMAP = colormap ("default")
 -- Function File: CMAP = colormap ("MAP_NAME")
 -- Function File: CMAP = colormap (HAX, ...)
 -- Command: colormap MAP_NAME
 -- Function File: CMAPS = colormap ("list")
 -- Function File: colormap ("register", "NAME")
 -- Function File: colormap ("unregister", "NAME")
     Query or set the current colormap.

     With no input arguments, 'colormap' returns the current color map.

     'colormap (MAP)' sets the current colormap to MAP.  The colormap should be an N row by 3 column matrix.  The columns contain red, green, and blue intensities respectively.  All entries must be between 0 and 1 inclusive.  The new colormap is returned.

     'colormap ("default")' restores the default colormap (the 'jet' map with 64 entries).  The default colormap is returned.

     The map may also be specified by a string, "MAP_NAME", where MAP_NAME is the name of a function that returns a colormap.

     If the first argument HAX is an axes handle, then the colormap for the parent figure of HAX is queried or set.

     For convenience, it is also possible to use this function with the command form, 'colormap MAP_NAME'.

     'colormap ("list")' returns a cell array with all of the available colormaps.  The options "register" and "unregister" add or remove the colormap NAME from this list.

     See also: jet.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Query or set the current colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
contrast


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 303
 -- Function File: CMAP = contrast (X)
 -- Function File: CMAP = contrast (X, N)
     Return a gray colormap that maximizes the contrast in an image.

     The returned colormap will have N rows.  If N is not defined then the size of the current colormap is used.

     See also: colormap, brighten.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Return a gray colormap that maximizes the contrast in an image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cool


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 275
 -- Function File: MAP = cool ()
 -- Function File: MAP = cool (N)
     Create color colormap.  The colormap varies from cyan to magenta.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
copper


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 293
 -- Function File: MAP = copper ()
 -- Function File: MAP = copper (N)
     Create color colormap.  This colormap varies from black to a light copper tone.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
cubehelix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 828
 -- Function File: MAP = cubehelix ()
 -- Function File: MAP = cubehelix (N)
     Create cubehelix colormap.

     This colormap varies from black to white going though blue, green, and red tones while maintaining a monotonically increasing perception of intensity.  This is achieved by transversing a color cube from black to white through a helix, hence the name cubehelix, while taking into account the perceived brightness of each channel according to the NTSC specifications from 1953.

          rgbplot (cubehelix (256))

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     Reference: Green, D. A., 2011, '"A colour scheme for the display of astronomical intensity images"', Bulletin of the Astronomical Society of India, 39, 289.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Create cubehelix colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
flag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- Function File: MAP = flag ()
 -- Function File: MAP = flag (N)
     Create color colormap.  This colormap cycles through red, white, blue, and black with each index change.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
gray


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 294
 -- Function File: MAP = gray ()
 -- Function File: MAP = gray (N)
     Create gray colormap.  This colormap varies from black to white with shades of gray.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Create gray colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
gray2ind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 591
 -- Function File: IMG = gray2ind (I)
 -- Function File: IMG = gray2ind (I, N)
 -- Function File: IMG = gray2ind (BW)
 -- Function File: IMG = gray2ind (BW, N)
 -- Function File: [IMG, MAP] = gray2ind (...)
     Convert a grayscale or binary intensity image to an indexed image.

     The indexed image will consist of N different intensity values.  If not given N defaults to 64 for grayscale images or 2 for binary black and white images.

     The output IMG is of class uint8 if N is less than or equal to 256; Otherwise the return class is uint16.

     See also: ind2gray, rgb2ind.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Convert a grayscale or binary intensity image to an indexed image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
hot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 312
 -- Function File: MAP = hot ()
 -- Function File: MAP = hot (N)
     Create color colormap.  This colormap ranges from black through dark red, red, orange, yellow, to white.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
hsv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 550
 -- Function File: hsv (N)
     Create color colormap.  This colormap begins with red, changes through yellow, green, cyan, blue, and magenta, before returning to red.

     It is useful for displaying periodic functions.  The map is obtained by linearly varying the hue through all possible values while keeping constant maximum saturation and value.  The equivalent code is 'hsv2rgb ([(0:N-1)'/N, ones(N,2)])'.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hsv2rgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 556
 -- Function File: RGB_MAP = hsv2rgb (HSV_MAP)
 -- Function File: RGB_IMG = hsv2rgb (HSV_IMG)
     Transform a colormap or image from hue-saturation-value (HSV) space to red-green-blue (RGB) space.

     A color in HSV space is represented by hue, saturation and value (brightness) levels.  Value gives the amount of light in the color.  Hue describes the dominant wavelength.  Saturation is the amount of hue mixed into the color.

     A color in the RGB space consists of red, green, and blue intensities.

     See also: rgb2hsv, ind2rgb, ntsc2rgb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 98
Transform a colormap or image from hue-saturation-value (HSV) space to red-green-blue (RGB) space.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
iscolormap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 329
 -- Function File: iscolormap (CMAP)
     Return true if CMAP is a colormap.

     A colormap is a real matrix with N rows and 3 columns.  Each row represents a single color.  The columns contain red, green, and blue intensities respectively.  All entries must be between 0 and 1 inclusive.

     See also: colormap, rgbplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Return true if CMAP is a colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
image


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1887
 -- Function File: image (IMG)
 -- Function File: image (X, Y, IMG)
 -- Function File: image (..., "PROP", VAL, ...)
 -- Function File: image ("PROP1", VAL1, ...)
 -- Function File: H = image (...)
     Display a matrix as an indexed color image.

     The elements of IMG are indices into the current colormap.

     X and Y are optional 2-element vectors, '[min, max]', which specify the range for the axis labels.  If a range is specified as '[max, min]' then the image will be reversed along that axis.  For convenience, X and Y may be specified as N-element vectors matching the length of the data in IMG.  However, only the first and last elements will be used to determine the axis limits.  *Warning:* X and Y are ignored when using gnuplot 4.0 or earlier.

     Multiple property/value pairs may be specified for the image object, but they must appear in pairs.

     The optional return value H is a graphics handle to the image.

     Implementation Note: The origin (0, 0) for images is located in the upper left.  For ordinary plots, the origin is located in the lower left.  Octave handles this inversion by plotting the data normally, and then reversing the direction of the y-axis by setting the 'ydir' property to "reverse".  This has implications whenever an image and an ordinary plot need to be overlaid.  The recommended solution is to display the image and then plot the reversed ydata using, for example, 'flipud (ydata)'.

     Calling Forms: The 'image' function can be called in two forms: High-Level and Low-Level.  When invoked with normal options, the High-Level form is used which first calls 'newplot' to prepare the graphic figure and axes.  When the only inputs to 'image' are property/value pairs the Low-Level form is used which creates a new instance of an image object and inserts it in the current axes.

     See also: imshow, imagesc, colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Display a matrix as an indexed color image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
imagesc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1266
 -- Function File: imagesc (IMG)
 -- Function File: imagesc (X, Y, IMG)
 -- Function File: imagesc (..., CLIMITS)
 -- Function File: imagesc (..., "PROP", VAL, ...)
 -- Function File: imagesc ("PROP1", VAL1, ...)
 -- Function File: imagesc (HAX, ...)
 -- Function File: H = imagesc (...)
     Display a scaled version of the matrix IMG as a color image.

     The colormap is scaled so that the entries of the matrix occupy the entire colormap.  If 'CLIMITS = [LO, HI]' is given, then that range is set to the "clim" of the current axes.

     The axis values corresponding to the matrix elements are specified in X and Y, either as pairs giving the minimum and maximum values for the respective axes, or as values for each row and column of the matrix IMG.

     The optional return value H is a graphics handle to the image.

     Calling Forms: The 'imagesc' function can be called in two forms: High-Level and Low-Level.  When invoked with normal options, the High-Level form is used which first calls 'newplot' to prepare the graphic figure and axes.  When the only inputs to 'image' are property/value pairs the Low-Level form is used which creates a new instance of an image object and inserts it in the current axes.

     See also: image, imshow, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Display a scaled version of the matrix IMG as a color image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
imfinfo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3857
 -- Function File: INFO = imfinfo (FILENAME)
 -- Function File: INFO = imfinfo (URL)
 -- Function File: INFO = imfinfo (..., EXT)
     Read image information from a file.

     'imfinfo' returns a structure containing information about the image stored in the file FILENAME.  If there is no file FILENAME, and EXT was specified, it will look for a file named FILENAME and extension EXT, i.e., a file named FILENAME.EXT.

     The output structure INFO contains the following fields:

     'Filename'
          The full name of the image file.

     'FileModDate'
          Date of last modification to the file.

     'FileSize'
          Number of bytes of the image on disk

     'Format'
          Image format (e.g., "jpeg").

     'Height'
          Image height in pixels.

     'Width'
          Image Width in pixels.

     'BitDepth'
          Number of bits per channel per pixel.

     'ColorType'
          Image type.  Value is "grayscale", "indexed", "truecolor", "CMYK", or "undefined".

     'XResolution'
          X resolution of the image.

     'YResolution'
          Y resolution of the image.

     'ResolutionUnit'
          Units of image resolution.  Value is "Inch", "Centimeter", or "undefined".

     'DelayTime'
          Time in 1/100ths of a second (0 to 65535) which must expire before displaying the next image in an animated sequence.

     'LoopCount'
          Number of iterations to loop an animation.

     'ByteOrder'
          Endian option for formats that support it.  Value is "little-endian", "big-endian", or "undefined".

     'Gamma'
          Gamma level of the image.  The same color image displayed on two different workstations may look different due to differences in the display monitor.

     'Quality'
          JPEG/MIFF/PNG compression level.  Value is an integer in the range [0 100].

     'DisposalMethod'
          Only valid for GIF images, control how successive frames are rendered (how the preceding frame is disposed of) when creating a GIF animation.  Values can be "doNotSpecify", "leaveInPlace", "restoreBG", or "restorePrevious".  For non-GIF files, value is an empty string.

     'Chromaticities'
          Value is a 1x8 Matrix with the x,y chromaticity values for white, red, green, and blue points, in that order.

     'Comment'
          Image comment.

     'Compression'
          Compression type.  Value can be "none", "bzip", "fax3", "fax4", "jpeg", "lzw", "rle", "deflate", "lzma", "jpeg2000", "jbig2", "jbig2", or "undefined".

     'Colormap'
          Colormap for each image.

     'Orientation'
          The orientation of the image with respect to the rows and columns.  Value is an integer between 1 and 8 as defined in the TIFF 6 specifications, and for MATLAB compatibility.

     'Software'
          Name and version of the software or firmware of the camera or image input device used to generate the image.

     'Make'
          The manufacturer of the recording equipment.  This is the manufacture of the DSC, scanner, video digitizer or other equipment that generated the image.

     'Model'
          The model name or model number of the recording equipment as mentioned on the field "Make".

     'DateTime'
          The date and time of image creation as defined by the Exif standard, i.e., it is the date and time the file was changed.

     'ImageDescription'
          The title of the image as defined by the Exif standard.

     'Artist'
          Name of the camera owner, photographer or image creator.

     'Copyright'
          Copyright notice of the person or organization claiming rights to the image.

     'DigitalCamera'
          A struct with information retrieved from the Exif tag.

     'GPSInfo'
          A struct with geotagging information retrieved from the Exif tag.

     See also: imread, imwrite, imshow, imformats.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Read image information from a file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
imformats


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1731
 -- Function File: imformats ()
 -- Function File: FORMATS = imformats (EXT)
 -- Function File: FORMATS = imformats (FORMAT)
 -- Function File: FORMATS = imformats ("add", FORMAT)
 -- Function File: FORMATS = imformats ("remove", EXT)
 -- Function File: FORMATS = imformats ("update", EXT, FORMAT)
 -- Function File: FORMATS = imformats ("factory")
     Manage supported image formats.

     FORMATS is a structure with information about each supported file format, or from a specific format EXT, the value displayed on the field 'ext'.  It contains the following fields:

     ext
          The name of the file format.  This may match the file extension but Octave will automatically detect the file format.

     description
          A long description of the file format.

     isa
          A function handle to confirm if a file is of the specified format.

     write
          A function handle to write if a file is of the specified format.

     read
          A function handle to open files the specified format.

     info
          A function handle to obtain image information of the specified format.

     alpha
          Logical value if format supports alpha channel (transparency or matte).

     multipage
          Logical value if format supports multipage (multiple images per file).

     It is possible to change the way Octave manages file formats with the options "add", "remove", and "update", and supplying a structure FORMAT with the required fields.  The option "factory" resets the configuration to the default.

     This can be used by Octave packages to extend the image reading capabilities Octave, through use of the PKG_ADD and PKG_DEL commands.

     See also: imfinfo, imread, imwrite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Manage supported image formats.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
imread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2606
 -- Function File: [IMG, MAP, ALPHA] = imread (FILENAME)
 -- Function File: [...] = imread (URL)
 -- Function File: [...] = imread (..., EXT)
 -- Function File: [...] = imread (..., IDX)
 -- Function File: [...] = imread (..., PARAM1, VAL1, ...)
     Read images from various file formats.

     Read an image as a matrix from the file FILENAME.  If there is no file FILENAME, and EXT was specified, it will look for a file with the extension EXT.  Finally, it will attempt to download and read an image from URL.

     The size and class of the output depends on the format of the image.  A color image is returned as an MxNx3 matrix.  Gray-level and black-and-white images are of size MxN. Multipage images will have an additional 4th dimension.

     The bit depth of the image determines the class of the output: "uint8", "uint16" or "single" for gray and color, and "logical" for black and white.  Note that indexed images always return the indexes for a colormap, independent if MAP is a requested output.  To obtain the actual RGB image, use 'ind2rgb'.  When more than one indexed image is being read, MAP is obtained from the first.  In some rare cases this may be incorrect and 'imfinfo' can be used to obtain the colormap of each image.

     See the Octave manual for more information in representing images.

     Some file formats, such as TIFF and GIF, are able to store multiple images in a single file.  IDX can be a scalar or vector specifying the index of the images to read.  By default, Octave will only read the first page.

     Depending on the file format, it is possible to configure the reading of images with PARAM, VAL pairs.  The following options are supported:

     '"Frames" or "Index"'
          This is an alternative method to specify IDX.  When specifying it in this way, its value can also be the string "all".

     '"Info"'
          This option exists for MATLAB compatibility and has no effect.  For maximum performance while reading multiple images from a single file, use the Index option.

     '"PixelRegion"'
          Controls the image region that is read.  Takes as value a cell array with two arrays of 3 elements '{ROWS COLS}'.  The elements in the array are the start, increment and end pixel to be read.  If the increment value is omitted, defaults to 1.  For example, the following are all equivalent:

               imread (filename, "PixelRegion", {[200 600] [300 700]});
               imread (filename, "PixelRegion", {[200 1 600] [300 1 700]});
               imread (filename)(200:600, 300:700);

     See also: imwrite, imfinfo, imformats.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Read images from various file formats.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
imshow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1727
 -- Function File: imshow (IM)
 -- Function File: imshow (IM, LIMITS)
 -- Function File: imshow (IM, MAP)
 -- Function File: imshow (RGB, ...)
 -- Function File: imshow (FILENAME)
 -- Function File: imshow (..., STRING_PARAM1, VALUE1, ...)
 -- Function File: H = imshow (...)
     Display the image IM, where IM can be a 2-dimensional (grayscale image) or a 3-dimensional (RGB image) matrix.

     If LIMITS is a 2-element vector '[LOW, HIGH]', the image is shown using a display range between LOW and HIGH.  If an empty matrix is passed for LIMITS, the display range is computed as the range between the minimal and the maximal value in the image.

     If MAP is a valid color map, the image will be shown as an indexed image using the supplied color map.

     If a file name is given instead of an image, the file will be read and shown.

     If given, the parameter STRING_PARAM1 has value VALUE1.  STRING_PARAM1 can be any of the following:

     "displayrange"
          VALUE1 is the display range as described above.

     "colormap"
          VALUE1 is the colormap to use when displaying an indexed image.

     "xdata"
          If VALUE1 is a two element vector, it must contain horizontal axis limits in the form [xmin xmax]; Otherwise VALUE1 must be a vector and only the first and last elements will be used for xmin and xmax respectively.

     "ydata"
          If VALUE1 is a two element vector, it must contain vertical axis limits in the form [ymin ymax]; Otherwise VALUE1 must be a vector and only the first and last elements will be used for ymin and ymax respectively.

     The optional return value H is a graphics handle to the image.

     See also: image, imagesc, colormap, gray2ind, rgb2ind.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 110
Display the image IM, where IM can be a 2-dimensional (grayscale image) or a 3-dimensional (RGB image) matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
imwrite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3288
 -- Function File: imwrite (IMG, FILENAME)
 -- Function File: imwrite (IMG, FILENAME, EXT)
 -- Function File: imwrite (IMG, MAP, FILENAME)
 -- Function File: imwrite (..., PARAM1, VAL1, ...)
     Write images in various file formats.

     The image IMG can be a binary, grayscale, RGB, or multi-dimensional image.  The size and class of IMG should be the same as what should be expected when reading it with 'imread': the 3rd and 4th dimensions reserved for color space, and multiple pages respectively.  If it's an indexed image, the colormap MAP must also be specified.

     If EXT is not supplied, the file extension of FILENAME is used to determine the format.  The actual supported formats are dependent on options made during the build of Octave.  Use 'imformats' to check the support of the different image formats.

     Depending on the file format, it is possible to configure the writing of images with PARAM, VAL pairs.  The following options are supported:

     'Alpha'
          Alpha (transparency) channel for the image.  This must be a matrix with same class, and number of rows and columns of IMG.  In case of a multipage image, the size of the 4th dimension must also match and the third dimension must be a singleton.  By default, image will be completely opaque.

     'DelayTime'
          For formats that accept animations (such as GIF), controls for how long a frame is displayed until it moves to the next one.  The value must be scalar (which will applied to all frames in IMG), or a vector of length equal to the number of frames in IM.  The value is in seconds, must be between 0 and 655.35, and defaults to 0.5.

     'DisposalMethod'
          For formats that accept animations (such as GIF), controls what happens to a frame before drawing the next one.  Its value can be one of the following strings: "doNotSpecify" (default); "leaveInPlace"; "restoreBG"; and "restorePrevious", or a cell array of those string with length equal to the number of frames in IMG.

     'LoopCount'
          For formats that accept animations (such as GIF), controls how many times the sequence is repeated.  A value of Inf means an infinite loop (default), a value of 0 or 1 that the sequence is played only once (loops zero times), while a value of 2 or above loops that number of times (looping twice means it plays the complete sequence 3 times).  This option is ignored when there is only a single image at the end of writing the file.

     'Quality'
          Set the quality of the compression.  The value should be an integer between 0 and 100, with larger values indicating higher visual quality and lower compression.  Defaults to 75.

     'WriteMode'
          Some file formats, such as TIFF and GIF, are able to store multiple images in a single file.  This option specifies if IMG should be appended to the file (if it exists) or if a new file should be created for it (possibly overwriting an existing file).  The value should be the string "Overwrite" (default), or "Append".

          Despite this option, the most efficient method of writing a multipage image is to pass a 4 dimensional IMG to 'imwrite', the same matrix that could be expected when using 'imread' with the option "Index" set to "all".

     See also: imread, imfinfo, imformats.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Write images in various file formats.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ind2gray


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 829
 -- Function File: I = ind2gray (X, MAP)
     Convert a color indexed image to a grayscale intensity image.

     The image X must be an indexed image which will be converted using the colormap CMAP.  If CMAP does not contain enough colors for the image, pixels in X outside the range are mapped to the last color in the map before conversion to grayscale.

     The output I is of the same class as the input X and may be one of 'uint8', 'uint16', 'single', or 'double'.

     Implementation Note: There are several ways of converting colors to grayscale intensities.  This functions uses the luminance value obtained from 'rgb2ntsc' which is 'I = 0.299*R + 0.587*G + 0.114*B'.  Other possibilities include the value component from 'rgb2hsv' or using a single color channel from 'ind2rgb'.

     See also: gray2ind, ind2rgb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Convert a color indexed image to a grayscale intensity image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ind2rgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 767
 -- Function File: RGB = ind2rgb (X, MAP)
 -- Function File: [R, G, B] = ind2rgb (X, MAP)
     Convert an indexed image to red, green, and blue color components.

     The image X must be an indexed image which will be converted using the colormap MAP.  If MAP does not contain enough colors for the image, pixels in X outside the range are mapped to the last color in the map.

     The output may be a single RGB image (MxNx3 matrix where M and N are the original image X dimensions, one for each of the red, green and blue channels).  Alternatively, the individual red, green, and blue color matrices of size MxN may be returned.

     Multi-dimensional indexed images (of size MxNx1xK) are also supported.

     See also: rgb2ind, ind2gray, hsv2rgb, ntsc2rgb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Convert an indexed image to red, green, and blue color components.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
jet


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 320
 -- Function File: MAP = jet ()
 -- Function File: MAP = jet (N)
     Create color colormap.  This colormap ranges from dark blue through blue, cyan, green, yellow, red, to dark red.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
lines


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 390
 -- Function File: MAP = lines ()
 -- Function File: MAP = lines (N)
     Create color colormap.  This colormap is composed of the list of colors in the current axes "ColorOrder" property.  The default is blue, green, red, cyan, pink, yellow, and gray.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ntsc2rgb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- Function File: RGB_MAP = ntsc2rgb (YIQ_MAP)
 -- Function File: RGB_IMG = ntsc2rgb (YIQ_IMG)
     Transform a colormap or image from luminance-chrominance (NTSC) space to red-green-blue (RGB) color space.

     Implementation Note: The conversion matrix is chosen to be the inverse of the matrix used for rgb2ntsc such that

          x == ntsc2rgb (rgb2ntsc (x))

     MATLAB uses a slightly different matrix where rounding means the equality above does not hold.

     See also: rgb2ntsc, hsv2rgb, ind2rgb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 106
Transform a colormap or image from luminance-chrominance (NTSC) space to red-green-blue (RGB) color space.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ocean


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 297
 -- Function File: MAP = ocean ()
 -- Function File: MAP = ocean (N)
     Create color colormap.  This colormap varies from black to white with shades of blue.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
pink


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 -- Function File: MAP = pink ()
 -- Function File: MAP = pink (N)
     Create color colormap.  This colormap varies from black to white with shades of gray-pink.

     This colormap gives a sepia tone when used on grayscale images.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
prism


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 332
 -- Function File: MAP = prism ()
 -- Function File: MAP = prism (N)
     Create color colormap.  This colormap cycles through red, orange, yellow, green, blue and violet with each index change.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
rainbow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 317
 -- Function File: MAP = rainbow ()
 -- Function File: MAP = rainbow (N)
     Create color colormap.  This colormap ranges from red through orange, yellow, green, blue, to violet.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
rgb2hsv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 549
 -- Function File: HSV_MAP = rgb2hsv (RGB)
 -- Function File: HSV_MAP = rgb2hsv (RGB)
     Transform a colormap or image from red-green-blue (RGB) space to hue-saturation-value (HSV) space.

     A color in the RGB space consists of red, green, and blue intensities.

     A color in HSV space is represented by hue, saturation, and value (brightness) levels.  Value gives the amount of light in the color.  Hue describes the dominant wavelength.  Saturation is the amount of hue mixed into the color.

     See also: hsv2rgb, rgb2ind, rgb2ntsc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 98
Transform a colormap or image from red-green-blue (RGB) space to hue-saturation-value (HSV) space.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
rgb2ind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 925
 -- Function File: [X, MAP] = rgb2ind (RGB)
 -- Function File: [X, MAP] = rgb2ind (R, G, B)
     Convert an image in red-green-blue (RGB) color space to an indexed image.

     The input image RGB can be specified as a single matrix of size MxNx3, or as three separate variables, R, G, and B, its three color channels, red, green, and blue.

     It outputs an indexed image X and a colormap MAP to interpret an image exactly the same as the input.  No dithering or other form of color quantization is performed.  The output class of the indexed image X can be uint8, uint16 or double, whichever is required to specify the number of unique colors in the image (which will be equal to the number of rows in MAP) in order

     Multi-dimensional indexed images (of size MxNx3xK) are also supported, both via a single input (RGB) or its three color channels as separate variables.

     See also: ind2rgb, rgb2hsv, rgb2ntsc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Convert an image in red-green-blue (RGB) color space to an indexed image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
rgb2ntsc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 739
 -- Function File: YIQ_MAP = rgb2ntsc (RGB_MAP)
 -- Function File: YIQ_IMG = rgb2ntsc (RGB_IMG)
     Transform a colormap or image from red-green-blue (RGB) color space to luminance-chrominance (NTSC) space.  The input may be of class uint8, uint16, single, or double.  The output is of class double.

     Implementation Note: The reference matrix for the transformation is

          /Y\     0.299  0.587  0.114  /R\
          |I|  =  0.596 -0.274 -0.322  |G|
          \Q/     0.211 -0.523  0.312  \B/

     as documented in <http://en.wikipedia.org/wiki/YIQ> and truncated to 3 significant figures.  Note: The FCC version of NTSC uses only 2 significant digits and is slightly different.

     See also: ntsc2rgb, rgb2hsv, rgb2ind.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 106
Transform a colormap or image from red-green-blue (RGB) color space to luminance-chrominance (NTSC) space.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
rgbplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 799
 -- Function File: rgbplot (CMAP)
 -- Function File: rgbplot (CMAP, STYLE)
 -- Function File: H = rgbplot (...)
     Plot the components of a colormap.

     Two different STYLEs are available for displaying the CMAP:

     profile (default)
          Plot the RGB line profile of the colormap for each of the channels (red, green and blue) with the plot lines colored appropriately.  Each line represents the intensity of each RGB components across the colormap.

     composite
          Draw the colormap across the X-axis so that the actual index colors are visible rather than the individual color components.

     The optional return value H is a graphics handle to the created plot.

     Run 'demo rgbplot' to see an example of 'rgbplot' and each style option.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Plot the components of a colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
spinmap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 627
 -- Function File: spinmap ()
 -- Function File: spinmap (T)
 -- Function File: spinmap (T, INC)
 -- Function File: spinmap ("inf")
     Cycle the colormap for T seconds with a color increment of INC.

     Both parameters are optional.  The default cycle time is 5 seconds and the default increment is 2.  If the option "inf" is given then cycle continuously until 'Control-C' is pressed.

     When rotating, the original color 1 becomes color 2, color 2 becomes color 3, etc.  A positive or negative increment is allowed and a higher value of INC will cause faster cycling through the colormap.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Cycle the colormap for T seconds with a color increment of INC.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
spring


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: MAP = spring ()
 -- Function File: MAP = spring (N)
     Create color colormap.  This colormap varies from magenta to yellow.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
summer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 280
 -- Function File: MAP = summer ()
 -- Function File: MAP = summer (N)
     Create color colormap.  This colormap varies from green to yellow.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
white


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 270
 -- Function File: MAP = white ()
 -- Function File: MAP = white (N)
     Create color colormap.  This colormap is completely white.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
winter


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 278
 -- Function File: MAP = winter ()
 -- Function File: MAP = winter (N)
     Create color colormap.  This colormap varies from blue to green.

     The argument N must be a scalar.  If unspecified, the length of the current colormap, or 64, is used.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Create color colormap.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
beep


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 306
 -- Function File: beep ()
     Produce a beep from the speaker (or visual bell).

     This function sends the alarm character "\a" to the terminal.  Depending on the user's configuration this may produce an audible beep, a visual bell, or nothing at all.

     See also: puts, fputs, printf, fprintf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Produce a beep from the speaker (or visual bell).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
csvread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 293
 -- Function File: X = csvread (FILENAME)
 -- Function File: X = csvread (FILENAME, DLM_OPTS)
     Read the comma-separated-value file FILENAME into the matrix X.

     This function is equivalent to

          X = dlmread (FILENAME, "," , ...)

     See also: csvwrite, dlmread, dlmwrite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Read the comma-separated-value file FILENAME into the matrix X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
csvwrite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 300
 -- Function File: csvwrite (FILENAME, X)
 -- Function File: csvwrite (FILENAME, X, DLM_OPTS)
     Write the matrix X to the file FILENAME in comma-separated-value format.

     This function is equivalent to

          dlmwrite (FILENAME, X, ",", ...)

     See also: csvread, dlmwrite, dlmread.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Write the matrix X to the file FILENAME in comma-separated-value format.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
dlmwrite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1600
 -- Function File: dlmwrite (FILE, M)
 -- Function File: dlmwrite (FILE, M, DELIM, R, C)
 -- Function File: dlmwrite (FILE, M, KEY, VAL ...)
 -- Function File: dlmwrite (FILE, M, "-append", ...)
 -- Function File: dlmwrite (FID, ...)
     Write the matrix M to the named file using delimiters.

     FILE should be a file name or writable file ID given by 'fopen'.

     The parameter DELIM specifies the delimiter to use to separate values on a row.

     The value of R specifies the number of delimiter-only lines to add to the start of the file.

     The value of C specifies the number of delimiters to prepend to each line of data.

     If the argument "-append" is given, append to the end of FILE.

     In addition, the following keyword value pairs may appear at the end of the argument list:

     "append"
          Either "on" or "off".  See "-append" above.

     "delimiter"
          See DELIM above.

     "newline"
          The character(s) to use to separate each row.  Three special cases exist for this option.  "unix" is changed into "\n", "pc" is changed into "\r\n", and "mac" is changed into "\r".  Any other value is used directly as the newline separator.

     "roffset"
          See R above.

     "coffset"
          See C above.

     "precision"
          The precision to use when writing the file.  It can either be a format string (as used by fprintf) or a number of significant digits.

          dlmwrite ("file.csv", reshape (1:16, 4, 4));

          dlmwrite ("file.tex", a, "delimiter", "&", "newline", "\n")

     See also: dlmread, csvread, csvwrite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Write the matrix M to the named file using delimiters.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
fileread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function File: STR = fileread (FILENAME)
     Read the contents of FILENAME and return it as a string.

     See also: fread, textread, sscanf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Read the contents of FILENAME and return it as a string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
importdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 958
 -- Function File: A = importdata (FNAME)
 -- Function File: A = importdata (FNAME, DELIMITER)
 -- Function File: A = importdata (FNAME, DELIMITER, HEADER_ROWS)
 -- Function File: [A, DELIMITER] = importdata (...)
 -- Function File: [A, DELIMITER, HEADER_ROWS] = importdata (...)
     Import data from the file FNAME.

     Input parameters:

        * FNAME The name of the file containing data.

        * DELIMITER The character separating columns of data.  Use '\t' for tab.  (Only valid for ASCII files)

        * HEADER_ROWS The number of header rows before the data begins.  (Only valid for ASCII files)

     Different file types are supported:

        * ASCII table

          Import ASCII table using the specified number of header rows and the specified delimiter.

        * Image file

        * MATLAB file

        * Spreadsheet files (depending on external software)

        * WAV file

     See also: textscan, dlmread, csvread, load.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Import data from the file FNAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
is_valid_file_id


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
 -- Function File: is_valid_file_id (FID)
     Return true if FID refers to an open file.

     See also: freport, fopen.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Return true if FID refers to an open file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
strread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5366
 -- Function File: [A, ...] = strread (STR)
 -- Function File: [A, ...] = strread (STR, FORMAT)
 -- Function File: [A, ...] = strread (STR, FORMAT, FORMAT_REPEAT)
 -- Function File: [A, ...] = strread (STR, FORMAT, PROP1, VALUE1, ...)
 -- Function File: [A, ...] = strread (STR, FORMAT, FORMAT_REPEAT, PROP1, VALUE1, ...)
     Read data from a string.

     The string STR is split into words that are repeatedly matched to the specifiers in FORMAT.  The first word is matched to the first specifier, the second to the second specifier and so forth.  If there are more words than specifiers, the process is repeated until all words have been processed.

     The string FORMAT describes how the words in STR should be parsed.  It may contain any combination of the following specifiers:

     '%s'
          The word is parsed as a string.

     '%f'
     '%n'
          The word is parsed as a number and converted to double.

     '%d'
     '%u'
          The word is parsed as a number and converted to int32.

     '%*', '%*f', '%*s'
          The word is skipped.

          For %s and %d, %f, %n, %u and the associated %*s ... specifiers an optional width can be specified as %Ns, etc.  where N is an integer > 1.  For %f, format specifiers like %N.Mf are allowed.

     'literals'
          In addition the format may contain literal character strings; these will be skipped during reading.

     Parsed word corresponding to the first specifier are returned in the first output argument and likewise for the rest of the specifiers.

     By default, FORMAT is "%f", meaning that numbers are read from STR.  This will do if STR contains only numeric fields.

     For example, the string

          STR = "\
          Bunny Bugs   5.5\n\
          Duck Daffy  -7.5e-5\n\
          Penguin Tux   6"

     can be read using

          [A, B, C] = strread (STR, "%s %s %f");

     Optional numeric argument FORMAT_REPEAT can be used for limiting the number of items read:

     -1
          (default) read all of the string until the end.

     N
          Read N times NARGOUT items.  0 (zero) is an acceptable value for FORMAT_REPEAT.

     The behavior of 'strread' can be changed via property-value pairs.  The following properties are recognized:

     "commentstyle"
          Parts of STR are considered comments and will be skipped.  VALUE is the comment style and can be any of the following.

             * "shell" Everything from '#' characters to the nearest end-of-line is skipped.

             * "c" Everything between '/*' and '*/' is skipped.

             * "c++" Everything from '//' characters to the nearest end-of-line is skipped.

             * "matlab" Everything from '%' characters to the nearest end-of-line is skipped.

             * user-supplied.  Two options: (1) One string, or 1x1 cell string: Skip everything to the right of it; (2) 2x1 cell string array: Everything between the left and right strings is skipped.

     "delimiter"
          Any character in VALUE will be used to split STR into words (default value = any whitespace).  Note that whitespace is implicitly added to the set of delimiter characters unless a "%s" format conversion specifier is supplied; see "whitespace" parameter below.  The set of delimiter characters cannot be empty; if needed Octave substitutes a space as delimiter.

     "emptyvalue"
          Value to return for empty numeric values in non-whitespace delimited data.  The default is NaN.  When the data type does not support NaN (int32 for example), then default is zero.

     "multipledelimsasone"
          Treat a series of consecutive delimiters, without whitespace in between, as a single delimiter.  Consecutive delimiter series need not be vertically "aligned".

     "treatasempty"
          Treat single occurrences (surrounded by delimiters or whitespace) of the string(s) in VALUE as missing values.

     "returnonerror"
          If VALUE true (1, default), ignore read errors and return normally.  If false (0), return an error.

     "whitespace"
          Any character in VALUE will be interpreted as whitespace and trimmed; the string defining whitespace must be enclosed in double quotes for proper processing of special characters like "\t".  In each data field, multiple consecutive whitespace characters are collapsed into one space and leading and trailing whitespace is removed.  The default value for whitespace is " \b\r\n\t" (note the space).  Whitespace is always added to the set of delimiter characters unless at least one "%s" format conversion specifier is supplied; in that case only whitespace explicitly specified in "delimiter" is retained as delimiter and removed from the set of whitespace characters.  If whitespace characters are to be kept as-is (in e.g., strings), specify an empty value (i.e., "") for "whitespace"; obviously, whitespace cannot be a delimiter then.

     When the number of words in STR doesn't match an exact multiple of the number of format conversion specifiers, strread's behavior depends on the last character of STR:

     last character = "\n"
          Data columns are padded with empty fields or Nan so that all columns have equal length

     last character is not "\n"
          Data columns are not padded; strread returns columns of unequal length

     See also: textscan, textread, load, dlmread, fscanf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Read data from a string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
textscan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2392
 -- Function File: C = textscan (FID, FORMAT)
 -- Function File: C = textscan (FID, FORMAT, N)
 -- Function File: C = textscan (FID, FORMAT, PARAM, VALUE, ...)
 -- Function File: C = textscan (FID, FORMAT, N, PARAM, VALUE, ...)
 -- Function File: C = textscan (STR, ...)
 -- Function File: [C, POSITION] = textscan (FID, ...)
     Read data from a text file or string.

     The string STR or file associated with FID is read from and parsed according to FORMAT.  The function behaves like 'strread' except it can also read from file instead of a string.  See the documentation of 'strread' for details.

     In addition to the options supported by 'strread', this function supports a few more:

        * "collectoutput": A value of 1 or true instructs textscan to concatenate consecutive columns of the same class in the output cell array.  A value of 0 or false (default) leaves output in distinct columns.

        * "endofline": Specify "\r", "\n" or "\r\n" (for CR, LF, or CRLF). If no value is given, it will be inferred from the file.  If set to "" (empty string) EOLs are ignored as delimiters and added to whitespace.

        * "headerlines": The first VALUE number of lines of FID are skipped.

        * "returnonerror": If set to numerical 1 or true (default), return normally when read errors have been encountered.  If set to 0 or false, return an error and no data.  As the string or file is read by columns rather than by rows, and because textscan is fairly forgiving as regards read errors, setting this option may have little or no actual effect.

     When reading from a character string, optional input argument N specifies the number of times FORMAT should be used (i.e., to limit the amount of data read).  When reading from file, N specifies the number of data lines to read; in this sense it differs slightly from the format repeat count in strread.

     The output C is a cell array whose second dimension is determined by the number of format specifiers.

     The second output, POSITION, provides the position, in characters, from the beginning of the file.

     If the format string is empty (not: omitted) and the file contains only numeric data (excluding headerlines), textscan will return data in a number of columns matching the number of numeric fields on the first data line of the file.

     See also: dlmread, fscanf, load, strread, textread.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Read data from a text file or string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
textread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2728
 -- Function File: [A, ...] = textread (FILENAME)
 -- Function File: [A, ...] = textread (FILENAME, FORMAT)
 -- Function File: [A, ...] = textread (FILENAME, FORMAT, N)
 -- Function File: [A, ...] = textread (FILENAME, FORMAT, PROP1, VALUE1, ...)
 -- Function File: [A, ...] = textread (FILENAME, FORMAT, N, PROP1, VALUE1, ...)
     Read data from a text file.

     The file FILENAME is read and parsed according to FORMAT.  The function behaves like 'strread' except it works by parsing a file instead of a string.  See the documentation of 'strread' for details.

     In addition to the options supported by 'strread', this function supports two more:

        * "headerlines": The first VALUE number of lines of FILENAME are skipped.

        * "endofline": Specify a single character or "\r\n".  If no value is given, it will be inferred from the file.  If set to "" (empty string) EOLs are ignored as delimiters.

     The optional input N (format repeat count) specifies the number of times the format string is to be used or the number of lines to be read, whichever happens first while reading.  The former is equivalent to requesting that the data output vectors should be of length N.  Note that when reading files with format strings referring to multiple lines, N should rather be the number of lines to be read than the number of format string uses.

     If the format string is empty (not just omitted) and the file contains only numeric data (excluding headerlines), textread will return a rectangular matrix with the number of columns matching the number of numeric fields on the first data line of the file.  Empty fields are returned as zero values.

     Examples:

            Assume a data file like:
            1 a 2 b
            3 c 4 d
            5 e

            [a, b] = textread (f, "%f %s")
            returns two columns of data, one with doubles, the other a
            cellstr array:
            a = [1; 2; 3; 4; 5]
            b = {"a"; "b"; "c"; "d"; "e"}

            [a, b] = textread (f, "%f %s", 3)
            (read data into two culumns, try to use the format string
            three times)
            returns
            a = [1; 2; 3]
            b = {"a"; "b"; "c"}


            With a data file like:
            1
            a
            2
            b

            [a, b] = textread (f, "%f %s", 2)
            returns a = 1 and b = {"a"}; i.e., the format string is used
            only once because the format string refers to 2 lines of the
            data file. To obtain 2x1 data output columns, specify N = 4
            (number of data lines containing all requested data) rather
            than 2.

     See also: strread, load, dlmread, fscanf, textscan.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Read data from a text file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
java_get


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 486
 -- Function File: VAL = java_get (OBJ, NAME)
     Get the value of the field NAME of the Java object OBJ.

     For static fields, OBJ can be a string representing the fully qualified name of the corresponding class.

     When OBJ is a regular Java object, structure-like indexing can be used as a shortcut syntax.  For instance, the following two statements are equivalent

            java_get (x, "field1")
            x.field1

     See also: java_set, javaMethod, javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Get the value of the field NAME of the Java object OBJ.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
java_set


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- Function File: OBJ = java_set (OBJ, NAME, VAL)
     Set the value of the field NAME of the Java object OBJ to VAL.

     For static fields, OBJ can be a string representing the fully qualified named of the corresponding Java class.

     When OBJ is a regular Java object, structure-like indexing can be used as a shortcut syntax.  For instance, the following two statements are equivalent

            java_set (x, "field1", val)
            x.field1 = val

     See also: java_get, javaMethod, javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Set the value of the field NAME of the Java object OBJ to VAL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
javaArray


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 699
 -- Function File: JARY = javaArray (CLASSNAME, SZ)
 -- Function File: JARY = javaArray (CLASSNAME, M, N, ...)

     Create a Java array of size SZ with elements of class CLASSNAME.

     CLASSNAME may be a Java object representing a class or a string containing the fully qualified class name.  The size of the object may also be specified with individual integer arguments M, N, etc.

     The generated array is uninitialized.  All elements are set to null if CLASSNAME is a reference type, or to a default value (usually 0) if CLASSNAME is a primitive type.

     Sample code:

          jary = javaArray ("java.lang.String", 2, 2);
          jary(1,1) = "Hello";

     See also: javaObject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Create a Java array of size SZ with elements of class CLASSNAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
javaaddpath


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 393
 -- Function File: javaaddpath (CLSPATH)
 -- Function File: javaaddpath (CLSPATH1, ...)
     Add CLSPATH to the dynamic class path of the Java virtual machine.

     CLSPATH may either be a directory where '.class' files are found, or a '.jar' file containing Java classes.  Multiple paths may be added at once by specifying additional arguments.

     See also: javarmpath, javaclasspath.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Add CLSPATH to the dynamic class path of the Java virtual machine.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
javachk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1517
 -- Function File: javachk (FEATURE)
 -- Function File: javachk (FEATURE, COMPONENT)
 -- Function File: MSG = javachk (...)
     Check for the presence of the Java FEATURE in the current session and print or return an error message if it is not.

     Possible features are:

     "awt"
          Abstract Window Toolkit for GUIs.

     "desktop"
          Interactive desktop is running.

     "jvm"
          Java Virtual Machine.

     "swing"
          Swing components for lightweight GUIs.

     If FEATURE is supported and

        * no output argument is requested:

          Return an empty string

        * an output argument is requested:

          Return a struct with fields "feature" and "identifier" both empty

     If FEATURE is not supported and

        * no output argument is requested:

          Emit an error message

        * an output argument is requested:

          Return a struct with field "feature" set to FEATURE and field "identifier" set to COMPONENT

     The optional input COMPONENT will be used in place of FEATURE in any error messages for greater specificity.

     'javachk' determines if specific Java features are available in an Octave session.  This function is provided for scripts which may alter their behavior based on the availability of Java.  The feature "desktop" is never available as Octave has no Java-based desktop.  Other features may be available if Octave was compiled with the Java Interface and Java is installed.

     See also: usejava, error.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
Check for the presence of the Java FEATURE in the current session and print or return an error message if it is not.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
javaclasspath


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 969
 -- Function File: javaclasspath ()
 -- Function File: DPATH = javaclasspath ()
 -- Function File: [DPATH, SPATH] = javaclasspath ()
 -- Function File: CLSPATH = javaclasspath (WHAT)
     Return the class path of the Java virtual machine in the form of a cell array of strings.

     If called with no inputs:

        * If no output is requested, the dynamic and static classpaths are printed to the standard output.

        * If one output value DPATH is requested, the result is the dynamic classpath.

        * If two output valuesDPATH and SPATH are requested, the first variable will contain the dynamic classpath and the second will contain the static classpath.

     If called with a single input parameter WHAT:

     "-dynamic"
          Return the dynamic classpath.

     "-static"
          Return the static classpath.

     "-all"
          Return both the static and dynamic classpath in a single cellstr.

     See also: javaaddpath, javarmpath.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Return the class path of the Java virtual machine in the form of a cell array of strings.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
javamem


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1636
 -- Function File: javamem ()
 -- Function File: JMEM = javamem ()
     Show the current memory usage of the Java virtual machine (JVM) and run the garbage collector.

     When no return argument is given the info is printed to the screen.  Otherwise, the output cell array JMEM contains Maximum, Total, and Free memory (in bytes).

     All Java-based routines are run in the JVM's shared memory pool, a dedicated and separate part of memory claimed by the JVM from your computer's total memory (which comprises physical RAM and virtual memory / swap space on hard disk).

     The maximum allowable memory usage can be configured using the file 'java.opts'.  The directory where this file resides is determined by the environment variable 'OCTAVE_JAVA_DIR'.  If unset, the directory where 'javaaddpath.m' resides is used instead (typically 'OCTAVE_HOME/share/octave/OCTAVE_VERSION/m/java/').

     'java.opts' is a plain text file with one option per line.  The default initial memory size and default maximum memory size (which are both system dependent) can be overridden like so:

     -Xms64m

     -Xmx512m

     (in megabytes in this example).  You can adapt these values to your own requirements if your system has limited available physical memory or if you get Java memory errors.

     "Total memory" is what the operating system has currently assigned to the JVM and depends on actual and active memory usage.  "Free memory" is self-explanatory.  During operation of Java-based Octave functions the amount of Total and Free memory will vary, due to Java's own cleaning up and your operating system's memory management.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Show the current memory usage of the Java virtual machine (JVM) and run the garbage collector.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
javarmpath


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 399
 -- Function File: javarmpath (CLSPATH)
 -- Function File: javarmpath (CLSPATH1, ...)
     Remove CLSPATH from the dynamic class path of the Java virtual machine.

     CLSPATH may either be a directory where '.class' files are found, or a '.jar' file containing Java classes.  Multiple paths may be removed at once by specifying additional arguments.

     See also: javaaddpath, javaclasspath.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Remove CLSPATH from the dynamic class path of the Java virtual machine.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
usejava


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 754
 -- Function File: usejava (FEATURE)
     Return true if the Java element FEATURE is available.

     Possible features are:

     "awt"
          Abstract Window Toolkit for GUIs.

     "desktop"
          Interactive desktop is running.

     "jvm"
          Java Virtual Machine.

     "swing"
          Swing components for lightweight GUIs.

     'usejava' determines if specific Java features are available in an Octave session.  This function is provided for scripts which may alter their behavior based on the availability of Java.  The feature "desktop" always returns 'false' as Octave has no Java-based desktop.  Other features may be available if Octave was compiled with the Java Interface and Java is installed.

     See also: javachk.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Return true if the Java element FEATURE is available.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
bandwidth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 471
 -- Function File: BW = bandwidth (A, TYPE)
 -- Function File: [LOWER, UPPER] = bandwidth (A)
     Compute the bandwidth of A.

     The TYPE argument is the string "lower" for the lower bandwidth and "upper" for the upper bandwidth.  If no TYPE is specified return both the lower and upper bandwidth of A.

     The lower/upper bandwidth of a matrix is the number of subdiagonals/superdiagonals with nonzero entries.

     See also: isbanded, isdiag, istril, istriu.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Compute the bandwidth of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
commutation_matrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 -- Function File: commutation_matrix (M, N)
     Return the commutation matrix K(m,n) which is the unique M*N by M*N matrix such that K(m,n) * vec(A) = vec(A') for all m by n matrices A.

     If only one argument M is given, K(m,m) is returned.

     See Magnus and Neudecker (1988), 'Matrix Differential Calculus with Applications in Statistics and Econometrics.'
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
Return the commutation matrix K(m,n) which is the unique M*N by M*N matrix such that K(m,n) * vec(A) = vec(A') for all m by n matrices A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cond


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 894
 -- Function File: cond (A)
 -- Function File: cond (A, P)
     Compute the P-norm condition number of a matrix.

     'cond (A)' is defined as 'norm (A, P) * norm (inv (A), P)'.

     By default, 'P = 2' is used which implies a (relatively slow) singular value decomposition.  Other possible selections are 'P = 1, Inf, "fro"' which are generally faster.  See 'norm' for a full discussion of possible P values.

     The condition number of a matrix quantifies the sensitivity of the matrix inversion operation when small changes are made to matrix elements.  Ideally the condition number will be close to 1.  When the number is large this indicates small changes (such as underflow or round-off error) will produce large changes in the resulting output.  In such cases the solution results from numerical computing are not likely to be accurate.

     See also: condest, rcond, norm, svd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Compute the P-norm condition number of a matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
condest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1601
 -- Function File: condest (A)
 -- Function File: condest (A, T)
 -- Function File: [EST, V] = condest (...)
 -- Function File: [EST, V] = condest (A, SOLVE, SOLVE_T, T)
 -- Function File: [EST, V] = condest (APPLY, APPLY_T, SOLVE, SOLVE_T, N, T)

     Estimate the 1-norm condition number of a matrix A using T test vectors using a randomized 1-norm estimator.

     If T exceeds 5, then only 5 test vectors are used.

     If the matrix is not explicit, e.g., when estimating the condition number of A given an LU factorization, 'condest' uses the following functions:

     APPLY
          'A*x' for a matrix 'x' of size N by T.

     APPLY_T
          'A'*x' for a matrix 'x' of size N by T.

     SOLVE
          'A \ b' for a matrix 'b' of size N by T.

     SOLVE_T
          'A' \ b' for a matrix 'b' of size N by T.

     The implicit version requires an explicit dimension N.

     'condest' uses a randomized algorithm to approximate the 1-norms.

     'condest' returns the 1-norm condition estimate EST and a vector V satisfying 'norm (A*v, 1) == norm (A, 1) * norm (V, 1) / EST'.  When EST is large, V is an approximate null vector.

     References:

        * N.J. Higham and F. Tisseur, 'A Block Algorithm for Matrix 1-Norm Estimation, with an Application to 1-Norm Pseudospectra'.  SIMAX vol 21, no 4, pp 1185-1201.  <http://dx.doi.org/10.1137/S0895479899356080>

        * N.J. Higham and F. Tisseur, 'A Block Algorithm for Matrix 1-Norm Estimation, with an Application to 1-Norm Pseudospectra'.  <http://citeseer.ist.psu.edu/223007.html>

     See also: cond, norm, onenormest.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
Estimate the 1-norm condition number of a matrix A using T test vectors using a randomized 1-norm estimator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
cross


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 486
 -- Function File: cross (X, Y)
 -- Function File: cross (X, Y, DIM)
     Compute the vector cross product of two 3-dimensional vectors X and Y.

     If X and Y are matrices, the cross product is applied along the first dimension with three elements.

     The optional argument DIM forces the cross product to be calculated along the specified dimension.

     Example Code:

          cross ([1,1,0], [0,1,1])
               => [ 1; -1; 1 ]

     See also: dot, curl, divergence.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Compute the vector cross product of two 3-dimensional vectors X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
duplication_matrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 316
 -- Function File: duplication_matrix (N)
     Return the duplication matrix Dn which is the unique n^2 by n*(n+1)/2 matrix such that Dn vech (A) = vec (A) for all symmetric n by n matrices A.

     See Magnus and Neudecker (1988), 'Matrix Differential Calculus with Applications in Statistics and Econometrics.'
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
Return the duplication matrix Dn which is the unique n^2 by n*(n+1)/2 matrix such that Dn vech (A) = vec (A) for all symmetric n by n matrices A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
expm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 911
 -- Function File: expm (A)
     Return the exponential of a matrix.

     The matrix exponential is defined as the infinite Taylor series

          expm (A) = I + A + A^2/2! + A^3/3! + ...

     However, the Taylor series is _not_ the way to compute the matrix exponential; see Moler and Van Loan, 'Nineteen Dubious Ways to Compute the Exponential of a Matrix', SIAM Review, 1978.  This routine uses Ward's diagonal Pade' approximation method with three step preconditioning (SIAM Journal on Numerical Analysis, 1977).  Diagonal Pade' approximations are rational polynomials of matrices

               -1
          D (A)   N (A)

     whose Taylor series matches the first '2q+1' terms of the Taylor series above; direct evaluation of the Taylor series (with the same preconditioning steps) may be desirable in lieu of the Pade' approximation when 'Dq(A)' is ill-conditioned.

     See also: logm, sqrtm.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Return the exponential of a matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
housh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 602
 -- Function File: [HOUSV, BETA, ZER] = housh (X, J, Z)
     Compute Householder reflection vector HOUSV to reflect X to be the j-th column of identity, i.e.,

          (I - beta*housv*housv')x =  norm (x)*e(j) if x(j) < 0,
          (I - beta*housv*housv')x = -norm (x)*e(j) if x(j) >= 0

     Inputs

     X
          vector

     J
          index into vector

     Z
          threshold for zero (usually should be the number 0)

     Outputs (see Golub and Van Loan):

     BETA
          If beta = 0, then no reflection need be applied (zer set to 0)

     HOUSV
          householder vector
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Compute Householder reflection vector HOUSV to reflect X to be the j-th column of identity, i.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
isbanded


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 302
 -- Function File: isbanded (A, LOWER, UPPER)
     Return true if A is a matrix with entries confined between LOWER diagonals below the main diagonal and UPPER diagonals above the main diagonal.

     LOWER and UPPER must be non-negative integers.

     See also: isdiag, istril, istriu, bandwidth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
Return true if A is a matrix with entries confined between LOWER diagonals below the main diagonal and UPPER diagonals above the main diagonal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
isdefinite


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 349
 -- Function File: isdefinite (A)
 -- Function File: isdefinite (A, TOL)
     Return 1 if A is symmetric positive definite within the tolerance specified by TOL or 0 if A is symmetric positive semidefinite.  Otherwise, return -1.

     If TOL is omitted, use a tolerance of '100 * eps * norm (A, "fro")'

     See also: issymmetric, ishermitian.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
Return 1 if A is symmetric positive definite within the tolerance specified by TOL or 0 if A is symmetric positive semidefinite.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
isdiag


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 136
 -- Function File: isdiag (A)
     Return true if A is a diagonal matrix.

     See also: isbanded, istril, istriu, diag, bandwidth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Return true if A is a diagonal matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
ishermitian


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 335
 -- Function File: ishermitian (A)
 -- Function File: ishermitian (A, TOL)
     Return true if A is Hermitian within the tolerance specified by TOL.

     The default tolerance is zero (uses faster code).

     Matrix A is considered symmetric if 'norm (A - A', Inf) / norm (A, Inf) < TOL'.

     See also: issymmetric, isdefinite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Return true if A is Hermitian within the tolerance specified by TOL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
issymmetric


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 345
 -- Function File: issymmetric (A)
 -- Function File: issymmetric (A, TOL)
     Return true if A is a symmetric matrix within the tolerance specified by TOL.

     The default tolerance is zero (uses faster code).

     Matrix A is considered symmetric if 'norm (A - A.', Inf) / norm (A, Inf) < TOL'.

     See also: ishermitian, isdefinite.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Return true if A is a symmetric matrix within the tolerance specified by TOL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
istril


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 233
 -- Function File: istril (A)
     Return true if A is a lower triangular matrix.

     A lower triangular matrix has nonzero entries only on the main diagonal and below.

     See also: istriu, isbanded, isdiag, tril, bandwidth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Return true if A is a lower triangular matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
istriu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 235
 -- Function File: istriu (A)
     Return true if A is an upper triangular matrix.

     An upper triangular matrix has nonzero entries only on the main diagonal and above.

     See also: isdiag, isbanded, istril, triu, bandwidth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Return true if A is an upper triangular matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
krylov


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1184
 -- Function File: [U, H, NU] = krylov (A, V, K, EPS1, PFLG)
     Construct an orthogonal basis U of block Krylov subspace

          [v a*v a^2*v ... a^(k+1)*v]

     using Householder reflections to guard against loss of orthogonality.

     If V is a vector, then H contains the Hessenberg matrix such that a*u == u*h+rk*ek', in which 'rk = a*u(:,k)-u*h(:,k)', and ek' is the vector '[0, 0, ..., 1]' of length 'k'.  Otherwise, H is meaningless.

     If V is a vector and K is greater than 'length (A) - 1', then H contains the Hessenberg matrix such that 'a*u == u*h'.

     The value of NU is the dimension of the span of the Krylov subspace (based on EPS1).

     If B is a vector and K is greater than M-1, then H contains the Hessenberg decomposition of A.

     The optional parameter EPS1 is the threshold for zero.  The default value is 1e-12.

     If the optional parameter PFLG is nonzero, row pivoting is used to improve numerical behavior.  The default value is 0.

     Reference: A. Hodel, P. Misra, 'Partial Pivoting in the Computation of Krylov Subspaces of Large Sparse Systems', Proceedings of the 42nd IEEE Conference on Decision and Control, December 2003.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Construct an orthogonal basis U of block Krylov subspace 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
linsolve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1616
 -- Function File: X = linsolve (A, B)
 -- Function File: X = linsolve (A, B, OPTS)
 -- Function File: [X, R] = linsolve (...)
     Solve the linear system 'A*x = b'.

     With no options, this function is equivalent to the left division operator ('x = A \ b') or the matrix-left-divide function ('x = mldivide (A, b)').

     Octave ordinarily examines the properties of the matrix A and chooses a solver that best matches the matrix.  By passing a structure OPTS to 'linsolve' you can inform Octave directly about the matrix A.  In this case Octave will skip the matrix examination and proceed directly to solving the linear system.

     *Warning:* If the matrix A does not have the properties listed in the OPTS structure then the result will not be accurate AND no warning will be given.  When in doubt, let Octave examine the matrix and choose the appropriate solver as this step takes little time and the result is cached so that it is only done once per linear system.

     Possible OPTS fields (set value to true/false):

     LT
          A is lower triangular

     UT
          A is upper triangular

     UHESS
          A is upper Hessenberg (currently makes no difference)

     SYM
          A is symmetric or complex Hermitian (currently makes no difference)

     POSDEF
          A is positive definite

     RECT
          A is general rectangular (currently makes no difference)

     TRANSA
          Solve 'A'*x = b' by 'transpose (A) \ b'

     The optional second output R is the inverse condition number of A (zero if matrix is singular).

     See also: mldivide, matrix_type, rcond.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Solve the linear system 'A*x = b'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
logm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 512
 -- Function File: S = logm (A)
 -- Function File: S = logm (A, OPT_ITERS)
 -- Function File: [S, ITERS] = logm (...)
     Compute the matrix logarithm of the square matrix A.

     The implementation utilizes a Pade' approximant and the identity

          logm (A) = 2^k * logm (A^(1 / 2^k))

     The optional input OPT_ITERS is the maximum number of square roots to compute and defaults to 100.

     The optional output ITERS is the number of square roots actually computed.

     See also: expm, sqrtm.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute the matrix logarithm of the square matrix A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 529
 -- Function File: N = normest (A)
 -- Function File: N = normest (A, TOL)
 -- Function File: [N, C] = normest (...)
     Estimate the 2-norm of the matrix A using a power series analysis.

     This is typically used for large matrices, where the cost of calculating 'norm (A)' is prohibitive and an approximation to the 2-norm is acceptable.

     TOL is the tolerance to which the 2-norm is calculated.  By default TOL is 1e-6.

     The optional output C returns the number of iterations needed for 'normest' to converge.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Estimate the 2-norm of the matrix A using a power series analysis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
null


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 349
 -- Function File: null (A)
 -- Function File: null (A, TOL)
     Return an orthonormal basis of the null space of A.

     The dimension of the null space is taken as the number of singular values of A not greater than TOL.  If the argument TOL is missing, it is computed as

          max (size (A)) * max (svd (A)) * eps

     See also: orth.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Return an orthonormal basis of the null space of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
onenormest


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1249
 -- Function File: [EST, V, W, ITER] = onenormest (A, T)
 -- Function File: [EST, V, W, ITER] = onenormest (APPLY, APPLY_T, N, T)

     Apply Higham and Tisseur's randomized block 1-norm estimator to matrix A using T test vectors.

     If T exceeds 5, then only 5 test vectors are used.

     If the matrix is not explicit, e.g., when estimating the norm of 'inv (A)' given an LU factorization, 'onenormest' applies A and its conjugate transpose through a pair of functions APPLY and APPLY_T, respectively, to a dense matrix of size N by T.  The implicit version requires an explicit dimension N.

     Returns the norm estimate EST, two vectors V and W related by norm '(W, 1) = EST * norm (V, 1)', and the number of iterations ITER.  The number of iterations is limited to 10 and is at least 2.

     References:

        * N.J. Higham and F. Tisseur, 'A Block Algorithm for Matrix 1-Norm Estimation, with an Application to 1-Norm Pseudospectra'.  SIMAX vol 21, no 4, pp 1185-1201.  <http://dx.doi.org/10.1137/S0895479899356080>

        * N.J. Higham and F. Tisseur, 'A Block Algorithm for Matrix 1-Norm Estimation, with an Application to 1-Norm Pseudospectra'.  <http://citeseer.ist.psu.edu/223007.html>

     See also: condest, norm, cond.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Apply Higham and Tisseur's randomized block 1-norm estimator to matrix A using T test vectors.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
orth


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 347
 -- Function File: orth (A)
 -- Function File: orth (A, TOL)
     Return an orthonormal basis of the range space of A.

     The dimension of the range space is taken as the number of singular values of A greater than TOL.  If the argument TOL is missing, it is computed as

          max (size (A)) * max (svd (A)) * eps

     See also: null.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return an orthonormal basis of the range space of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
planerot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 184
 -- Function File: [G, Y] = planerot (X)
     Given a two-element column vector, return the 2 by 2 orthogonal matrix G such that 'Y = G * X' and 'Y(2) = 0'.

     See also: givens.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 110
Given a two-element column vector, return the 2 by 2 orthogonal matrix G such that 'Y = G * X' and 'Y(2) = 0'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qzhess


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 777
 -- Function File: [AA, BB, Q, Z] = qzhess (A, B)
     Compute the Hessenberg-triangular decomposition of the matrix pencil '(A, B)', returning 'AA = Q * A * Z', 'BB = Q * B * Z', with Q and Z orthogonal.

     For example:

          [aa, bb, q, z] = qzhess ([1, 2; 3, 4], [5, 6; 7, 8])
               => aa = [ -3.02244, -4.41741;  0.92998,  0.69749 ]
               => bb = [ -8.60233, -9.99730;  0.00000, -0.23250 ]
               =>  q = [ -0.58124, -0.81373; -0.81373,  0.58124 ]
               =>  z = [ 1, 0; 0, 1 ]

     The Hessenberg-triangular decomposition is the first step in Moler and Stewart's QZ decomposition algorithm.

     Algorithm taken from Golub and Van Loan, 'Matrix Computations, 2nd edition'.

     See also: lu, chol, hess, qr, qz, schur, svd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
Compute the Hessenberg-triangular decomposition of the matrix pencil '(A, B)', returning 'AA = Q * A * Z', 'BB = Q * B * Z', with Q and Z orthogonal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
rank


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 942
 -- Function File: rank (A)
 -- Function File: rank (A, TOL)
     Compute the rank of matrix A, using the singular value decomposition.

     The rank is taken to be the number of singular values of A that are greater than the specified tolerance TOL.  If the second argument is omitted, it is taken to be

          tol = max (size (A)) * sigma(1) * eps;

     where 'eps' is machine precision and 'sigma(1)' is the largest singular value of A.

     The rank of a matrix is the number of linearly independent rows or columns and determines how many particular solutions exist to a system of equations.  Use 'null' for finding the remaining homogenous solutions.

     Example:

          x = [1 2 3
               4 5 6
               7 8 9];
          rank (x)
            => 2

     The number of linearly independent rows is only 2 because the final row is a linear combination of -1*row1 + 2*row2.

     See also: null, sprank, svd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Compute the rank of matrix A, using the singular value decomposition.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
rref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 357
 -- Function File: rref (A)
 -- Function File: rref (A, TOL)
 -- Function File: [R, K] = rref (...)
     Return the reduced row echelon form of A.

     TOL defaults to 'eps * max (size (A)) * norm (A, inf)'.

     The optional return argument K contains the vector of "bound variables", which are those columns on which elimination has been performed.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Return the reduced row echelon form of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
subspace


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 155
 -- Function File: ANGLE = subspace (A, B)
     Determine the largest principal angle between two subspaces spanned by the columns of matrices A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Determine the largest principal angle between two subspaces spanned by the columns of matrices A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
trace


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 194
 -- Function File: trace (A)
     Compute the trace of A, the sum of the elements along the main diagonal.

     The implementation is straightforward: 'sum (diag (A))'.

     See also: eig.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Compute the trace of A, the sum of the elements along the main diagonal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
vech


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 347
 -- Function File: vech (X)
     Return the vector obtained by eliminating all superdiagonal elements of the square matrix X and stacking the result one column above the other.

     This has uses in matrix calculus where the underlying matrix is symmetric and it would be pointless to keep values above the main diagonal.

     See also: vec.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
Return the vector obtained by eliminating all superdiagonal elements of the square matrix X and stacking the result one column above the other.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
ans


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 234
 -- Automatic Variable: ans
     The most recently computed result that was not explicitly assigned to a variable.

     For example, after the expression

          3^2 + 4^2

     is evaluated, the value returned by 'ans' is 25.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 81
The most recently computed result that was not explicitly assigned to a variable.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
bug_report


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 105
 -- Function File: bug_report ()
     Display information about how to submit bug reports for Octave.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Display information about how to submit bug reports for Octave.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
bunzip2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 377
 -- Function File: FILELIST = bunzip2 (BZFILE)
 -- Function File: FILELIST = bunzip2 (BZFILE, DIR)
     Unpack the bzip2 archive BZFILE.

     If DIR is specified the files are unpacked in this directory rather than the one where BZFILE is located.

     The optional output FILELIST is a list of the uncompressed files.

     See also: bzip2, unpack, gunzip, unzip, untar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Unpack the bzip2 archive BZFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
bzip2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 777
 -- Function File: FILELIST = bzip2 (FILES)
 -- Function File: FILELIST = bzip2 (FILES, DIR)
     Compress the list of files specified in FILES.

     FILES is a character array or cell array of strings.  Shell wildcards in the filename such as '*' or '?' are accepted and expanded.  Each file is compressed separately and a new file with a '".bz2"' extension is created.  The original files are not modified, but existing compressed files will be silently overwritten.

     If DIR is defined the compressed files are placed in this directory, rather than the original directory where the uncompressed file resides.  If DIR does not exist it is created.

     The optional output FILELIST is a list of the compressed files.

     See also: bunzip2, unpack, gzip, zip, tar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Compress the list of files specified in FILES.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
cast


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 667
 -- Function File: cast (VAL, "TYPE")
     Convert VAL to data type TYPE.

     VAL must be one of the numeric classes:

          "double"
          "single"
          "logical"
          "char"
          "int8"
          "int16"
          "int32"
          "int64"
          "uint8"
          "uint16"
          "uint32"
          "uint64"

     The value VAL may be modified to fit within the range of the new type.

     Examples:

          cast (-5, "uint8")
             => 0
          cast (300, "int8")
             => 127

     See also: typecast, int8, uint8, int16, uint16, int32, uint32, int64, uint64, double, single, logical, char, class, typeinfo.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Convert VAL to data type TYPE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
citation


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 664
 -- Command: citation
 -- Command: citation PACKAGE
     Display instructions for citing GNU Octave or its packages in publications.

     When called without an argument, display information on how to cite the core GNU Octave system.

     When given a package name PACKAGE, display information on citing the specific named package.  Note that some packages may not yet have instructions on how to cite them.

     The GNU Octave developers and its active community of package authors have invested a lot of time and effort in creating GNU Octave as it is today.  Please give credit where credit is due and cite GNU Octave and its packages when you use them.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Display instructions for citing GNU Octave or its packages in publications.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
comma


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 105
 -- Operator: ,
     Array index, function argument, or command separator.

     See also: semicolon.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Array index, function argument, or command separator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
compare_versions


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1138
 -- Function File: compare_versions (V1, V2, OPERATOR)
     Compare two version strings using the given OPERATOR.

     This function assumes that versions V1 and V2 are arbitrarily long strings made of numeric and period characters possibly followed by an arbitrary string (e.g., "1.2.3", "0.3", "0.1.2+", or "1.2.3.4-test1").

     The version is first split into numeric and character portions and then the parts are padded to be the same length (i.e., "1.1" would be padded to be "1.1.0" when being compared with "1.1.1", and separately, the character parts of the strings are padded with nulls).

     The operator can be any logical operator from the set

        * "==" equal

        * "<" less than

        * "<=" less than or equal to

        * ">" greater than

        * ">=" greater than or equal to

        * "!=" not equal

        * "~=" not equal

     Note that version "1.1-test2" will compare as greater than "1.1-test10".  Also, since the numeric part is compared first, "a" compares less than "1a" because the second string starts with a numeric part even though 'double ("a")' is greater than 'double ("1").'
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compare two version strings using the given OPERATOR.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
computer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1084
 -- Function File: computer ()
 -- Function File: C = computer ()
 -- Function File: [C, MAXSIZE] = computer ()
 -- Function File: [C, MAXSIZE, ENDIAN] = computer ()
 -- Function File: ARCH = computer ("arch")
     Print or return a string of the form CPU-VENDOR-OS that identifies the type of computer that Octave is running on.

     If invoked with an output argument, the value is returned instead of printed.  For example:

          computer ()
             -| i586-pc-linux-gnu

          mycomp = computer ()
             => mycomp = "i586-pc-linux-gnu"

     If two output arguments are requested, also return the maximum number of elements for an array.  This will depend on whether Octave has been compiled with 32-bit or 64-bit index vectors.

     If three output arguments are requested, also return the byte order of the current system as a character ("B" for big-endian or "L" for little-endian).

     If the argument "arch" is specified, return a string indicating the architecture of the computer on which Octave is running.

     See also: isunix, ismac, ispc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 114
Print or return a string of the form CPU-VENDOR-OS that identifies the type of computer that Octave is running on.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
copyfile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 741
 -- Function File: [STATUS, MSG, MSGID] = copyfile (F1, F2)
 -- Function File: [STATUS, MSG, MSGID] = copyfile (F1, F2, 'f')
     Copy the source files or directories F1 to the destination F2.

     The name F1 may contain globbing patterns.  If F1 expands to multiple file names, F2 must be a directory.

     When the force flag 'f' is given any existing files will be overwritten without prompting.

     If successful, STATUS is 1, and MSG, MSGID are empty character strings ("").  Otherwise, STATUS is 0, MSG contains a system-dependent error message, and MSGID contains a unique message identifier.  Note that the status code is exactly opposite that of the 'system' command.

     See also: movefile, rename, unlink, delete, glob.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Copy the source files or directories F1 to the destination F2.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
debug


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2099
 -- Function File: debug ()
     Summary of debugging commands.

     For more information on each command and available options use 'help CMD'.

     The debugging commands available in Octave are

     'dbstop'
          Add a breakpoint.

     'dbclear'
          Remove a breakpoint.

     'dbstatus'
          List all breakpoints.

     'dbwhere'
          Report the current file and line number where execution is stopped.

     'dbtype'
          Display the code of the function being debugged, enumerating the line numbers.

     'dblist'
          List 10 lines of code centered around the line number where execution is stopped.

     'dbstep'
     'dbnext'
          Execute (step) one or more lines, follow execution into (step into) a function call, or execute until the end of a function (step out), and re-enter debug mode.

     'dbcont'
          Continue normal code execution from the debug prompt.

     'dbquit'
          Quit debugging mode immediately and return to the main prompt.

     'dbstack'
          Print a backtrace of the execution stack.

     'dbup'
          Move up the execution stack.

     'dbdown'
          Move down the execution stack.

     'keyboard'
          Force entry into debug mode from an m-file.

     'debug_on_error'
          Configure whether Octave enters debug mode when it encounters an error.

     'debug_on_warning'
          Configure whether Octave enters debug mode when it encounters a warning.

     'debug_on_interrupt'
          Configure whether Octave enters debug mode when it encounters an interrupt.

     'isdebugmode'
          Return true if in debug mode.

     When Octave encounters a breakpoint, or other reason to enter debug mode, the prompt changes to "debug>".  The workspace of the function where the breakpoint was encountered becomes available and any Octave command that is valid in that workspace context may be executed.

     See also: dbstop, dbclear, dbstatus, dbwhere, dbtype, dbcont, dbquit, dbstack, dbup, dbdown, keyboard, debug_on_error, debug_on_warning, debug_on_interrupt, isdebugmode.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Summary of debugging commands.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
delete


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 537
 -- Function File: delete (FILE)
 -- Function File: delete (FILE1, FILE2, ...)
 -- Function File: delete (HANDLE)
     Delete the named file or graphics handle.

     FILE may contain globbing patterns such as '*'.  Multiple files to be deleted may be specified in the same function call.

     HANDLE may be a scalar or vector of graphic handles to delete.

     Programming Note: Deleting graphics objects is the proper way to remove features from a plot without clearing the entire figure.

     See also: clf, cla, unlink, rmdir.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Delete the named file or graphics handle.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
desktop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
 -- Function File: USED = desktop ("-inuse")
     Return true if the desktop (GUI) is currently in use.

     See also: isguirunning.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Return true if the desktop (GUI) is currently in use.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
dir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1351
 -- Function File: dir
 -- Function File: dir (DIRECTORY)
 -- Function File: [LIST] = dir (DIRECTORY)
     Display file listing for directory DIRECTORY.

     If DIRECTORY is not specified then list the present working directory.

     If a return value is requested, return a structure array with the fields

     name
          File or directory name.

     date
          Timestamp of file modification (string value).

     bytes
          File size in bytes.

     isdir
          True if name is a directory.

     datenum
          Timestamp of file modification as serial date number (double).

     statinfo
          Information structure returned from 'stat'.

     If DIRECTORY is a filename, rather than a directory, then return information about the named file.  DIRECTORY may also be a list rather than a single directory or file.

     DIRECTORY is subject to shell expansion if it contains any wildcard characters '*', '?', '[]'.  To find a literal example of a wildcard character the wildcard must be escaped using the backslash operator '\'.

     Note that for symbolic links, 'dir' returns information about the file that the symbolic link points to rather than the link itself.  However, if the link points to a nonexistent file, 'dir' returns information about the link.

     See also: ls, readdir, glob, what, stat, lstat.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Display file listing for directory DIRECTORY.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
dos


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 595
 -- Function File: dos ("COMMAND")
 -- Function File: STATUS = dos ("COMMAND")
 -- Function File: [STATUS, TEXT] = dos ("COMMAND")
 -- Function File: [...] = dos ("COMMAND", "-echo")
     Execute a system command if running under a Windows-like operating system, otherwise do nothing.

     Octave waits for the external command to finish before returning the exit status of the program in STATUS and any output in TEXT.

     When called with no output argument, or the "-echo" argument is given, then TEXT is also sent to standard output.

     See also: unix, system, isunix, ismac, ispc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 96
Execute a system command if running under a Windows-like operating system, otherwise do nothing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
edit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3608
 -- Command: edit NAME
 -- Command: edit FIELD VALUE
 -- Command: VALUE = edit get FIELD
     Edit the named function, or change editor settings.

     If 'edit' is called with the name of a file or function as its argument it will be opened in the text editor defined by 'EDITOR'.

        * If the function NAME is available in a file on your path and that file is modifiable, then it will be edited in place.  If it is a system function, then it will first be copied to the directory 'HOME' (see below) and then edited.  If no file is found, then the m-file variant, ending with ".m", will be considered.  If still no file is found, then variants with a leading "@" and then with both a leading "@" and trailing ".m" will be considered.

        * If NAME is the name of a function defined in the interpreter but not in an m-file, then an m-file will be created in 'HOME' to contain that function along with its current definition.

        * If 'NAME.cc' is specified, then it will search for 'NAME.cc' in the path and try to modify it, otherwise it will create a new '.cc' file in the current directory.  If NAME happens to be an m-file or interpreter defined function, then the text of that function will be inserted into the .cc file as a comment.

        * If 'NAME.ext' is on your path then it will be edited, otherwise the editor will be started with 'NAME.ext' in the current directory as the filename.  If 'NAME.ext' is not modifiable, it will be copied to 'HOME' before editing.

          *Warning:* You may need to clear NAME before the new definition is available.  If you are editing a .cc file, you will need to execute 'mkoctfile NAME.cc' before the definition will be available.

     If 'edit' is called with FIELD and VALUE variables, the value of the control field FIELD will be set to VALUE.  If an output argument is requested and the first input argument is 'get' then 'edit' will return the value of the control field FIELD.  If the control field does not exist, edit will return a structure containing all fields and values.  Thus, 'edit get all' returns a complete control structure.

     The following control fields are used:

     'home'
          This is the location of user local m-files.  Be sure it is in your path.  The default is '~/octave'.

     'author'
          This is the name to put after the "## Author:" field of new functions.  By default it guesses from the 'gecos' field of the password database.

     'email'
          This is the e-mail address to list after the name in the author field.  By default it guesses '<$LOGNAME@$HOSTNAME>', and if '$HOSTNAME' is not defined it uses 'uname -n'.  You probably want to override this.  Be sure to use the format '<user@host>'.

     'license'

          'gpl'
               GNU General Public License (default).

          'bsd'
               BSD-style license without advertising clause.

          'pd'
               Public domain.

          '"text"'
               Your own default copyright and license.

          Unless you specify 'pd', edit will prepend the copyright statement with "Copyright (C) yyyy Function Author".

     'mode'
          This value determines whether the editor should be started in async mode (editor is started in the background and Octave continues) or sync mode (Octave waits until the editor exits).  Set it to "sync" to start the editor in sync mode.  The default is "async" (*note system: XREFsystem.).

     'editinplace'
          Determines whether files should be edited in place, without regard to whether they are modifiable or not.  The default is 'false'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Edit the named function, or change editor settings.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
error_ids


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 859
'Octave:invalid-context'
     Indicates the error was generated by an operation that cannot be executed in the scope from which it was called.  For example, the function 'print_usage ()' when called from the Octave prompt raises this error.

'Octave:invalid-input-arg'
     Indicates that a function was called with invalid input arguments.

'Octave:invalid-fun-call'
     Indicates that a function was called in an incorrect way, e.g., wrong number of input arguments.

'Octave:invalid-indexing'
     Indicates that a data-type was indexed incorrectly, e.g., real-value index for arrays, nonexistent field of a structure.

'Octave:bad-alloc'
     Indicates that memory couldn't be allocated.

'Octave:undefined-function'
     Indicates a call to a function that is not defined.  The function may exist but Octave is unable to find it in the search path.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 138
'Octave:invalid-context'  Indicates the error was generated by an operation that cannot be executed in the scope from which it was called.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fact


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 131
 -- Command: fact
 -- Function File: TRUTH = fact ()
     Display an amazing and random fact about the world's greatest hacker.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
Display an amazing and random fact about the world's greatest hacker.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
fileattrib


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1190
 -- Function File: [STATUS, RESULT, MSGID] = fileattrib (FILE)
     Return information about FILE.

     If successful, STATUS is 1, with RESULT containing a structure with the following fields:

     'Name'
          Full name of FILE.

     'archive'
          True if FILE is an archive (Windows).

     'system'
          True if FILE is a system file (Windows).

     'hidden'
          True if FILE is a hidden file (Windows).

     'directory'
          True if FILE is a directory.

     'UserRead'
     'GroupRead'
     'OtherRead'
          True if the user (group; other users) has read permission for FILE.

     'UserWrite'
     'GroupWrite'
     'OtherWrite'
          True if the user (group; other users) has write permission for FILE.

     'UserExecute'
     'GroupExecute'
     'OtherExecute'
          True if the user (group; other users) has execute permission for FILE.

     If an attribute does not apply (i.e., archive on a Unix system) then the field is set to NaN.

     With no input arguments, return information about the current directory.

     If FILE contains globbing characters, return information about all the matching files.

     See also: glob.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Return information about FILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fileparts


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 313
 -- Function File: [DIR, NAME, EXT] = fileparts (FILENAME)
     Return the directory, name, and extension components of FILENAME.

     The input FILENAME is a string which is parsed.  There is no attempt to check whether the filename or directory specified actually exists.

     See also: fullfile, filesep.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Return the directory, name, and extension components of FILENAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
fullfile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 972
 -- Function File: FILENAME = fullfile (DIR1, DIR2, ..., FILE)
 -- Function File: FILENAMES = fullfile (..., FILES)
     Build complete filename from separate parts.

     Joins any number of path components intelligently.  The return value is the concatenation of each component with exactly one file separator between each non empty part and at most one leading and/or trailing file separator.

     If the last component part is a cell array, returns a cell array of filepaths, one for each element in the last component, e.g.:

          fullfile ("/home/username", "data", {"f1.csv", "f2.csv", "f3.csv"})
          =>  /home/username/data/f1.csv
              /home/username/data/f2.csv
              /home/username/data/f3.csv

     On Windows systems, while forward slash file separators do work, they are replaced by backslashes; in addition drive letters are stripped of leading file separators to obtain a valid file path.

     See also: fileparts, filesep.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Build complete filename from separate parts.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
genvarname


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2023
 -- Function File: VARNAME = genvarname (STR)
 -- Function File: VARNAME = genvarname (STR, EXCLUSIONS)
     Create valid unique variable name(s) from STR.

     If STR is a cellstr, then a unique variable is created for each cell in STR.

          genvarname ({"foo", "foo"})
            =>
               {
                 [1,1] = foo
                 [1,2] = foo1
               }

     If EXCLUSIONS is given, then the variable(s) will be unique to each other and to EXCLUSIONS (EXCLUSIONS may be either a string or a cellstr).

          x = 3.141;
          genvarname ("x", who ())
            => x1

     Note that the result is a char array or cell array of strings, not the variables themselves.  To define a variable, 'eval()' can be used.  The following trivial example sets 'x' to '42'.

          name = genvarname ("x");
          eval ([name " = 42"]);
            => x =  42

     This can be useful for creating unique struct field names.

          x = struct ();
          for i = 1:3
            x.(genvarname ("a", fieldnames (x))) = i;
          endfor
            => x =
               {
                 a =  1
                 a1 =  2
                 a2 =  3
               }

     Since variable names may only contain letters, digits, and underscores, 'genvarname' will replace any sequence of disallowed characters with an underscore.  Also, variables may not begin with a digit; in this case an 'x' is added before the variable name.

     Variable names beginning and ending with two underscores "__" are valid, but they are used internally by Octave and should generally be avoided; therefore, 'genvarname' will not generate such names.

     'genvarname' will also ensure that returned names do not clash with keywords such as "for" and "if".  A number will be appended if necessary.  Note, however, that this does *not* include function names such as "sin".  Such names should be included in EXCLUSIONS if necessary.

     See also: isvarname, iskeyword, exist, who, tempname, eval.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Create valid unique variable name(s) from STR.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
getappdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 458
 -- Function File: VALUE = getappdata (H, NAME)
 -- Function File: APPDATA = getappdata (H)
     Return the VALUE of the application data NAME for the graphics object with handle H.

     H may also be a vector of graphics handles.  If no second argument NAME is given then 'getappdata' returns a structure, APPDATA, whose fields correspond to the appdata properties.

     See also: setappdata, isappdata, rmappdata, guidata, get, set, getpref, setpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
Return the VALUE of the application data NAME for the graphics object with handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
getfield


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 573
 -- Function File: VAL = getfield (S, FIELD)
 -- Function File: VAL = getfield (S, SIDX1, FIELD1, FIDX1, ...)
     Get the value of the field named FIELD from a structure or nested structure S.

     If S is a structure array then SIDX selects an element of the structure array, FIELD specifies the field name of the selected element, and FIDX selects which element of the field (in the case of an array or cell array).  See 'setfield' for a more complete description of the syntax.

     See also: setfield, rmfield, orderfields, isfield, fieldnames, isstruct, struct.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Get the value of the field named FIELD from a structure or nested structure S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gunzip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 465
 -- Function File: FILELIST = gunzip (GZFILE)
 -- Function File: FILELIST = gunzip (GZFILE, DIR)
     Unpack the gzip archive GZFILE.

     If GZFILE is a directory, all gzfiles in the directory will be recursively unpacked.

     If DIR is specified the files are unpacked in this directory rather than the one where GZFILE is located.

     The optional output FILELIST is a list of the uncompressed files.

     See also: gzip, unpack, bunzip2, unzip, untar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Unpack the gzip archive GZFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
gzip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 882
 -- Function File: FILELIST = gzip (FILES)
 -- Function File: FILELIST = gzip (FILES, DIR)
     Compress the list of files and directories specified in FILES.

     FILES is a character array or cell array of strings.  Shell wildcards in the filename such as '*' or '?' are accepted and expanded.  Each file is compressed separately and a new file with a '".gz"' extension is created.  The original files are not modified, but existing compressed files will be silently overwritten.  If a directory is specified then 'gzip' recursively compresses all files in the directory.

     If DIR is defined the compressed files are placed in this directory, rather than the original directory where the uncompressed file resides.  If DIR does not exist it is created.

     The optional output FILELIST is a list of the compressed files.

     See also: gunzip, unpack, bzip2, zip, tar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Compress the list of files and directories specified in FILES.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
info


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 93
 -- Function File: info ()
     Display contact information for the GNU Octave community.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Display contact information for the GNU Octave community.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
inputname


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 294
 -- Function File: inputname (N)
     Return the name of the N-th argument to the calling function.

     If the argument is not a simple variable name, return an empty string.  'inputname' may only be used within a function body, not at the command line.

     See also: nargin, nthargout.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Return the name of the N-th argument to the calling function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
isappdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 288
 -- Function File: VALID = isappdata (H, NAME)
     Return true if the named application data, NAME, exists for the graphics object with handle H.

     H may also be a vector of graphics handles.

     See also: getappdata, setappdata, rmappdata, guidata, get, set, getpref, setpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Return true if the named application data, NAME, exists for the graphics object with handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
isdeployed


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 265
 -- Function File: isdeployed ()
     Return true if the current program has been compiled and is running separately from the Octave interpreter and false if it is running in the Octave interpreter.

     Currently, this function always returns false in Octave.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 160
Return true if the current program has been compiled and is running separately from the Octave interpreter and false if it is running in the Octave interpreter.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ismac


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 141
 -- Function File: ismac ()
     Return true if Octave is running on a Mac OS X system and false otherwise.

     See also: isunix, ispc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Return true if Octave is running on a Mac OS X system and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
ispc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 140
 -- Function File: ispc ()
     Return true if Octave is running on a Windows system and false otherwise.

     See also: isunix, ismac.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
Return true if Octave is running on a Windows system and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
isunix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
 -- Function File: isunix ()
     Return true if Octave is running on a Unix-like system and false otherwise.

     See also: ismac, ispc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Return true if Octave is running on a Unix-like system and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
license


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1477
 -- Command: license
 -- Command: license inuse
 -- Command: license inuse FEATURE
 -- Function File: license ("inuse")
 -- Function File: RETVAL = license ("inuse")
 -- Function File: RETVAL = license ("test", FEATURE)
 -- Function File: RETVAL = license ("checkout", FEATURE)
 -- Function File: [RETVAL, ERRMSG] = license ("checkout", FEATURE)
     Get license information for Octave and Octave packages.

     GNU Octave is free software distributed under the GNU General Public License (GPL), and a license manager makes no sense.  This function is provided only for MATLAB compatibility.

     When called with no extra input arguments, it returns the Octave license, otherwise the first input defines the operation mode and must be one of the following strings: 'inuse', 'test', and 'checkout'.  The optional FEATURE argument can either be "octave" (core), or an Octave package.

     "inuse"
          Returns a list of loaded features, i.e., octave and the list of loaded packages.  If an output is requested, it returns a struct array with the fields "feature", and "user".

     "test"
          Return true if the specified FEATURE is installed, false otherwise.

          An optional third argument "enable" or "disable" is accepted but ignored.

     "checkout"
          Return true if the specified FEATURE is installed, false otherwise.  An optional second output will have an error message if a package is not installed.

     See also: pkg, ver, version.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Get license information for Octave and Octave packages.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
list_primes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 194
 -- Function File: list_primes ()
 -- Function File: list_primes (N)
     List the first N primes.

     If N is unspecified, the first 25 primes are listed.

     See also: primes, isprime.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
List the first N primes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2
ls


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 963
 -- Command: ls
 -- Command: ls FILENAMES
 -- Command: ls OPTIONS
 -- Command: ls OPTIONS FILENAMES
 -- Function File: LIST = ls (...)

     List directory contents.

     The 'ls' command is implemented by calling the native operating system's directory listing command--available OPTIONS will vary from system to system.

     Filenames are subject to shell expansion if they contain any wildcard characters '*', '?', '[]'.  To find a literal example of a wildcard character the wildcard must be escaped using the backslash operator '\'.

     If the optional output LIST is requested then 'ls' returns a character array with one row for each file/directory name.

     Example usage on a UNIX-like system:

          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

     See also: dir, readdir, glob, what, stat, filesep, ls_command.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
List directory contents.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
ls_command


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 179
 -- Function File: VAL = ls_command ()
 -- Function File: OLD_VAL = ls_command (NEW_VAL)
     Query or set the shell command used by Octave's 'ls' command.

     See also: ls.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Query or set the shell command used by Octave's 'ls' command.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
menu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 798
 -- Function File: CHOICE = menu (TITLE, OPT1, ...)
 -- Function File: CHOICE = menu (TITLE, {OPT1, ...})
     Display a menu with heading TITLE and options OPT1, ..., and wait for user input.

     If the GUI is running, or Java is available, the menu is displayed graphically using 'listdlg'.  Otherwise, the title and menu options are printed on the console.

     TITLE is a string and the options may be input as individual strings or as a cell array of strings.

     The return value CHOICE is the number of the option selected by the user counting from 1.

     This function is useful for interactive programs.  There is no limit to the number of options that may be passed in, but it may be confusing to present more than will fit easily on one screen.

     See also: input, listdlg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Display a menu with heading TITLE and options OPT1, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
mex


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 207
 -- Command: mex [options] file ...
     Compile source code written in C, C++, or Fortran, to a MEX file.

     This is equivalent to 'mkoctfile --mex [options] file'.

     See also: mkoctfile, mexext.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Compile source code written in C, C++, or Fortran, to a MEX file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mexext


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
 -- Function File: mexext ()
     Return the filename extension used for MEX files.

     See also: mex.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Return the filename extension used for MEX files.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
mkoctfile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4131
 -- Command: mkoctfile [-options] file ...
 -- Function File: [OUTPUT, STATUS] = mkoctfile (...)

     The 'mkoctfile' function compiles source code written in C, C++, or Fortran.  Depending on the options used with 'mkoctfile', the compiled code can be called within Octave or can be used as a stand-alone application.

     'mkoctfile' can be called from the shell prompt or from the Octave prompt.  Calling it from the Octave prompt simply delegates the call to the shell prompt.  The output is stored in the OUTPUT variable and the exit status in the STATUS variable.

     'mkoctfile' accepts the following options, all of which are optional except for the file name of the code you wish to compile:

     '-I DIR'
          Add the include directory DIR to compile commands.

     '-D DEF'
          Add the definition DEF to the compiler call.

     '-l LIB'
          Add the library LIB to the link command.

     '-L DIR'
          Add the library directory DIR to the link command.

     '-M'
     '--depend'
          Generate dependency files (.d) for C and C++ source files.

     '-R DIR'
          Add the run-time path to the link command.

     '-Wl,...'
          Pass flags though the linker like "-Wl,-rpath=...".  The quotes are needed since commas are interpreted as command separators.

     '-W...'
          Pass flags though the compiler like "-Wa,OPTION".

     '-c'
          Compile but do not link.

     '-g'
          Enable debugging options for compilers.

     '-o FILE'
     '--output FILE'
          Output file name.  Default extension is .oct (or .mex if '--mex' is specified) unless linking a stand-alone executable.

     '-p VAR'
     '--print VAR'
          Print the configuration variable VAR.  Recognized variables are:

                  ALL_CFLAGS                  INCFLAGS
                  ALL_CXXFLAGS                INCLUDEDIR
                  ALL_FFLAGS                  LAPACK_LIBS
                  ALL_LDFLAGS                 LD_CXX
                  AR                          LDFLAGS
                  BLAS_LIBS                   LD_STATIC_FLAG
                  CC                          LFLAGS
                  CFLAGS                      LIBDIR
                  CPICFLAG                    LIBOCTAVE
                  CPPFLAGS                    LIBOCTINTERP
                  CXX                         LIBS
                  CXXFLAGS                    OCTAVE_HOME
                  CXXPICFLAG                  OCTAVE_LIBS
                  DEPEND_EXTRA_SED_PATTERN    OCTAVE_LINK_DEPS
                  DEPEND_FLAGS                OCTAVE_LINK_OPTS
                  DL_LD                       OCTAVE_PREFIX
                  DL_LDFLAGS                  OCTINCLUDEDIR
                  F77                         OCTLIBDIR
                  F77_INTEGER8_FLAG           OCT_LINK_DEPS
                  FFLAGS                      OCT_LINK_OPTS
                  FFTW3F_LDFLAGS              RANLIB
                  FFTW3F_LIBS                 RDYNAMIC_FLAG
                  FFTW3_LDFLAGS               READLINE_LIBS
                  FFTW3_LIBS                  SED
                  FFTW_LIBS                   SPECIAL_MATH_LIB
                  FLIBS                       XTRA_CFLAGS
                  FPICFLAG                    XTRA_CXXFLAGS

     '--link-stand-alone'
          Link a stand-alone executable file.

     '--mex'
          Assume we are creating a MEX file.  Set the default output extension to ".mex".

     '-s'
     '--strip'
          Strip the output file.

     '-v'
     '--verbose'
          Echo commands as they are executed.

     'file'
          The file to compile or link.  Recognized file types are

                  .c    C source
                  .cc   C++ source
                  .C    C++ source
                  .cpp  C++ source
                  .f    Fortran source (fixed form)
                  .F    Fortran source (fixed form)
                  .f90  Fortran source (free form)
                  .F90  Fortran source (free form)
                  .o    object file
                  .a    library file

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
The 'mkoctfile' function compiles source code written in C, C++, or Fortran.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
movefile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 923
 -- Function File: movefile (F1)
 -- Function File: movefile (F1, F2)
 -- Function File: movefile (F1, F2, 'f')
 -- Function File: [STATUS, MSG, MSGID] = movefile (...)
     Move the source files or directories F1 to the destination F2.

     The name F1 may contain globbing patterns.  If F1 expands to multiple file names, F2 must be a directory.  If no destination F2 is specified then the destination is the present working directory.  If F2 is a file name then F1 is renamed to F2.

     When the force flag 'f' is given any existing files will be overwritten without prompting.

     If successful, STATUS is 1, and MSG, MSGID are empty character strings ("").  Otherwise, STATUS is 0, MSG contains a system-dependent error message, and MSGID contains a unique message identifier.  Note that the status code is exactly opposite that of the 'system' command.

     See also: rename, copyfile, unlink, delete, glob.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Move the source files or directories F1 to the destination F2.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
namelengthmax


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 436
 -- Function File: namelengthmax ()
     Return the MATLAB compatible maximum variable name length.

     Octave is capable of storing strings up to 2^{31} - 1 in length.  However for MATLAB compatibility all variable, function, and structure field names should be shorter than the length returned by 'namelengthmax'.  In particular, variables stored to a MATLAB file format ('*.mat') will have their names truncated to this length.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Return the MATLAB compatible maximum variable name length.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
news


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 306
 -- Command: news
 -- Command: news PACKAGE
     Display the current NEWS file for Octave or an installed package.

     When called without an argument, display the NEWS file for Octave.

     When given a package name PACKAGE, display the current NEWS file for that package.

     See also: ver, pkg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Display the current NEWS file for Octave or an installed package.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
open


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 493
 -- Function File: OUTPUT = open FILE
 -- Function File: OUTPUT = open (FILE)
     Open the file FILE in Octave or in an external application based on the file type as determined by the file name extension.

     Recognized file types are

     '.m'
          Open file in the editor.

     '.mat'
          Load the file in the base workspace.

     '.exe'
          Execute the program (on Windows systems only).

     Other file types are opened in the appropriate external application.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
Open the file FILE in Octave or in an external application based on the file type as determined by the file name extension.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
orderfields


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1956
 -- Function File: SOUT = orderfields (S1)
 -- Function File: SOUT = orderfields (S1, S2)
 -- Function File: SOUT = orderfields (S1, {CELLSTR})
 -- Function File: SOUT = orderfields (S1, P)
 -- Function File: [SOUT, P] = orderfields (...)
     Return a _copy_ of S1 with fields arranged alphabetically, or as specified by the second input.

     Given one input struct S1, arrange field names alphabetically.

     If a second struct argument is given, arrange field names in S1 as they appear in S2.  The second argument may also specify the order in a cell array of strings CELLSTR.  The second argument may also be a permutation vector.

     The optional second output argument P is the permutation vector which converts the original name order to the new name order.

     Examples:

          s = struct ("d", 4, "b", 2, "a", 1, "c", 3);
          t1 = orderfields (s)
               => t1 =
                  {
                    a =  1
                    b =  2
                    c =  3
                    d =  4
                  }
          t = struct ("d", {}, "c", {}, "b", {}, "a", {});
          t2 = orderfields (s, t)
               => t2 =
                  {
                    d =  4
                    c =  3
                    b =  2
                    a =  1
                  }
          t3 = orderfields (s, [3, 2, 4, 1])
               => t3 =
                  {
                    a =  1
                    b =  2
                    c =  3
                    d =  4
                  }
          [t4, p] = orderfields (s, {"d", "c", "b", "a"})
               => t4 =
                  {
                    d =  4
                    c =  3
                    b =  2
                    a =  1
                  }
                  p =
                     1
                     4
                     2
                     3

     See also: fieldnames, getfield, setfield, rmfield, isfield, isstruct, struct.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Return a _copy_ of S1 with fields arranged alphabetically, or as specified by the second input.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
pack


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 177
 -- Function File: pack ()
     Consolidate workspace memory in MATLAB.

     This function is provided for compatibility, but does nothing in Octave.

     See also: clear.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Consolidate workspace memory in MATLAB.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
paren


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
 -- Operator: (
 -- Operator: )
     Array index or function argument delimeter.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Array index or function argument delimeter.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
parseparams


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1172
 -- Function File: [REG, PROP] = parseparams (PARAMS)
 -- Function File: [REG, VAR1, ...] = parseparams (PARAMS, NAME1, DEFAULT1, ...)
     Return in REG the cell elements of PARAM up to the first string element and in PROP all remaining elements beginning with the first string element.

     For example:

          [reg, prop] = parseparams ({1, 2, "linewidth", 10})
          reg =
          {
            [1,1] = 1
            [1,2] = 2
          }
          prop =
          {
            [1,1] = linewidth
            [1,2] = 10
          }

     The parseparams function may be used to separate regular numeric arguments from additional arguments given as property/value pairs of the VARARGIN cell array.

     In the second form of the call, available options are specified directly with their default values given as name-value pairs.  If PARAMS do not form name-value pairs, or if an option occurs that does not match any of the available options, an error occurs.

     When called from an m-file function, the error is prefixed with the name of the caller function.

     The matching of options is case-insensitive.

     See also: varargin, inputParser.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
Return in REG the cell elements of PARAM up to the first string element and in PROP all remaining elements beginning with the first string element.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
perl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 469
 -- Function File: OUTPUT = perl (SCRIPTFILE)
 -- Function File: OUTPUT = perl (SCRIPTFILE, ARGUMENT1, ARGUMENT2, ...)
 -- Function File: [OUTPUT, STATUS] = perl (...)
     Invoke Perl script SCRIPTFILE, possibly with a list of command line arguments.

     Return output in OUTPUT and optional status in STATUS.  If SCRIPTFILE is not an absolute file name it is searched for in the current directory and then in the Octave loadpath.

     See also: system, python.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Invoke Perl script SCRIPTFILE, possibly with a list of command line arguments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
python


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 475
 -- Function File: OUTPUT = python (SCRIPTFILE)
 -- Function File: OUTPUT = python (SCRIPTFILE, ARGUMENT1, ARGUMENT2, ...)
 -- Function File: [OUTPUT, STATUS] = python (...)
     Invoke Python script SCRIPTFILE, possibly with a list of command line arguments.

     Return output in OUTPUT and optional status in STATUS.  If SCRIPTFILE is not an absolute file name it is searched for in the current directory and then in the Octave loadpath.

     See also: system, perl.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Invoke Python script SCRIPTFILE, possibly with a list of command line arguments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
recycle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 580
 -- Function File: CURRENT_STATE = recycle ()
 -- Function File: OLD_STATE = recycle (NEW_STATE)
     Query or set the preference for recycling deleted files.

     When recycling is enabled, commands which would permanently erase files instead move them to a temporary location (such as the directory labeled Trash).

     Programming Note: This function is provided for MATLAB compatibility, but recycling is not implemented in Octave.  To help avoid accidental data loss an error will be raised if an attempt is made to enable file recycling.

     See also: delete, rmdir.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Query or set the preference for recycling deleted files.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
rmappdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 360
 -- Function File: rmappdata (H, NAME)
 -- Function File: rmappdata (H, NAME1, NAME2, ...)
     Delete the application data NAME from the graphics object with handle H.

     H may also be a vector of graphics handles.  Multiple application data names may be supplied to delete several properties at once.

     See also: setappdata, getappdata, isappdata.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Delete the application data NAME from the graphics object with handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
run


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 920
 -- Command: run SCRIPT
 -- Function File: run ("SCRIPT")
     Run SCRIPT in the current workspace.

     Scripts which reside in directories specified in Octave's load path, and which end with the extension '".m"', can be run simply by typing their name.  For scripts not located on the load path, use 'run'.

     The file name SCRIPT can be a bare, fully qualified, or relative filename and with or without a file extension.  If no extension is specified, Octave will first search for a script with the '".m"' extension before falling back to the script name without an extension.

     Implementation Note: If SCRIPT includes a path component, then 'run' first changes the working directory to the directory where SCRIPT is found.  Next, the script is executed.  Finally, 'run' returns to the original working directory unless 'script' has specifically changed directories.

     See also: path, addpath, source.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Run SCRIPT in the current workspace.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
semicolon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
 -- Operator: ;
     Array row or command separator.

     See also: comma.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Array row or command separator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
setappdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 474
 -- Function File: setappdata (H, NAME, VALUE)
 -- Function File: setappdata (H, NAME1, VALUE1, NAME2, VALUE3, ...)
     Set the application data NAME to VALUE for the graphics object with handle H.

     H may also be a vector of graphics handles.  If the application data with the specified NAME does not exist, it is created.  Multiple NAME/VALUE pairs can be specified at a time.

     See also: getappdata, isappdata, rmappdata, guidata, get, set, getpref, setpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Set the application data NAME to VALUE for the graphics object with handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
setfield


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2570
 -- Function File: SOUT = setfield (S, FIELD, VAL)
 -- Function File: SOUT = setfield (S, SIDX1, FIELD1, FIDX1, SIDX2, FIELD2, FIDX2, ..., VAL)

     Return a _copy_ of the structure S with the field member FIELD set to the value VAL.

     For example:

          S = struct ();
          S = setfield (S, "foo bar", 42);

     This is equivalent to

          S.("foo bar") = 42;

     Note that ordinary structure syntax 'S.foo bar = 42' cannot be used here, as the field name is not a valid Octave identifier because of the space character.  Using arbitrary strings for field names is incompatible with MATLAB, and this usage will emit a warning if the warning ID 'Octave:language-extension' is enabled.  *Note XREFwarning_ids::.

     With the second calling form, set a field of a structure array.  The input SIDX selects an element of the structure array, FIELD specifies the field name of the selected element, and FIDX selects which element of the field (in the case of an array or cell array).  The SIDX, FIELD, and FIDX inputs can be repeated to address nested structure array elements.  The structure array index and field element index must be cell arrays while the field name must be a string.

     For example:

          S = struct ("baz", 42);
          setfield (S, {1}, "foo", {1}, "bar", 54)
          =>
            ans =
              scalar structure containing the fields:
                baz =  42
                foo =
                  scalar structure containing the fields:
                    bar =  54

     The example begins with an ordinary scalar structure to which a nested scalar structure is added.  In all cases, if the structure index SIDX is not specified it defaults to 1 (scalar structure).  Thus, the example above could be written more concisely as 'setfield (S, "foo", "bar", 54)'

     Finally, an example with nested structure arrays:

          SA.foo = 1;
          SA = setfield (SA, {2}, "bar", {3}, "baz", {1, 4}, 5);
          SA(2).bar(3)
          =>
            ans =
              scalar structure containing the fields:
                baz =  0   0   0   5

     Here SA is a structure array whose field at elements 1 and 2 is in turn another structure array whose third element is a simple scalar structure.  The terminal scalar structure has a field which contains a matrix value.

     Note that the same result as in the above example could be achieved by:

          SA.foo = 1;
          SA(2).bar(3).baz(1,4) = 5

     See also: getfield, rmfield, orderfields, isfield, fieldnames, isstruct, struct.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
Return a _copy_ of the structure S with the field member FIELD set to the value VAL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
substruct


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 583
 -- Function File: substruct (TYPE, SUBS, ...)
     Create a subscript structure for use with 'subsref' or 'subsasgn'.

     For example:

          idx = substruct ("()", {3, ":"})
               =>
                 idx =
                 {
                   type = ()
                   subs =
                   {
                     [1,1] =  3
                     [1,2] = :
                   }
                 }
          x = [1, 2, 3;
               4, 5, 6;
               7, 8, 9];
          subsref (x, idx)
             => 7  8  9

     See also: subsref, subsasgn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Create a subscript structure for use with 'subsref' or 'subsasgn'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
swapbytes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 259
 -- Function File: swapbytes (X)
     Swap the byte order on values, converting from little endian to big endian and vice versa.

     For example:

          swapbytes (uint16 (1:4))
          => [   256   512   768  1024]

     See also: typecast, cast.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Swap the byte order on values, converting from little endian to big endian and vice versa.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
symvar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 467
 -- Function File: VARS = symvar (STR)
     Identify the symbolic variable names in the string STR.

     Common constant names such as 'i', 'j', 'pi', 'Inf' and Octave functions such as 'sin' or 'plot' are ignored.

     Any names identified are returned in a cell array of strings.  The array is empty if no variables were found.

     Example:

          symvar ("x^2 + y^2 == 4")
          => {
               [1,1] = x
               [2,1] = y
             }
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Identify the symbolic variable names in the string STR.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
tar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 703
 -- Function File: FILELIST = tar (TARFILE, FILES)
 -- Function File: FILELIST = tar (TARFILE, FILES, ROOTDIR)
     Pack the list of files and directories specified in FILES into the TAR archive TARFILE.

     FILES is a character array or cell array of strings.  Shell wildcards in the filename such as '*' or '?' are accepted and expanded.  Directories are recursively traversed and all files are added to the archive.

     If ROOTDIR is defined then any files without absolute pathnames are located relative to ROOTDIR rather than the current directory.

     The optional output FILELIST is a list of the files that were included in the archive.

     See also: untar, unpack, bzip2, gzip, zip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 87
Pack the list of files and directories specified in FILES into the TAR archive TARFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
tempdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 321
 -- Function File: DIR = tempdir ()
     Return the name of the host system's directory for temporary files.

     The directory name is taken first from the environment variable 'TMPDIR'.  If that does not exist the system default returned by 'P_tmpdir' is used.

     See also: P_tmpdir, tempname, mkstemp, tmpfile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Return the name of the host system's directory for temporary files.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tmpnam


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 948
 -- Function File: FNAME = tmpnam ()
 -- Function File: FNAME = tmpnam (DIR)
 -- Function File: FNAME = tmpnam (DIR, PREFIX)
     Return a unique temporary file name as a string.

     If PREFIX is omitted, a value of "oct-" is used.

     If DIR is also omitted, the default directory for temporary files ('P_tmpdir' is used.  If DIR is provided, it must exist, otherwise the default directory for temporary files is used.

     Programming Note: Because the named file is not opened by 'tmpnam', it is possible, though relatively unlikely, that it will not be available by the time your program attempts to open it.  If this is a concern, see 'tmpfile'.  The functions 'tmpnam' and 'tempname' are equivalent with the latter provided for MATLAB compatibility.

     *Caution*: 'tmpnam' will be removed in a future version of Octave.  Use the equivalent 'tempname' in all new code.

     See also: tempname, mkstemp, tempdir, P_tmpdir, tmpfile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Return a unique temporary file name as a string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
unix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 595
 -- Function File: unix ("COMMAND")
 -- Function File: STATUS = unix ("COMMAND")
 -- Function File: [STATUS, TEXT] = unix ("COMMAND")
 -- Function File: [...] = unix ("COMMAND", "-echo")
     Execute a system command if running under a Unix-like operating system, otherwise do nothing.

     Octave waits for the external command to finish before returning the exit status of the program in STATUS and any output in TEXT.

     When called with no output argument, or the "-echo" argument is given, then TEXT is also sent to standard output.

     See also: dos, system, isunix, ismac, ispc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 93
Execute a system command if running under a Unix-like operating system, otherwise do nothing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
unpack


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1201
 -- Function File: FILES = unpack (FILE)
 -- Function File: FILES = unpack (FILE, DIR)
 -- Function File: FILES = unpack (FILE, DIR, FILETYPE)
     Unpack the archive FILE based on its extension to the directory DIR.

     If FILE is a list of strings, then each file is unpacked individually.  Shell wildcards in the filename such as '*' or '?' are accepted and expanded.

     If DIR is not specified or is empty ('[]'), it defaults to the current directory.  If a directory is in the file list, then FILETYPE must also be specified.

     The specific archive filetype is inferred from the extension of the file.  The FILETYPE may also be specified directly using a string which corresponds to a known extension.

     Valid filetype extensions:

     'bz'
     'bz2'
          bzip archive

     'gz'
          gzip archive

     'tar'
          tar archive

     'tarbz'
     'tarbz2'
     'tbz'
     'tbz2'
          tar + bzip archive

     'targz'
     'tgz'
          tar + gzip archive

     'z'
          compress archive

     'zip'
          zip archive

     The optional return value is a list of FILES unpacked.

     See also: bunzip2, gunzip, unzip, untar, bzip2, gzip, zip, tar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Unpack the archive FILE based on its extension to the directory DIR.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
untar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 353
 -- Function File: untar (TARFILE)
 -- Function File: untar (TARFILE, DIR)
     Unpack the TAR archive TARFILE.

     If DIR is specified the files are unpacked in this directory rather than the one where TARFILE is located.

     The optional output FILELIST is a list of the uncompressed files.

     See also: tar, unpack, bunzip2, gunzip, unzip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Unpack the TAR archive TARFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
unzip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 375
 -- Function File: FILELIST = unzip (ZIPFILE)
 -- Function File: FILELIST = unzip (ZIPFILE, DIR)
     Unpack the ZIP archive ZIPFILE.

     If DIR is specified the files are unpacked in this directory rather than the one where ZIPFILE is located.

     The optional output FILELIST is a list of the uncompressed files.

     See also: zip, unpack, bunzip2, gunzip, untar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Unpack the ZIP archive ZIPFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
ver


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 830
 -- Function File: ver
 -- Function File: ver Octave
 -- Function File: ver PACKAGE
 -- Function File: v = ver (...)

     Display a header containing the current Octave version number, license string, and operating system.  The header is followed by a list of installed packages, versions, and installation directories.

     Use the package name PACKAGE or Octave to limit the listing to a desired component.

     When called with an output argument, return a vector of structures describing Octave and each installed package.  The structure includes the following fields.

     'Name'
          Package name.

     'Version'
          Version of the package.

     'Revision'
          Revision of the package.

     'Date'
          Date of the version/revision.

     See also: version, octave_config_info, usejava, pkg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 100
Display a header containing the current Octave version number, license string, and operating system.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
version


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 209
 -- Function File: version ()
     Return the version number of Octave as a string.

     This is an alias for the function 'OCTAVE_VERSION' provided for compatibility.

     See also: OCTAVE_VERSION, ver.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Return the version number of Octave as a string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
warning_ids


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10266
'Octave:abbreviated-property-match'
     By default, the 'Octave:abbreviated-property-match' warning is enabled.

'Octave:array-to-scalar'
     If the 'Octave:array-to-scalar' warning is enabled, Octave will warn when an implicit conversion from an array to a scalar value is attempted.  By default, the 'Octave:array-to-scalar' warning is disabled.

'Octave:array-to-vector'
     If the 'Octave:array-to-vector' warning is enabled, Octave will warn when an implicit conversion from an array to a vector value is attempted.  By default, the 'Octave:array-to-vector' warning is disabled.

'Octave:assign-as-truth-value'
     If the 'Octave:assign-as-truth-value' warning is enabled, a warning is issued for statements like

          if (s = t)
            ...

     since such statements are not common, and it is likely that the intent was to write

          if (s == t)
            ...

     instead.

     There are times when it is useful to write code that contains assignments within the condition of a 'while' or 'if' statement.  For example, statements like

          while (c = getc ())
            ...

     are common in C programming.

     It is possible to avoid all warnings about such statements by disabling the 'Octave:assign-as-truth-value' warning, but that may also let real errors like

          if (x = 1)  # intended to test (x == 1)!
            ...

     slip by.

     In such cases, it is possible suppress errors for specific statements by writing them with an extra set of parentheses.  For example, writing the previous example as

          while ((c = getc ()))
            ...

     will prevent the warning from being printed for this statement, while allowing Octave to warn about other assignments used in conditional contexts.

     By default, the 'Octave:assign-as-truth-value' warning is enabled.

'Octave:associativity-change'
     If the 'Octave:associativity-change' warning is enabled, Octave will warn about possible changes in the meaning of some code due to changes in associativity for some operators.  Associativity changes have typically been made for MATLAB compatibility.  By default, the 'Octave:associativity-change' warning is enabled.

'Octave:autoload-relative-file-name'
     If the 'Octave:autoload-relative-file-name' is enabled, Octave will warn when parsing autoload() function calls with relative paths to function files.  This usually happens when using autoload() calls in PKG_ADD files, when the PKG_ADD file is not in the same directory as the .oct file referred to by the autoload() command.  By default, the 'Octave:autoload-relative-file-name' warning is enabled.

'Octave:built-in-variable-assignment'
     By default, the 'Octave:built-in-variable-assignment' warning is enabled.

'Octave:deprecated-keyword'
     If the 'Octave:deprecated-keyword' warning is enabled, a warning is issued when Octave encounters a keyword that is obsolete and scheduled for removal from Octave.  By default, the 'Octave:deprecated-keyword' warning is enabled.

'Octave:divide-by-zero'
     If the 'Octave:divide-by-zero' warning is enabled, a warning is issued when Octave encounters a division by zero.  By default, the 'Octave:divide-by-zero' warning is enabled.

'Octave:fopen-file-in-path'
     By default, the 'Octave:fopen-file-in-path' warning is enabled.

'Octave:function-name-clash'
     If the 'Octave:function-name-clash' warning is enabled, a warning is issued when Octave finds that the name of a function defined in a function file differs from the name of the file.  (If the names disagree, the name declared inside the file is ignored.)  By default, the 'Octave:function-name-clash' warning is enabled.

'Octave:future-time-stamp'
     If the 'Octave:future-time-stamp' warning is enabled, Octave will print a warning if it finds a function file with a time stamp that is in the future.  By default, the 'Octave:future-time-stamp' warning is enabled.

'Octave:glyph-render'
     By default, the 'Octave:glyph-render' warning is enabled.

'Octave:imag-to-real'
     If the 'Octave:imag-to-real' warning is enabled, a warning is printed for implicit conversions of complex numbers to real numbers.  By default, the 'Octave:imag-to-real' warning is disabled.

'Octave:language-extension'
     Print warnings when using features that are unique to the Octave language and that may still be missing in MATLAB.  By default, the 'Octave:language-extension' warning is disabled.  The '--traditional' or '--braindead' startup options for Octave may also be of use, *note Command Line Options::.

'Octave:load-file-in-path'
     By default, the 'Octave:load-file-in-path' warning is enabled.

'Octave:logical-conversion'
     By default, the 'Octave:logical-conversion' warning is enabled.

'Octave:md5sum-file-in-path'
     By default, the 'Octave:md5sum-file-in-path' warning is enabled.

'Octave:missing-glyph'
     By default, the 'Octave:missing-glyph' warning is enabled.

'Octave:missing-semicolon'
     If the 'Octave:missing-semicolon' warning is enabled, Octave will warn when statements in function definitions don't end in semicolons.  By default the 'Octave:missing-semicolon' warning is disabled.

'Octave:mixed-string-concat'
     If the 'Octave:mixed-string-concat' warning is enabled, print a warning when concatenating a mixture of double and single quoted strings.  By default, the 'Octave:mixed-string-concat' warning is disabled.

'Octave:neg-dim-as-zero'
     If the 'Octave:neg-dim-as-zero' warning is enabled, print a warning for expressions like

          eye (-1)

     By default, the 'Octave:neg-dim-as-zero' warning is disabled.

'Octave:nested-functions-coerced'
     By default, the 'Octave:nested-functions-coerced' warning is enabled.

'Octave:noninteger-range-as-index'
     By default, the 'Octave:noninteger-range-as-index' warning is enabled.

'Octave:num-to-str'
     If the 'Octave:num-to-str' warning is enable, a warning is printed for implicit conversions of numbers to their ASCII character equivalents when strings are constructed using a mixture of strings and numbers in matrix notation.  For example,

          [ "f", 111, 111 ]
          => "foo"

     elicits a warning if the 'Octave:num-to-str' warning is enabled.  By default, the 'Octave:num-to-str' warning is enabled.

'Octave:possible-matlab-short-circuit-operator'
     If the 'Octave:possible-matlab-short-circuit-operator' warning is enabled, Octave will warn about using the not short circuiting operators '&' and '|' inside 'if' or 'while' conditions.  They normally never short circuit, but MATLAB always short circuits if any logical operators are used in a condition.  You can turn on the option

          do_braindead_shortcircuit_evaluation (1)

     if you would like to enable this short-circuit evaluation in Octave.  Note that the '&&' and '||' operators always short circuit in both Octave and MATLAB, so it's only necessary to enable MATLAB-style short-circuiting if it's too arduous to modify existing code that relies on this behavior.  By default, the 'Octave:possible-matlab-short-circuit-operator' warning is enabled.

'Octave:precedence-change'
     If the 'Octave:precedence-change' warning is enabled, Octave will warn about possible changes in the meaning of some code due to changes in precedence for some operators.  Precedence changes have typically been made for MATLAB compatibility.  By default, the 'Octave:precedence-change' warning is enabled.

'Octave:recursive-path-search'
     By default, the 'Octave:recursive-path-search' warning is enabled.

'Octave:remove-init-dir'
     The 'path' function changes the search path that Octave uses to find functions.  It is possible to set the path to a value which excludes Octave's own built-in functions.  If the 'Octave:remove-init-dir' warning is enabled then Octave will warn when the 'path' function has been used in a way that may render Octave unworkable.  By default, the 'Octave:remove-init-dir' warning is enabled.

'Octave:reload-forces-clear'
     If several functions have been loaded from the same file, Octave must clear all the functions before any one of them can be reloaded.  If the 'Octave:reload-forces-clear' warning is enabled, Octave will warn you when this happens, and print a list of the additional functions that it is forced to clear.  By default, the 'Octave:reload-forces-clear' warning is enabled.

'Octave:resize-on-range-error'
     If the 'Octave:resize-on-range-error' warning is enabled, print a warning when a matrix is resized by an indexed assignment with indices outside the current bounds.  By default, the ## 'Octave:resize-on-range-error' warning is disabled.

'Octave:separator-insert'
     Print warning if commas or semicolons might be inserted automatically in literal matrices.  By default, the 'Octave:separator-insert' warning is disabled.

'Octave:shadowed-function'
     By default, the 'Octave:shadowed-function' warning is enabled.

'Octave:single-quote-string'
     Print warning if a single quote character is used to introduce a string constant.  By default, the 'Octave:single-quote-string' warning is disabled.

'Octave:nearly-singular-matrix'
'Octave:singular-matrix'
     By default, the 'Octave:nearly-singular-matrix' and 'Octave:singular-matrix' warnings are enabled.

'Octave:sqrtm:SingularMatrix'
     By default, the 'Octave:sqrtm:SingularMatrix' warning is enabled.

'Octave:str-to-num'
     If the 'Octave:str-to-num' warning is enabled, a warning is printed for implicit conversions of strings to their numeric ASCII equivalents.  For example,

          "abc" + 0
          => 97 98 99

     elicits a warning if the 'Octave:str-to-num' warning is enabled.  By default, the 'Octave:str-to-num' warning is disabled.

'Octave:undefined-return-values'
     If the 'Octave:undefined-return-values' warning is disabled, print a warning if a function does not define all the values in the return list which are expected.  By default, the 'Octave:undefined-return-values' warning is enabled.

'Octave:variable-switch-label'
     If the 'Octave:variable-switch-label' warning is enabled, Octave will print a warning if a switch label is not a constant or constant expression.  By default, the 'Octave:variable-switch-label' warning is disabled.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
'Octave:abbreviated-property-match'  By default, the 'Octave:abbreviated-property-match' warning is enabled.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
what


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1037
 -- Command: what
 -- Command: what DIR
 -- Function File: w = what (DIR)
     List the Octave specific files in directory DIR.

     If DIR is not specified then the current directory is used.

     If a return argument is requested, the files found are returned in the structure W.  The structure contains the following fields:

     path
          Full path to directory DIR

     m
          Cell array of m-files

     mat
          Cell array of mat files

     mex
          Cell array of mex files

     oct
          Cell array of oct files

     mdl
          Cell array of mdl files

     slx
          Cell array of slx files

     p
          Cell array of p-files

     classes
          Cell array of class directories ('@CLASSNAME/')

     packages
          Cell array of package directories ('+PKGNAME/')

     Compatibility Note: Octave does not support mdl, slx, and p files; nor does it support package directories.  'what' will always return an empty list for these categories.

     See also: which, ls, exist.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
List the Octave specific files in directory DIR.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
xor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3778
 -- Function File: Z = xor (X, Y)
 -- Function File: Z = xor (X1, X2, ...)
     Return the "exclusive or" of X and Y.

     For boolean expressions X and Y, 'xor (X, Y)' is true if and only if one of X or Y is true.  Otherwise, if X and Y are both true or both false, 'xor' returns false.

     The truth table for the xor operation is

                                                                                                                                                                                                                                                                                                                                                                                                                                                                         X                               Y                                                   Z
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         -                               -                                                   -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         0                               0                                                   0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         1                               0                                                   1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         0                               1                                                   1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         1                               1                                                   0

     If more than two arguments are given the xor operation is applied cumulatively from left to right:

          (...((x1 XOR x2) XOR x3) XOR ...)

     See also: and, or, not.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Return the "exclusive or" of X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
zip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 -- Function File: FILELIST = zip (ZIPFILE, FILES)
 -- Function File: FILELIST = zip (ZIPFILE, FILES, ROOTDIR)
     Compress the list of files and directories specified in FILES into the ZIP archive ZIPFILE.

     FILES is a character array or cell array of strings.  Shell wildcards in the filename such as '*' or '?' are accepted and expanded.  Directories are recursively traversed and all files are compressed and added to the archive.

     If ROOTDIR is defined then any files without absolute pathnames are located relative to ROOTDIR rather than the current directory.

     The optional output FILELIST is a list of the files that were included in the archive.

     See also: unzip, unpack, bzip2, gzip, tar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 91
Compress the list of files and directories specified in FILES into the ZIP archive ZIPFILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fminbnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1184
 -- Function File: [X, FVAL, INFO, OUTPUT] = fminbnd (FUN, A, B, OPTIONS)
     Find a minimum point of a univariate function.

     FUN should be a function handle or name.  A, B specify a starting interval.  OPTIONS is a structure specifying additional options.  Currently, 'fminbnd' recognizes these options: "FunValCheck", "OutputFcn", "TolX", "MaxIter", "MaxFunEvals".  For a description of these options, see *note optimset: XREFoptimset.

     On exit, the function returns X, the approximate minimum point and FVAL, the function value thereof.

     INFO is an exit flag that can have these values:

        * 1 The algorithm converged to a solution.

        * 0 Maximum number of iterations or function evaluations has been exhausted.

        * -1 The algorithm has been terminated from user output function.

     Notes: The search for a minimum is restricted to be in the interval bound by A and B.  If you only have an initial point to begin searching from you will need to use an unconstrained minimization algorithm such as 'fminunc' or 'fminsearch'.  'fminbnd' internally uses a Golden Section search strategy.

     See also: fzero, fminunc, fminsearch, optimset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Find a minimum point of a univariate function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
fminsearch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 999
 -- Function File: X = fminsearch (FUN, X0)
 -- Function File: X = fminsearch (FUN, X0, OPTIONS)
 -- Function File: [X, FVAL] = fminsearch (...)

     Find a value of X which minimizes the function FUN.

     The search begins at the point X0 and iterates using the Nelder & Mead Simplex algorithm (a derivative-free method).  This algorithm is better-suited to functions which have discontinuities or for which a gradient-based search such as 'fminunc' fails.

     Options for the search are provided in the parameter OPTIONS using the function 'optimset'.  Currently, 'fminsearch' accepts the options: "TolX", "MaxFunEvals", "MaxIter", "Display".  For a description of these options, see 'optimset'.

     On exit, the function returns X, the minimum point, and FVAL, the function value thereof.

     Example usages:

          fminsearch (@(x) (x(1)-5).^2+(x(2)-8).^4, [0;0])

          fminsearch (inline ("(x(1)-5).^2+(x(2)-8).^4", "x"), [0;0])

     See also: fminbnd, fminunc, optimset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Find a value of X which minimizes the function FUN.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fminunc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2542
 -- Function File: fminunc (FCN, X0)
 -- Function File: fminunc (FCN, X0, OPTIONS)
 -- Function File: [X, FVAL, INFO, OUTPUT, GRAD, HESS] = fminunc (FCN, ...)
     Solve an unconstrained optimization problem defined by the function FCN.

     FCN should accept a vector (array) defining the unknown variables, and return the objective function value, optionally with gradient.  'fminunc' attempts to determine a vector X such that 'FCN (X)' is a local minimum.

     X0 determines a starting guess.  The shape of X0 is preserved in all calls to FCN, but otherwise is treated as a column vector.

     OPTIONS is a structure specifying additional options.  Currently, 'fminunc' recognizes these options: "FunValCheck", "OutputFcn", "TolX", "TolFun", "MaxIter", "MaxFunEvals", "GradObj", "FinDiffType", "TypicalX", "AutoScaling".

     If "GradObj" is "on", it specifies that FCN, when called with 2 output arguments, also returns the Jacobian matrix of partial first derivatives at the requested point.  'TolX' specifies the termination tolerance for the unknown variables X, while 'TolFun' is a tolerance for the objective function value FVAL.  The default is '1e-7' for both options.

     For a description of the other options, see 'optimset'.

     On return, X is the location of the minimum and FVAL contains the value of the objective function at X.

     INFO may be one of the following values:

     1
          Converged to a solution point.  Relative gradient error is less than specified by 'TolFun'.

     2
          Last relative step size was less than 'TolX'.

     3
          Last relative change in function value was less than 'TolFun'.

     0
          Iteration limit exceeded--either maximum number of algorithm iterations 'MaxIter' or maximum number of function evaluations 'MaxFunEvals'.

     -1
          Algorithm terminated by 'OutputFcn'.

     -3
          The trust region radius became excessively small.

     Optionally, 'fminunc' can return a structure with convergence statistics (OUTPUT), the output gradient (GRAD) at the solution X, and approximate Hessian (HESS) at the solution X.

     Application Notes: If have only a single nonlinear equation of one variable then using 'fminbnd' is usually a better choice.

     The algorithm used by 'fminsearch' is a gradient search which depends on the objective function being differentiable.  If the function has discontinuities it may be better to use a derivative-free algorithm such as 'fminsearch'.

     See also: fminbnd, fminsearch, optimset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Solve an unconstrained optimization problem defined by the function FCN.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
fsolve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4353
 -- Function File: fsolve (FCN, X0, OPTIONS)
 -- Function File: [X, FVEC, INFO, OUTPUT, FJAC] = fsolve (FCN, ...)
     Solve a system of nonlinear equations defined by the function FCN.

     FCN should accept a vector (array) defining the unknown variables, and return a vector of left-hand sides of the equations.  Right-hand sides are defined to be zeros.  In other words, this function attempts to determine a vector X such that 'FCN (X)' gives (approximately) all zeros.

     X0 determines a starting guess.  The shape of X0 is preserved in all calls to FCN, but otherwise it is treated as a column vector.

     OPTIONS is a structure specifying additional options.  Currently, 'fsolve' recognizes these options: "FunValCheck", "OutputFcn", "TolX", "TolFun", "MaxIter", "MaxFunEvals", "Jacobian", "Updating", "ComplexEqn" "TypicalX", "AutoScaling" and "FinDiffType".

     If "Jacobian" is "on", it specifies that FCN, called with 2 output arguments also returns the Jacobian matrix of right-hand sides at the requested point.  "TolX" specifies the termination tolerance in the unknown variables, while "TolFun" is a tolerance for equations.  Default is '1e-7' for both "TolX" and "TolFun".

     If "AutoScaling" is on, the variables will be automatically scaled according to the column norms of the (estimated) Jacobian.  As a result, TolF becomes scaling-independent.  By default, this option is off because it may sometimes deliver unexpected (though mathematically correct) results.

     If "Updating" is "on", the function will attempt to use Broyden updates to update the Jacobian, in order to reduce the amount of Jacobian calculations.  If your user function always calculates the Jacobian (regardless of number of output arguments) then this option provides no advantage and should be set to false.

     "ComplexEqn" is "on", 'fsolve' will attempt to solve complex equations in complex variables, assuming that the equations possess a complex derivative (i.e., are holomorphic).  If this is not what you want, you should unpack the real and imaginary parts of the system to get a real system.

     For description of the other options, see 'optimset'.

     On return, FVAL contains the value of the function FCN evaluated at X.

     INFO may be one of the following values:

     1
          Converged to a solution point.  Relative residual error is less than specified by TolFun.

     2
          Last relative step size was less that TolX.

     3
          Last relative decrease in residual was less than TolF.

     0
          Iteration limit exceeded.

     -3
          The trust region radius became excessively small.

     Note: If you only have a single nonlinear equation of one variable, using 'fzero' is usually a much better idea.

     Note about user-supplied Jacobians: As an inherent property of the algorithm, a Jacobian is always requested for a solution vector whose residual vector is already known, and it is the last accepted successful step.  Often this will be one of the last two calls, but not always.  If the savings by reusing intermediate results from residual calculation in Jacobian calculation are significant, the best strategy is to employ OutputFcn: After a vector is evaluated for residuals, if OutputFcn is called with that vector, then the intermediate results should be saved for future Jacobian evaluation, and should be kept until a Jacobian evaluation is requested or until OutputFcn is called with a different vector, in which case they should be dropped in favor of this most recent vector.  A short example how this can be achieved follows:

          function [fvec, fjac] = user_func (x, optimvalues, state)
          persistent sav = [], sav0 = [];
          if (nargin == 1)
            ## evaluation call
            if (nargout == 1)
              sav0.x = x; # mark saved vector
              ## calculate fvec, save results to sav0.
            elseif (nargout == 2)
              ## calculate fjac using sav.
            endif
          else
            ## outputfcn call.
            if (all (x == sav0.x))
              sav = sav0;
            endif
            ## maybe output iteration status, etc.
          endif
          endfunction

          ## ...

          fsolve (@user_func, x0, optimset ("OutputFcn", @user_func, ...))

     See also: fzero, optimset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Solve a system of nonlinear equations defined by the function FCN.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
fzero


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1864
 -- Function File: fzero (FUN, X0)
 -- Function File: fzero (FUN, X0, OPTIONS)
 -- Function File: [X, FVAL, INFO, OUTPUT] = fzero (...)
     Find a zero of a univariate function.

     FUN is a function handle, inline function, or string containing the name of the function to evaluate.

     X0 should be a two-element vector specifying two points which bracket a zero.  In other words, there must be a change in sign of the function between X0(1) and X0(2).  More mathematically, the following must hold

          sign (FUN(X0(1))) * sign (FUN(X0(2))) <= 0

     If X0 is a single scalar then several nearby and distant values are probed in an attempt to obtain a valid bracketing.  If this is not successful, the function fails.

     OPTIONS is a structure specifying additional options.  Currently, 'fzero' recognizes these options: "FunValCheck", "OutputFcn", "TolX", "MaxIter", "MaxFunEvals".  For a description of these options, see *note optimset: XREFoptimset.

     On exit, the function returns X, the approximate zero point and FVAL, the function value thereof.

     INFO is an exit flag that can have these values:

        * 1 The algorithm converged to a solution.

        * 0 Maximum number of iterations or function evaluations has been reached.

        * -1 The algorithm has been terminated from user output function.

        * -5 The algorithm may have converged to a singular point.

     OUTPUT is a structure containing runtime information about the 'fzero' algorithm.  Fields in the structure are:

        * iterations Number of iterations through loop.

        * nfev Number of function evaluations.

        * bracketx A two-element vector with the final bracketing of the zero along the x-axis.

        * brackety A two-element vector with the final bracketing of the zero along the y-axis.

     See also: optimset, fsolve.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Find a zero of a univariate function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
glpk


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11032
 -- Function File: [XOPT, FMIN, ERRNUM, EXTRA] = glpk (C, A, B, LB, UB, CTYPE, VARTYPE, SENSE, PARAM)
     Solve a linear program using the GNU GLPK library.

     Given three arguments, 'glpk' solves the following standard LP:

          min C'*x

     subject to

          A*x  = b
            x >= 0

     but may also solve problems of the form

          [ min | max ] C'*x

     subject to

          A*x [ "=" | "<=" | ">=" ] b
            x >= LB
            x <= UB

     Input arguments:

     C
          A column array containing the objective function coefficients.

     A
          A matrix containing the constraints coefficients.

     B
          A column array containing the right-hand side value for each constraint in the constraint matrix.

     LB
          An array containing the lower bound on each of the variables.  If LB is not supplied, the default lower bound for the variables is zero.

     UB
          An array containing the upper bound on each of the variables.  If UB is not supplied, the default upper bound is assumed to be infinite.

     CTYPE
          An array of characters containing the sense of each constraint in the constraint matrix.  Each element of the array may be one of the following values

          "F"
               A free (unbounded) constraint (the constraint is ignored).

          "U"
               An inequality constraint with an upper bound ('A(i,:)*x <= b(i)').

          "S"
               An equality constraint ('A(i,:)*x = b(i)').

          "L"
               An inequality with a lower bound ('A(i,:)*x >= b(i)').

          "D"
               An inequality constraint with both upper and lower bounds ('A(i,:)*x >= -b(i)') _and_ ('A(i,:)*x <= b(i)').

     VARTYPE
          A column array containing the types of the variables.

          "C"
               A continuous variable.

          "I"
               An integer variable.

     SENSE
          If SENSE is 1, the problem is a minimization.  If SENSE is -1, the problem is a maximization.  The default value is 1.

     PARAM
          A structure containing the following parameters used to define the behavior of solver.  Missing elements in the structure take on default values, so you only need to set the elements that you wish to change from the default.

          Integer parameters:

          'msglev (default: 1)'
               Level of messages output by solver routines:

               0 ('GLP_MSG_OFF')
                    No output.

               1 ('GLP_MSG_ERR')
                    Error and warning messages only.

               2 ('GLP_MSG_ON')
                    Normal output.

               3 ('GLP_MSG_ALL')
                    Full output (includes informational messages).

          'scale (default: 16)'
               Scaling option.  The values can be combined with the bitwise OR operator and may be the following:

               1 ('GLP_SF_GM')
                    Geometric mean scaling.

               16 ('GLP_SF_EQ')
                    Equilibration scaling.

               32 ('GLP_SF_2N')
                    Round scale factors to power of two.

               64 ('GLP_SF_SKIP')
                    Skip if problem is well scaled.

               Alternatively, a value of 128 ('GLP_SF_AUTO') may be also specified, in which case the routine chooses the scaling options automatically.

          'dual (default: 1)'
               Simplex method option:

               1 ('GLP_PRIMAL')
                    Use two-phase primal simplex.

               2 ('GLP_DUALP')
                    Use two-phase dual simplex, and if it fails, switch to the primal simplex.

               3 ('GLP_DUAL')
                    Use two-phase dual simplex.

          'price (default: 34)'
               Pricing option (for both primal and dual simplex):

               17 ('GLP_PT_STD')
                    Textbook pricing.

               34 ('GLP_PT_PSE')
                    Steepest edge pricing.

          'itlim (default: intmax)'
               Simplex iterations limit.  It is decreased by one each time when one simplex iteration has been performed, and reaching zero value signals the solver to stop the search.

          'outfrq (default: 200)'
               Output frequency, in iterations.  This parameter specifies how frequently the solver sends information about the solution to the standard output.

          'branch (default: 4)'
               Branching technique option (for MIP only):

               1 ('GLP_BR_FFV')
                    First fractional variable.

               2 ('GLP_BR_LFV')
                    Last fractional variable.

               3 ('GLP_BR_MFV')
                    Most fractional variable.

               4 ('GLP_BR_DTH')
                    Heuristic by Driebeck and Tomlin.

               5 ('GLP_BR_PCH')
                    Hybrid pseudocost heuristic.

          'btrack (default: 4)'
               Backtracking technique option (for MIP only):

               1 ('GLP_BT_DFS')
                    Depth first search.

               2 ('GLP_BT_BFS')
                    Breadth first search.

               3 ('GLP_BT_BLB')
                    Best local bound.

               4 ('GLP_BT_BPH')
                    Best projection heuristic.

          'presol (default: 1)'
               If this flag is set, the simplex solver uses the built-in LP presolver.  Otherwise the LP presolver is not used.

          'lpsolver (default: 1)'
               Select which solver to use.  If the problem is a MIP problem this flag will be ignored.

               1
                    Revised simplex method.

               2
                    Interior point method.

          'rtest (default: 34)'
               Ratio test technique:

               17 ('GLP_RT_STD')
                    Standard ("textbook").

               34 ('GLP_RT_HAR')
                    Harris' two-pass ratio test.

          'tmlim (default: intmax)'
               Searching time limit, in milliseconds.

          'outdly (default: 0)'
               Output delay, in seconds.  This parameter specifies how long the solver should delay sending information about the solution to the standard output.

          'save (default: 0)'
               If this parameter is nonzero, save a copy of the problem in CPLEX LP format to the file '"outpb.lp"'.  There is currently no way to change the name of the output file.

          Real parameters:

          'tolbnd (default: 1e-7)'
               Relative tolerance used to check if the current basic solution is primal feasible.  It is not recommended that you change this parameter unless you have a detailed understanding of its purpose.

          'toldj (default: 1e-7)'
               Absolute tolerance used to check if the current basic solution is dual feasible.  It is not recommended that you change this parameter unless you have a detailed understanding of its purpose.

          'tolpiv (default: 1e-10)'
               Relative tolerance used to choose eligible pivotal elements of the simplex table.  It is not recommended that you change this parameter unless you have a detailed understanding of its purpose.

          'objll (default: -DBL_MAX)'
               Lower limit of the objective function.  If the objective function reaches this limit and continues decreasing, the solver stops the search.  This parameter is used in the dual simplex method only.

          'objul (default: +DBL_MAX)'
               Upper limit of the objective function.  If the objective function reaches this limit and continues increasing, the solver stops the search.  This parameter is used in the dual simplex only.

          'tolint (default: 1e-5)'
               Relative tolerance used to check if the current basic solution is integer feasible.  It is not recommended that you change this parameter unless you have a detailed understanding of its purpose.

          'tolobj (default: 1e-7)'
               Relative tolerance used to check if the value of the objective function is not better than in the best known integer feasible solution.  It is not recommended that you change this parameter unless you have a detailed understanding of its purpose.

     Output values:

     XOPT
          The optimizer (the value of the decision variables at the optimum).

     FOPT
          The optimum value of the objective function.

     ERRNUM
          Error code.

          0
               No error.

          1 ('GLP_EBADB')
               Invalid basis.

          2 ('GLP_ESING')
               Singular matrix.

          3 ('GLP_ECOND')
               Ill-conditioned matrix.

          4 ('GLP_EBOUND')
               Invalid bounds.

          5 ('GLP_EFAIL')
               Solver failed.

          6 ('GLP_EOBJLL')
               Objective function lower limit reached.

          7 ('GLP_EOBJUL')
               Objective function upper limit reached.

          8 ('GLP_EITLIM')
               Iterations limit exhausted.

          9 ('GLP_ETMLIM')
               Time limit exhausted.

          10 ('GLP_ENOPFS')
               No primal feasible solution.

          11 ('GLP_ENODFS')
               No dual feasible solution.

          12 ('GLP_EROOT')
               Root LP optimum not provided.

          13 ('GLP_ESTOP')
               Search terminated by application.

          14 ('GLP_EMIPGAP')
               Relative MIP gap tolerance reached.

          15 ('GLP_ENOFEAS')
               No primal/dual feasible solution.

          16 ('GLP_ENOCVG')
               No convergence.

          17 ('GLP_EINSTAB')
               Numerical instability.

          18 ('GLP_EDATA')
               Invalid data.

          19 ('GLP_ERANGE')
               Result out of range.

     EXTRA
          A data structure containing the following fields:

          'lambda'
               Dual variables.

          'redcosts'
               Reduced Costs.

          'time'
               Time (in seconds) used for solving LP/MIP problem.

          'status'
               Status of the optimization.

               1 ('GLP_UNDEF')
                    Solution status is undefined.

               2 ('GLP_FEAS')
                    Solution is feasible.

               3 ('GLP_INFEAS')
                    Solution is infeasible.

               4 ('GLP_NOFEAS')
                    Problem has no feasible solution.

               5 ('GLP_OPT')
                    Solution is optimal.

               6 ('GLP_UNBND')
                    Problem has no unbounded solution.

     Example:

          c = [10, 6, 4]';
          A = [ 1, 1, 1;
               10, 4, 5;
                2, 2, 6];
          b = [100, 600, 300]';
          lb = [0, 0, 0]';
          ub = [];
          ctype = "UUU";
          vartype = "CCC";
          s = -1;

          param.msglev = 1;
          param.itlim = 100;

          [xmin, fmin, status, extra] = ...
             glpk (c, A, b, lb, ub, ctype, vartype, s, param);
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Solve a linear program using the GNU GLPK library.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
lsqnonneg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1435
 -- Function File: X = lsqnonneg (C, D)
 -- Function File: X = lsqnonneg (C, D, X0)
 -- Function File: X = lsqnonneg (C, D, X0, OPTIONS)
 -- Function File: [X, RESNORM] = lsqnonneg (...)
 -- Function File: [X, RESNORM, RESIDUAL] = lsqnonneg (...)
 -- Function File: [X, RESNORM, RESIDUAL, EXITFLAG] = lsqnonneg (...)
 -- Function File: [X, RESNORM, RESIDUAL, EXITFLAG, OUTPUT] = lsqnonneg (...)
 -- Function File: [X, RESNORM, RESIDUAL, EXITFLAG, OUTPUT, LAMBDA] = lsqnonneg (...)
     Minimize 'norm (C*X - d)' subject to 'X >= 0'.

     C and D must be real.

     X0 is an optional initial guess for X.

     Currently, 'lsqnonneg' recognizes these options: "MaxIter", "TolX". For a description of these options, see *note optimset: XREFoptimset.

     Outputs:

        * resnorm

          The squared 2-norm of the residual: norm (C*X-D)^2

        * residual

          The residual: D-C*X

        * exitflag

          An indicator of convergence.  0 indicates that the iteration count was exceeded, and therefore convergence was not reached; >0 indicates that the algorithm converged.  (The algorithm is stable and will converge given enough iterations.)

        * output

          A structure with two fields:

             * "algorithm": The algorithm used ("nnls")

             * "iterations": The number of iterations taken.

        * lambda

          Not implemented.

     See also: optimset, pqpnonneg, lscov.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Minimize 'norm (C*X - d)' subject to 'X >= 0'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
optimget


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 342
 -- Function File: optimget (OPTIONS, PARNAME)
 -- Function File: optimget (OPTIONS, PARNAME, DEFAULT)
     Return the specific option PARNAME from the optimization options structure OPTIONS created by 'optimset'.

     If PARNAME is not defined then return DEFAULT if supplied, otherwise return an empty matrix.

     See also: optimset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 105
Return the specific option PARNAME from the optimization options structure OPTIONS created by 'optimset'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
optimset


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3041
 -- Function File: optimset ()
 -- Function File: OPTIONS = optimset ()
 -- Function File: OPTIONS = optimset (PAR, VAL, ...)
 -- Function File: OPTIONS = optimset (OLD, PAR, VAL, ...)
 -- Function File: OPTIONS = optimset (OLD, NEW)
     Create options structure for optimization functions.

     When called without any input or output arguments, 'optimset' prints a list of all valid optimization parameters.

     When called with one output and no inputs, return an options structure with all valid option parameters initialized to '[]'.

     When called with a list of parameter/value pairs, return an options structure with only the named parameters initialized.

     When the first input is an existing options structure OLD, the values are updated from either the PAR/VAL list or from the options structure NEW.

     Valid parameters are:

     AutoScaling

     ComplexEqn

     Display
          Request verbose display of results from optimizations.  Values are:

          "off" [default]
               No display.

          "iter"
               Display intermediate results for every loop iteration.

          "final"
               Display the result of the final loop iteration.

          "notify"
               Display the result of the final loop iteration if the function has failed to converge.

     FinDiffType

     FunValCheck
          When enabled, display an error if the objective function returns an invalid value (a complex number, NaN, or Inf).  Must be set to "on" or "off" [default].  Note: the functions 'fzero' and 'fminbnd' correctly handle Inf values and only complex values or NaN will cause an error in this case.

     GradObj
          When set to "on", the function to be minimized must return a second argument which is the gradient, or first derivative, of the function at the point X.  If set to "off" [default], the gradient is computed via finite differences.

     Jacobian
          When set to "on", the function to be minimized must return a second argument which is the Jacobian, or first derivative, of the function at the point X.  If set to "off" [default], the Jacobian is computed via finite differences.

     MaxFunEvals
          Maximum number of function evaluations before optimization stops.  Must be a positive integer.

     MaxIter
          Maximum number of algorithm iterations before optimization stops.  Must be a positive integer.

     OutputFcn
          A user-defined function executed once per algorithm iteration.

     TolFun
          Termination criterion for the function output.  If the difference in the calculated objective function between one algorithm iteration and the next is less than 'TolFun' the optimization stops.  Must be a positive scalar.

     TolX
          Termination criterion for the function input.  If the difference in X, the current search point, between one algorithm iteration and the next is less than 'TolX' the optimization stops.  Must be a positive scalar.

     TypicalX

     Updating

     See also: optimget.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Create options structure for optimization functions.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
pqpnonneg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1152
 -- Function File: X = pqpnonneg (C, D)
 -- Function File: X = pqpnonneg (C, D, X0)
 -- Function File: [X, MINVAL] = pqpnonneg (...)
 -- Function File: [X, MINVAL, EXITFLAG] = pqpnonneg (...)
 -- Function File: [X, MINVAL, EXITFLAG, OUTPUT] = pqpnonneg (...)
 -- Function File: [X, MINVAL, EXITFLAG, OUTPUT, LAMBDA] = pqpnonneg (...)
     Minimize '1/2*x'*c*x + d'*x' subject to 'X >= 0'.

     C ## and D must be real, and C must be symmetric and positive definite.

     X0 is an optional initial guess for X.

     Outputs:

        * minval

          The minimum attained model value, 1/2*xmin'*c*xmin + d'*xmin

        * exitflag

          An indicator of convergence.  0 indicates that the iteration count was exceeded, and therefore convergence was not reached; >0 indicates that the algorithm converged.  (The algorithm is stable and will converge given enough iterations.)

        * output

          A structure with two fields:

             * "algorithm": The algorithm used ("nnls")

             * "iterations": The number of iterations taken.

        * lambda

          Not implemented.

     See also: optimset, lsqnonneg, qp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Minimize '1/2*x'*c*x + d'*x' subject to 'X >= 0'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2
qp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1873
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (X0, H)
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (X0, H, Q)
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (X0, H, Q, A, B)
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (X0, H, Q, A, B, LB, UB)
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (X0, H, Q, A, B, LB, UB, A_LB, A_IN, A_UB)
 -- Function File: [X, OBJ, INFO, LAMBDA] = qp (..., OPTIONS)
     Solve a quadratic program (QP).

     Solve the quadratic program defined by

          min 0.5 x'*H*x + x'*q
           x

     subject to

          A*x = b
          lb <= x <= ub
          A_lb <= A_in*x <= A_ub

     using a null-space active-set method.

     Any bound (A, B, LB, UB, A_LB, A_UB) may be set to the empty matrix ('[]') if not present.  If the initial guess is feasible the algorithm is faster.

     OPTIONS
          An optional structure containing the following parameter(s) used to define the behavior of the solver.  Missing elements in the structure take on default values, so you only need to set the elements that you wish to change from the default.

          'MaxIter (default: 200)'
               Maximum number of iterations.

     INFO
          Structure containing run-time information about the algorithm.  The following fields are defined:

          'solveiter'
               The number of iterations required to find the solution.

          'info'
               An integer indicating the status of the solution.

               0
                    The problem is feasible and convex.  Global solution found.

               1
                    The problem is not convex.  Local solution found.

               2
                    The problem is not convex and unbounded.

               3
                    Maximum number of iterations reached.

               6
                    The problem is infeasible.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Solve a quadratic program (QP).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
sqp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4175
 -- Function File: [X, OBJ, INFO, ITER, NF, LAMBDA] = sqp (X0, PHI)
 -- Function File: [...] = sqp (X0, PHI, G)
 -- Function File: [...] = sqp (X0, PHI, G, H)
 -- Function File: [...] = sqp (X0, PHI, G, H, LB, UB)
 -- Function File: [...] = sqp (X0, PHI, G, H, LB, UB, MAXITER)
 -- Function File: [...] = sqp (X0, PHI, G, H, LB, UB, MAXITER, TOL)
     Minimize an objective function using sequential quadratic programming (SQP).

     Solve the nonlinear program

          min phi (x)
           x

     subject to

          g(x)  = 0
          h(x) >= 0
          lb <= x <= ub

     using a sequential quadratic programming method.

     The first argument is the initial guess for the vector X0.

     The second argument is a function handle pointing to the objective function PHI.  The objective function must accept one vector argument and return a scalar.

     The second argument may also be a 2- or 3-element cell array of function handles.  The first element should point to the objective function, the second should point to a function that computes the gradient of the objective function, and the third should point to a function that computes the Hessian of the objective function.  If the gradient function is not supplied, the gradient is computed by finite differences.  If the Hessian function is not supplied, a BFGS update formula is used to approximate the Hessian.

     When supplied, the gradient function 'PHI{2}' must accept one vector argument and return a vector.  When supplied, the Hessian function 'PHI{3}' must accept one vector argument and return a matrix.

     The third and fourth arguments G and H are function handles pointing to functions that compute the equality constraints and the inequality constraints, respectively.  If the problem does not have equality (or inequality) constraints, then use an empty matrix ([]) for G (or H).  When supplied, these equality and inequality constraint functions must accept one vector argument and return a vector.

     The third and fourth arguments may also be 2-element cell arrays of function handles.  The first element should point to the constraint function and the second should point to a function that computes the gradient of the constraint function:

                      [ d f(x)   d f(x)        d f(x) ]
          transpose ( [ ------   -----   ...   ------ ] )
                      [  dx_1     dx_2          dx_N  ]

     The fifth and sixth arguments, LB and UB, contain lower and upper bounds on X.  These must be consistent with the equality and inequality constraints G and H.  If the arguments are vectors then X(i) is bound by LB(i) and UB(i).  A bound can also be a scalar in which case all elements of X will share the same bound.  If only one bound (lb, ub) is specified then the other will default to (-REALMAX, +REALMAX).

     The seventh argument MAXITER specifies the maximum number of iterations.  The default value is 100.

     The eighth argument TOL specifies the tolerance for the stopping criteria.  The default value is 'sqrt (eps)'.

     The value returned in INFO may be one of the following:

     101
          The algorithm terminated normally.  All constraints meet the specified tolerance.

     102
          The BFGS update failed.

     103
          The maximum number of iterations was reached.

     104
          The stepsize has become too small, i.e., delta X, is less than 'TOL * norm (x)'.

     An example of calling 'sqp':

          function r = g (x)
            r = [ sumsq(x)-10;
                  x(2)*x(3)-5*x(4)*x(5);
                  x(1)^3+x(2)^3+1 ];
          endfunction

          function obj = phi (x)
            obj = exp (prod (x)) - 0.5*(x(1)^3+x(2)^3+1)^2;
          endfunction

          x0 = [-1.8; 1.7; 1.9; -0.8; -0.8];

          [x, obj, info, iter, nf, lambda] = sqp (x0, @phi, @g, [])

          x =

            -1.71714
             1.59571
             1.82725
            -0.76364
            -0.76364

          obj = 0.053950
          info = 101
          iter = 8
          nf = 10
          lambda =

            -0.0401627
             0.0379578
            -0.0052227

     See also: qp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Minimize an objective function using sequential quadratic programming (SQP).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
matlabroot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 216
 -- Function File: matlabroot ()
     Return the name of the top-level Octave installation directory.

     This is an alias for the function 'OCTAVE_HOME' provided for compatibility.

     See also: OCTAVE_HOME.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Return the name of the top-level Octave installation directory.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
pathdef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 428
 -- Function File: VAL = pathdef ()
     Return the default path for Octave.

     The path information is extracted from one of four sources.  The possible sources, in order of preference, are:

       1. '.octaverc'

       2. '~/.octaverc'

       3. '<OCTAVE_HOME>/.../<version>/m/startup/octaverc'

       4. Octave's path prior to changes by any octaverc file.

     See also: path, addpath, rmpath, genpath, savepath.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Return the default path for Octave.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
savepath


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 985
 -- Function File: savepath ()
 -- Function File: savepath (FILE)
 -- Function File: STATUS = savepath (...)
     Save the unique portion of the current function search path that is not set during Octave's initialization process to FILE.

     If FILE is omitted, Octave looks in the current directory for a project-specific '.octaverc' file in which to save the path information.  If no such file is present then the user's configuration file '~/.octaverc' is used.

     If successful, 'savepath' returns 0.

     The 'savepath' function makes it simple to customize a user's configuration file to restore the working paths necessary for a particular instance of Octave.  Assuming no filename is specified, Octave will automatically restore the saved directory paths from the appropriate '.octaverc' file when starting up.  If a filename has been specified then the paths may be restored manually by calling 'source FILE'.

     See also: path, addpath, rmpath, genpath, pathdef.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
Save the unique portion of the current function search path that is not set during Octave's initialization process to FILE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
pkg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7061
 -- Command: pkg COMMAND PKG_NAME
 -- Command: pkg COMMAND OPTION PKG_NAME
     Manage packages (groups of add-on functions) for Octave.

     Different actions are available depending on the value of COMMAND.

     Available commands:

     'install'
          Install named packages.  For example,

               pkg install image-1.0.0.tar.gz

          installs the package found in the file 'image-1.0.0.tar.gz'.

          The OPTION variable can contain options that affect the manner in which a package is installed.  These options can be one or more of

          '-nodeps'
               The package manager will disable dependency checking.  With this option it is possible to install a package even when it depends on another package which is not installed on the system.  *Use this option with care.*

          '-noauto'
               The package manager will not automatically load the installed package when starting Octave.  This overrides any setting within the package.

          '-auto'
               The package manager will automatically load the installed package when starting Octave.  This overrides any setting within the package.

          '-local'
               A local installation (package available only to current user) is forced, even if the user has system privileges.

          '-global'
               A global installation (package available to all users) is forced, even if the user doesn't normally have system privileges.

          '-forge'
               Install a package directly from the Octave-Forge repository.  This requires an internet connection and the cURL library.

          '-verbose'
               The package manager will print the output of all commands as they are performed.

     'update'
          Check installed Octave-Forge packages against repository and update any outdated items.  This requires an internet connection and the cURL library.  Usage:

               pkg update

     'uninstall'
          Uninstall named packages.  For example,

               pkg uninstall image

          removes the 'image' package from the system.  If another installed package depends on the 'image' package an error will be issued.  The package can be uninstalled anyway by using the '-nodeps' option.

     'load'
          Add named packages to the path.  After loading a package it is possible to use the functions provided by the package.  For example,

               pkg load image

          adds the 'image' package to the path.  It is possible to load all installed packages at once with the keyword 'all'.  Usage:

               pkg load all

     'unload'
          Remove named packages from the path.  After unloading a package it is no longer possible to use the functions provided by the package.  It is possible to unload all installed packages at once with the keyword 'all'.  Usage:

               pkg unload all

     'list'
          Show the list of currently installed packages.  For example,

               pkg list

          will produce a short report with the package name, version, and installation directory for each installed package.  Supply a package name to limit reporting to a particular package.  For example:

               pkg list image

          If a single return argument is requested then 'pkg' returns a cell array where each element is a structure with information on a single package.

               installed_packages = pkg ("list")

          If two output arguments are requested 'pkg' splits the list of installed packages into those which were installed by the current user, and those which were installed by the system administrator.

               [user_packages, system_packages] = pkg ("list")

          The "-forge" option lists packages available at the Octave-Forge repository.  This requires an internet connection and the cURL library.  For example:

               oct_forge_pkgs = pkg ("list", "-forge")

     'describe'
          Show a short description of the named installed packages, with the option "-verbose" also list functions provided by the package.  For example,

               pkg describe -verbose all

          will describe all installed packages and the functions they provide.  If one output is requested a cell of structure containing the description and list of functions of each package is returned as output rather than printed on screen:

               desc = pkg ("describe", "secs1d", "image")

          If any of the requested packages is not installed, 'pkg' returns an error, unless a second output is requested:

               [desc, flag] = pkg ("describe", "secs1d", "image")

          FLAG will take one of the values "Not installed", "Loaded", or "Not loaded" for each of the named packages.

     'prefix'
          Set the installation prefix directory.  For example,

               pkg prefix ~/my_octave_packages

          sets the installation prefix to '~/my_octave_packages'.  Packages will be installed in this directory.

          It is possible to get the current installation prefix by requesting an output argument.  For example:

               pfx = pkg ("prefix")

          The location in which to install the architecture dependent files can be independently specified with an addition argument.  For example:

               pkg prefix ~/my_octave_packages ~/my_arch_dep_pkgs

     'local_list'
          Set the file in which to look for information on locally installed packages.  Locally installed packages are those that are available only to the current user.  For example:

               pkg local_list ~/.octave_packages

          It is possible to get the current value of local_list with the following

               pkg local_list

     'global_list'
          Set the file in which to look for information on globally installed packages.  Globally installed packages are those that are available to all users.  For example:

               pkg global_list /usr/share/octave/octave_packages

          It is possible to get the current value of global_list with the following

               pkg global_list

     'build'
          Build a binary form of a package or packages.  The binary file produced will itself be an Octave package that can be installed normally with 'pkg'.  The form of the command to build a binary package is

               pkg build builddir image-1.0.0.tar.gz ...

          where 'builddir' is the name of a directory where the temporary installation will be produced and the binary packages will be found.  The options '-verbose' and '-nodeps' are respected, while all other options are ignored.

     'rebuild'
          Rebuild the package database from the installed directories.  This can be used in cases where the package database has been corrupted.  It can also take the '-auto' and '-noauto' options to allow the autoloading state of a package to be changed.  For example,

               pkg rebuild -noauto image

          will remove the autoloading status of the image package.

     See also: ver, news.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Manage packages (groups of add-on functions) for Octave.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
annotation


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4819
 -- Function File: annotation (TYPE)
 -- Function File: annotation ("line", X, Y)
 -- Function File: annotation ("arrow", X, Y)
 -- Function File: annotation ("doublearrow", X, Y)
 -- Function File: annotation ("textarrow", X, Y)
 -- Function File: annotation ("textbox", POS)
 -- Function File: annotation ("rectangle", POS)
 -- Function File: annotation ("ellipse", POS)
 -- Function File: annotation (..., PROP, VAL)
 -- Function File: annotation (HF, ...)
 -- Function File: H = annotation (...)
     Draw annotations to emphasize parts of a figure.

     You may build a default annotation by specifying only the TYPE of the annotation.

     Otherwise you can select the type of annotation and then set its position using either X and Y coordinates for line-based annotations or a position vector POS for others.  In either case, coordinates are interpreted using the "units" property of the annotation object.  The default is "normalized", which means the lower left hand corner of the figure has coordinates '[0 0]' and the upper right hand corner '[1 1]'.

     If the first argument HF is a figure handle, then plot into this figure, rather than the current figure returned by 'gcf'.

     Further arguments can be provided in the form of PROP/VAL pairs to customize the annotation appearance.

     The optional return value H is a graphics handle to the created annotation object.  This can be used with the 'set' function to customize an existing annotation object.

     All annotation objects share two properties:

        * "units": the units in which coordinates are interpreted.
          Its value may be one of "centimeters" | "characters" | "inches" | "{normalized}" | "pixels" | "points".

        * "position": a four-element vector [x0 y0 width height].
          The vector specifies the coordinates (x0,y0) of the origin of the annotation object, its width, and its height.  The width and height may be negative, depending on the orientation of the object.

     Valid annotation types and their specific properties are described below:

     "line"
          Constructs a line.  X and Y must be two-element vectors specifying the x and y coordinates of the two ends of the line.

          The line can be customized using "linewidth", "linestyle", and "color" properties the same way as for 'line' objects.

     "arrow"
          Construct an arrow.  The second point in vectors X and Y specifies the arrowhead coordinates.

          Besides line properties, the arrowhead can be customized using "headlength", "headwidth", and "headstyle" properties.  Supported values for "headstyle" property are: ["diamond" | "ellipse" | "plain" | "rectangle" | "vback1" | "{vback2}" | "vback3"]

     "doublearrow"
          Construct a double arrow.  Vectors X and Y specify the arrowhead coordinates.

          The line and the arrowhead can be customized as for arrow annotations, but some property names are duplicated: "head1length"/"head2length", "head1width"/"head2width", etc.  The index 1 marks the properties of the arrowhead at the first point in X and Y coordinates.

     "textarrow"
          Construct an arrow with a text label at the opposite end from the arrowhead.

          Use the "string" property to change the text string.  The line and the arrowhead can be customized as for arrow annotations, and the text can be customized using the same properties as 'text' graphics objects.  Note, however, that some text property names are prefixed with "text" to distinguish them from arrow properties: "textbackgroundcolor", "textcolor", "textedgecolor", "textlinewidth", "textmargin", "textrotation".

     "textbox"
          Construct a box with text inside.  POS specifies the "position" property of the annotation.

          Use the "string" property to change the text string.  You may use "backgroundcolor", "edgecolor", "linestyle", and "linewidth" properties to customize the box background color and edge appearance.  A limited set of 'text' objects properties are also available; Besides "font..." properties, you may also use "horizontalalignment" and "verticalalignment" to position the text inside the box.

          Finally, the "fitboxtotext" property controls the actual extent of the box.  If "on" (the default) the box limits are fitted to the text extent.

     "rectangle"
          Construct a rectangle.  POS specifies the "position" property of the annotation.

          You may use "facecolor", "color", "linestyle", and "linewidth" properties to customize the rectangle background color and edge appearance.

     "ellipse"
          Construct an ellipse.  POS specifies the "position" property of the annotation.

          See "rectangle" annotations for customization.

     See also: xlabel, ylabel, zlabel, title, text, gtext, legend, colorbar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Draw annotations to emphasize parts of a figure.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
axis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2831
 -- Function File: axis ()
 -- Function File: axis ([X_lo X_hi])
 -- Function File: axis ([X_lo X_hi Y_lo Y_hi])
 -- Function File: axis ([X_lo X_hi Y_lo Y_hi Z_lo Z_hi])
 -- Function File: axis (OPTION)
 -- Function File: axis (..., OPTION)
 -- Function File: axis (HAX, ...)
 -- Function File: LIMITS = axis ()
     Set axis limits and appearance.

     The argument LIMITS should be a 2-, 4-, or 6-element vector.  The first and second elements specify the lower and upper limits for the x-axis.  The third and fourth specify the limits for the y-axis, and the fifth and sixth specify the limits for the z-axis.  The special values -Inf and Inf may be used to indicate that the limit should automatically be computed based on the data in the axis.

     Without any arguments, 'axis' turns autoscaling on.

     With one output argument, 'LIMITS = axis' returns the current axis limits.

     The vector argument specifying limits is optional, and additional string arguments may be used to specify various axis properties.  For example,

          axis ([1, 2, 3, 4], "square");

     forces a square aspect ratio, and

          axis ("tic", "labely");

     turns tic marks on for all axes and tic mark labels on for the y-axis only.

     The following options control the aspect ratio of the axes.

     "square"
          Force a square aspect ratio.

     "equal"
          Force x distance to equal y-distance.

     "normal"
          Restore default aspect ratio.

     The following options control the way axis limits are interpreted.

     "auto"
          Set the specified axes to have nice limits around the data or all if no axes are specified.

     "manual"
          Fix the current axes limits.

     "tight"
          Fix axes to the limits of the data.

     "image"
          Equivalent to "tight" and "equal".

     The following options affect the appearance of tic marks.

     "on"
          Turn tic marks and labels on for all axes.

     "off"
          Turn tic marks off for all axes.

     "tic[xyz]"
          Turn tic marks on for all axes, or turn them on for the specified axes and off for the remainder.

     "label[xyz]"
          Turn tic labels on for all axes, or turn them on for the specified axes and off for the remainder.

     "nolabel"
          Turn tic labels off for all axes.

     Note, if there are no tic marks for an axis, there can be no labels.

     The following options affect the direction of increasing values on the axes.

     "ij"
          Reverse y-axis, so lower values are nearer the top.

     "xy"
          Restore y-axis, so higher values are nearer the top.

     If the first argument HAX is an axes handle, then operate on this axes rather than the current axes returned by 'gca'.

     See also: xlim, ylim, zlim, daspect, pbaspect, box, grid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Set axis limits and appearance.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
box


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 390
 -- Command: box
 -- Command: box on
 -- Command: box off
 -- Function File: box (HAX, ...)
     Control display of the axis border.

     The argument may be either "on" or "off".  If it is omitted, the current box state is toggled.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     See also: axis, grid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Control display of the axis border.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
caxis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1008
 -- Function File: caxis ([cmin cmax])
 -- Function File: caxis ("auto")
 -- Function File: caxis ("manual")
 -- Function File: caxis (HAX, ...)
 -- Function File: LIMITS = caxis ()
     Query or set color axis limits for plots.

     The limits argument should be a 2-element vector specifying the lower and upper limits to assign to the first and last value in the colormap.  Data values outside this range are clamped to the first and last colormap entries.

     If the "auto" option is given then automatic colormap limits are applied.  The automatic algorithm sets CMIN to the minimum data value and CMAX to the maximum data value.  If "manual" is specified then the "climmode" property is set to "manual" and the numeric values in the "clim" property are used for limits.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     Called without arguments the current color axis limits are returned.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Query or set color axis limits for plots.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
clabel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1652
 -- Function File: clabel (C, H)
 -- Function File: clabel (C, H, V)
 -- Function File: clabel (C, H, "manual")
 -- Function File: clabel (C)
 -- Function File: clabel (..., PROP, VAL, ...)
 -- Function File: H = clabel (...)
     Add labels to the contours of a contour plot.

     The contour levels are specified by the contour matrix C which is returned by 'contour', 'contourc', 'contourf', and 'contour3'.  Contour labels are rotated to match the local line orientation and centered on the line.  The position of labels along the contour line is chosen randomly.

     If the argument H is a handle to a contour group object, then label this plot rather than the one in the current axes returned by 'gca'.

     By default, all contours are labeled.  However, the contours to label can be specified by the vector V.  If the "manual" argument is given then the contours to label can be selected with the mouse.

     Additional property/value pairs that are valid properties of text objects can be given and are passed to the underlying text objects.  Moreover, the contour group property "LabelSpacing" is available which determines the spacing between labels on a contour to be specified.  The default is 144 points, or 2 inches.

     The optional return value H is a vector of graphics handles to the text objects representing each label.  The "userdata" property of the text objects contains the numerical value of the contour label.

     An example of the use of 'clabel' is

          [c, h] = contour (peaks (), -4 : 6);
          clabel (c, h, -4:2:6, "fontsize", 12);

     See also: contour, contourf, contour3, meshc, surfc, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Add labels to the contours of a contour plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
daspect


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 753
 -- Function File: DATA_ASPECT_RATIO = daspect ()
 -- Function File: daspect (DATA_ASPECT_RATIO)
 -- Function File: daspect (MODE)
 -- Function File: DATA_ASPECT_RATIO_MODE = daspect ("mode")
 -- Function File: daspect (HAX, ...)
     Query or set the data aspect ratio of the current axes.

     The aspect ratio is a normalized 3-element vector representing the span of the x, y, and z-axis limits.

     'daspect (MODE)'

     Set the data aspect ratio mode of the current axes.  MODE is either "auto" or "manual".

     'daspect ("mode")'

     Return the data aspect ratio mode of the current axes.

     'daspect (HAX, ...)'

     Operate on the axes in handle HAX instead of the current axes.

     See also: axis, pbaspect, xlim, ylim, zlim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Query or set the data aspect ratio of the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
datetick


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 600
 -- Function File: datetick ()
 -- Function File: datetick (FORM)
 -- Function File: datetick (AXIS, FORM)
 -- Function File: datetick (..., "keeplimits")
 -- Function File: datetick (..., "keepticks")
 -- Function File: datetick (HAX, ...)
     Add date formatted tick labels to an axis.

     The axis to apply the ticks to is determined by AXIS which can take the values "x", "y", or "z".  The default value is "x".

     The formatting of the labels is determined by the variable FORM, which can either be a string or positive integer that 'datestr' accepts.

     See also: datenum, datestr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Add date formatted tick labels to an axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
diffuse


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 335
 -- Function File: diffuse (SX, SY, SZ, LV)
     Calculate the diffuse reflection strength of a surface defined by the normal vector elements SX, SY, SZ.

     The light source location vector LV can be given as a 2-element vector [azimuth, elevation] in degrees or as a 3-element vector [x, y, z].

     See also: specular, surfl.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 104
Calculate the diffuse reflection strength of a surface defined by the normal vector elements SX, SY, SZ.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
grid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 734
 -- Command: grid
 -- Command: grid on
 -- Command: grid off
 -- Command: grid minor
 -- Command: grid minor on
 -- Command: grid minor off
 -- Function File: grid (HAX, ...)
     Control the display of plot grid lines.

     The function state input may be either "on" or "off".  If it is omitted, the current grid state is toggled.

     When the first argument is "minor" all subsequent commands modify the minor grid rather than the major grid.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     To control the grid lines for an individual axis use the 'set' function.  For example:

          set (gca, "ygrid", "on");

     See also: axis, box.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Control the display of plot grid lines.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gtext


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 726
 -- Function File: gtext (S)
 -- Function File: gtext ({S1, S2, ...})
 -- Function File: gtext ({S1; S2; ...})
 -- Function File: gtext (..., PROP, VAL, ...)
 -- Function File: H = gtext (...)
     Place text on the current figure using the mouse.

     The text is defined by the string S.  If S is a cell string organized as a row vector then each string of the cell array is written to a separate line.  If S is organized as a column vector then one string element of the cell array is placed for every mouse click.

     Optional property/value pairs are passed directly to the underlying text objects.

     The optional return value H is a graphics handle to the created text object(s).

     See also: ginput, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Place text on the current figure using the mouse.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
hidden


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 787
 -- Command: hidden
 -- Command: hidden on
 -- Command: hidden off
 -- Function File: MODE = hidden (...)
     Control mesh hidden line removal.

     When called with no argument the hidden line removal state is toggled.

     When called with one of the modes "on" or "off" the state is set accordingly.

     The optional output argument MODE is the current state.

     Hidden Line Removal determines what graphic objects behind a mesh plot are visible.  The default is for the mesh to be opaque and lines behind the mesh are not visible.  If hidden line removal is turned off then objects behind the mesh can be seen through the faces (openings) of the mesh, although the mesh grid lines are still opaque.

     See also: mesh, meshc, meshz, ezmesh, ezmeshc, trimesh, waterfall.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Control mesh hidden line removal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
legend


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5893
 -- Function File: legend (STR1, STR2, ...)
 -- Function File: legend (MATSTR)
 -- Function File: legend (CELLSTR)
 -- Function File: legend (..., "location", POS)
 -- Function File: legend (..., "orientation", ORIENT)
 -- Function File: legend (HAX, ...)
 -- Function File: legend (HOBJS, ...)
 -- Function File: legend (HAX, HOBJS, ...)
 -- Function File: legend ("OPTION")
 -- Function File: [HLEG, HLEG_OBJ, HPLOT, LABELS] = legend (...)

     Display a legend for the current axes using the specified strings as labels.

     Legend entries may be specified as individual character string arguments, a character array, or a cell array of character strings.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.  If the handles, HOBJS, are not specified then the legend's strings will be associated with the axes' descendants.  'legend' works on line graphs, bar graphs, etc.  A plot must exist before legend is called.

     The optional parameter POS specifies the location of the legend as follows:

                                                                   pos                                                                                                                                             location of the legend
     ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                                                                   north                                                                                                                                           center top
                                                                   south                                                                                                                                           center bottom
                                                                   east                                                                                                                                            right center
                                                                   west                                                                                                                                            left center
                                                                   northeast                                                                                                                                       right top (default)
                                                                   northwest                                                                                                                                       left top
                                                                   southeast                                                                                                                                       right bottom
                                                                   southwest                                                                                                                                       left bottom
                                                                   outside                                                                                                                                         can be appended to any location string

     The optional parameter ORIENT determines if the key elements are placed vertically or horizontally.  The allowed values are "vertical" (default) or "horizontal".

     The following customizations are available using OPTION:

     "show"
          Show legend on the plot

     "hide"
          Hide legend on the plot

     "toggle"
          Toggles between "hide" and "show"

     "boxon"
          Show a box around legend (default)

     "boxoff"
          Hide the box around legend

     "right"
          Place label text to the right of the keys (default)

     "left"
          Place label text to the left of the keys

     "off"
          Delete the legend object

     The optional output values are

     HLEG
          The graphics handle of the legend object.

     HLEG_OBJ
          Graphics handles to the text and line objects which make up the legend.

     HPLOT
          Graphics handles to the plot objects which were used in making the legend.

     LABELS
          A cell array of strings of the labels in the legend.

     The legend label text is either provided in the call to 'legend' or is taken from the DisplayName property of graphics objects.  If no labels or DisplayNames are available, then the label text is simply "data1", "data2", ..., "dataN".

     Implementation Note: A legend is implemented as an additional axes object of the current figure with the "tag" set to "legend".  Properties of the legend object may be manipulated directly by using 'set'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Display a legend for the current axes using the specified strings as labels.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
orient


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1014
 -- Function File: orient (ORIENTATION)
 -- Function File: orient (HFIG, ORIENTATION)
 -- Function File: ORIENTATION = orient ()
 -- Function File: ORIENTATION = orient (HFIG)
     Query or set the print orientation for figure HFIG.

     Valid values for ORIENTATION are "portrait", "landscape", and "tall".

     The "landscape" option changes the orientation so the plot width is larger than the plot height.  The "paperposition" is also modified so that the plot fills the page, while leaving a 0.25 inch border.

     The "tall" option sets the orientation to "portrait" and fills the page with the plot, while leaving a 0.25 inch border.

     The "portrait" option (default) changes the orientation so the plot height is larger than the plot width.  It also restores the default "paperposition" property.

     When called with no arguments, return the current print orientation.

     If the argument HFIG is omitted, then operate on the current figure returned by 'gcf'.

     See also: print, saveas.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Query or set the print orientation for figure HFIG.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
pbaspect


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 790
 -- Function File: PLOT_BOX_ASPECT_RATIO = pbaspect ( )
 -- Function File: pbaspect (PLOT_BOX_ASPECT_RATIO)
 -- Function File: pbaspect (MODE)
 -- Function File: PLOT_BOX_ASPECT_RATIO_MODE = pbaspect ("mode")
 -- Function File: pbaspect (HAX, ...)

     Query or set the plot box aspect ratio of the current axes.

     The aspect ratio is a normalized 3-element vector representing the rendered lengths of the x, y, and z axes.

     'pbaspect(MODE)'

     Set the plot box aspect ratio mode of the current axes.  MODE is either "auto" or "manual".

     'pbaspect ("mode")'

     Return the plot box aspect ratio mode of the current axes.

     'pbaspect (HAX, ...)'

     Operate on the axes in handle HAX instead of the current axes.

     See also: axis, daspect, xlim, ylim, zlim.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Query or set the plot box aspect ratio of the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
shading


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 603
 -- Function File: shading (TYPE)
 -- Function File: shading (HAX, TYPE)
     Set the shading of patch or surface graphic objects.

     Valid arguments for TYPE are

     "flat"
          Single colored patches with invisible edges.

     "faceted"
          Single colored patches with visible edges.

     "interp"
          Color between patch vertices are interpolated and the patch edges are invisible.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: fill, mesh, patch, pcolor, surf, surface, hidden.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Set the shading of patch or surface graphic objects.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
specular


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 623
 -- Function File: specular (SX, SY, SZ, LV, VV)
 -- Function File: specular (SX, SY, SZ, LV, VV, SE)
     Calculate the specular reflection strength of a surface defined by the normal vector elements SX, SY, SZ using Phong's approximation.

     The light source location and viewer location vectors are specified using parameters LV and VV respectively.  The location vectors can given as 2-element vectors [azimuth, elevation] in degrees or as 3-element vectors [x, y, z].

     An optional sixth argument specifies the specular exponent (spread) SE.  If not given, SE defaults to 10.

     See also: diffuse, surfl.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
Calculate the specular reflection strength of a surface defined by the normal vector elements SX, SY, SZ using Phong's approximation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
text


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 641
 -- Function File: text (X, Y, STRING)
 -- Function File: text (X, Y, Z, STRING)
 -- Function File: text (..., PROP, VAL, ...)
 -- Function File: H = text (...)
     Create a text object with text STRING at position X, Y, (Z) on the current axes.

     Multiple locations can be specified if X, Y, (Z) are vectors.  Multiple strings can be specified with a character matrix or a cell array of strings.

     Optional property/value pairs may be used to control the appearance of the text.

     The optional return value H is a vector of graphics handles to the created text objects.

     See also: gtext, title, xlabel, ylabel, zlabel.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Create a text object with text STRING at position X, Y, (Z) on the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
title


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 592
 -- Function File: title (STRING)
 -- Function File: title (STRING, PROP, VAL, ...)
 -- Function File: title (HAX, ...)
 -- Function File: H = title (...)
     Specify the string used as a title for the current axis.

     An optional list of PROPERTY/VALUE pairs can be used to change the appearance of the created title text object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created text object.

     See also: xlabel, ylabel, zlabel, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Specify the string used as a title for the current axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
view


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 932
 -- Function File: view (AZIMUTH, ELEVATION)
 -- Function File: view ([AZIMUTH ELEVATION])
 -- Function File: view ([X Y Z])
 -- Function File: view (2)
 -- Function File: view (3)
 -- Function File: view (HAX, ...)
 -- Function File: [AZIMUTH, ELEVATION] = view ()
     Query or set the viewpoint for the current axes.

     The parameters AZIMUTH and ELEVATION can be given as two arguments or as 2-element vector.  The viewpoint can also be specified with Cartesian coordinates X, Y, and Z.

     The call 'view (2)' sets the viewpoint to AZIMUTH = 0 and ELEVATION = 90, which is the default for 2-D graphs.

     The call 'view (3)' sets the viewpoint to AZIMUTH = -37.5 and ELEVATION = 30, which is the default for 3-D graphs.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     If no inputs are given, return the current AZIMUTH and ELEVATION.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Query or set the viewpoint for the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
whitebg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 775
 -- Function File: whitebg ()
 -- Function File: whitebg (COLOR)
 -- Function File: whitebg ("none")
 -- Function File: whitebg (HFIG, ...)
     Invert the colors in the current color scheme.

     The root properties are also inverted such that all subsequent plot use the new color scheme.

     If the optional argument COLOR is present then the background color is set to COLOR rather than inverted.  COLOR may be a string representing one of the eight known colors or an RGB triplet.  The special string argument "none" restores the plot to the default colors.

     If the first argument HFIG is a figure handle, then operate on this figure rather than the current figure returned by 'gcf'.  The root properties will not be changed.

     See also: reset, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Invert the colors in the current color scheme.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
xlabel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 610
 -- Function File: xlabel (STRING)
 -- Function File: xlabel (STRING, PROPERTY, VAL, ...)
 -- Function File: xlabel (HAX, ...)
 -- Function File: H = xlabel (...)
     Specify the string used to label the x-axis of the current axis.

     An optional list of PROPERTY/VALUE pairs can be used to change the properties of the created text label.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created text object.

     See also: ylabel, zlabel, datetick, title, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Specify the string used to label the x-axis of the current axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
xlim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
 -- Function File: XLIMITS = xlim ()
 -- Function File: XMODE = xlim ("mode")
 -- Function File: xlim ([X_LO X_HI])
 -- Function File: xlim ("auto")
 -- Function File: xlim ("manual")
 -- Function File: xlim (HAX, ...)
     Query or set the limits of the x-axis for the current plot.

     Called without arguments 'xlim' returns the x-axis limits of the current plot.

     With the input query "mode", return the current x-limit calculation mode which is either "auto" or "manual".

     If passed a 2-element vector [X_LO X_HI], the limits of the x-axis are set to these values and the mode is set to "manual".

     The current plotting mode can be changed by using either "auto" or "manual" as the argument.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     See also: ylim, zlim, axis, set, get, gca.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Query or set the limits of the x-axis for the current plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ylabel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 672
 -- Function File: ylabel (STRING)
 -- Function File: ylabel (STRING, PROPERTY, VAL, ...)
 -- Function File: ylabel (HAX, ...)
 -- Function File: H = ylabel (...)
     Specify the string used to label the y-axis of the current axis.

     If HAX is specified then label the axis defined by HAX.

     An optional list of PROPERTY/VALUE pairs can be used to change the properties of the created text label.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created text object.

     See also: xlabel, zlabel, datetick, title, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Specify the string used to label the y-axis of the current axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
ylim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
 -- Function File: YLIMITS = ylim ()
 -- Function File: XMODE = ylim ("mode")
 -- Function File: ylim ([Y_LO Y_HI])
 -- Function File: ylim ("auto")
 -- Function File: ylim ("manual")
 -- Function File: ylim (HAX, ...)
     Query or set the limits of the y-axis for the current plot.

     Called without arguments 'ylim' returns the y-axis limits of the current plot.

     With the input query "mode", return the current y-limit calculation mode which is either "auto" or "manual".

     If passed a 2-element vector [Y_LO Y_HI], the limits of the y-axis are set to these values and the mode is set to "manual".

     The current plotting mode can be changed by using either "auto" or "manual" as the argument.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     See also: xlim, zlim, axis, set, get, gca.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Query or set the limits of the y-axis for the current plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
zlabel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 622
 -- Function File: zlabel (STRING)
 -- Function File: zlabel (STRING, PROPERTY, VAL, ...)
 -- Function File: zlabel (HAX, ...)
 -- Function File: H = zlabel (...)
     Specify the string used to label the z-axis of the current axis.

     An optional list of PROPERTY/VALUE pairs can be used to change the properties of the created text label.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created text object.

     See also: xlabel, ylabel, datetick, title, text.
   Author: jwe 


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Specify the string used to label the z-axis of the current axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
zlim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
 -- Function File: ZLIMITS = zlim ()
 -- Function File: XMODE = zlim ("mode")
 -- Function File: zlim ([Z_LO Z_HI])
 -- Function File: zlim ("auto")
 -- Function File: zlim ("manual")
 -- Function File: zlim (HAX, ...)
     Query or set the limits of the z-axis for the current plot.

     Called without arguments 'zlim' returns the z-axis limits of the current plot.

     With the input query "mode", return the current z-limit calculation mode which is either "auto" or "manual".

     If passed a 2-element vector [Z_LO Z_HI], the limits of the x-axis are set to these values and the mode is set to "manual".

     The current plotting mode can be changed by using either "auto" or "manual" as the argument.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     See also: xlim, ylim, axis, set, get, gca.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Query or set the limits of the z-axis for the current plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
area


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1306
 -- Function File: area (Y)
 -- Function File: area (X, Y)
 -- Function File: area (..., LVL)
 -- Function File: area (..., PROP, VAL, ...)
 -- Function File: area (HAX, ...)
 -- Function File: H = area (...)
     Area plot of the columns of Y.

     This plot shows the contributions of each column value to the row sum.  It is functionally similar to 'plot (X, cumsum (Y, 2))', except that the area under the curve is shaded.

     If the X argument is omitted it defaults to '1:rows (Y)'.  A value LVL can be defined that determines where the base level of the shading under the curve should be defined.  The default level is 0.

     Additional property/value pairs are passed directly to the underlying patch object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the hggroup object comprising the area patch objects.  The "BaseValue" property of the hggroup can be used to adjust the level where shading begins.

     Example: Verify identity sin^2 + cos^2 = 1

          t = linspace (0, 2*pi, 100)';
          y = [sin(t).^2, cos(t).^2];
          area (t, y);
          legend ("sin^2", "cos^2", "location", "NorthEastOutside");

     See also: plot, patch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Area plot of the columns of Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
barh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1710
 -- Function File: barh (Y)
 -- Function File: barh (X, Y)
 -- Function File: barh (..., W)
 -- Function File: barh (..., STYLE)
 -- Function File: barh (..., PROP, VAL, ...)
 -- Function File: barh (HAX, ...)
 -- Function File: H = barh (..., PROP, VAL, ...)
     Produce a horizontal bar graph from two vectors of X-Y data.

     If only one argument is given, it is taken as a vector of Y values and the X coordinates are the range '1:numel (Y)'.

     The optional input W controls the width of the bars.  A value of 1.0 will cause each bar to exactly touch any adjacent bars.  The default width is 0.8.

     If Y is a matrix, then each column of Y is taken to be a separate bar graph plotted on the same graph.  By default the columns are plotted side-by-side.  This behavior can be changed by the STYLE argument which can take the following values:

     "grouped" (default)
          Side-by-side bars with a gap between bars and centered over the Y-coordinate.

     "stacked"
          Bars are stacked so that each Y value has a single bar composed of multiple segments.

     "hist"
          Side-by-side bars with no gap between bars and centered over the Y-coordinate.

     "histc"
          Side-by-side bars with no gap between bars and left-aligned to the Y-coordinate.

     Optional property/value pairs are passed directly to the underlying patch objects.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created bar series hggroup.  For a description of the use of the bar series, *note bar: XREFbar.

     See also: bar, hist, pie, plot, patch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Produce a horizontal bar graph from two vectors of X-Y data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
bar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2561
 -- Function File: bar (Y)
 -- Function File: bar (X, Y)
 -- Function File: bar (..., W)
 -- Function File: bar (..., STYLE)
 -- Function File: bar (..., PROP, VAL, ...)
 -- Function File: bar (HAX, ...)
 -- Function File: H = bar (..., PROP, VAL, ...)
     Produce a bar graph from two vectors of X-Y data.

     If only one argument is given, Y, it is taken as a vector of Y values and the X coordinates are the range '1:numel (Y)'.

     The optional input W controls the width of the bars.  A value of 1.0 will cause each bar to exactly touch any adjacent bars.  The default width is 0.8.

     If Y is a matrix, then each column of Y is taken to be a separate bar graph plotted on the same graph.  By default the columns are plotted side-by-side.  This behavior can be changed by the STYLE argument which can take the following values:

     "grouped" (default)
          Side-by-side bars with a gap between bars and centered over the X-coordinate.

     "stacked"
          Bars are stacked so that each X value has a single bar composed of multiple segments.

     "hist"
          Side-by-side bars with no gap between bars and centered over the X-coordinate.

     "histc"
          Side-by-side bars with no gap between bars and left-aligned to the X-coordinate.

     Optional property/value pairs are passed directly to the underlying patch objects.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of handles to the created "bar series" hggroups with one handle per column of the variable Y.  This series makes it possible to change a common element in one bar series object and have the change reflected in the other "bar series".  For example,

          h = bar (rand (5, 10));
          set (h(1), "basevalue", 0.5);

     changes the position on the base of all of the bar series.

     The following example modifies the face and edge colors using property/value pairs.

          bar (randn (1, 100), "facecolor", "r", "edgecolor", "b");

     The color of the bars is taken from the figure's colormap, such that

          bar (rand (10, 3));
          colormap (summer (64));

     will change the colors used for the bars.  The color of bars can also be set manually using the "facecolor" property as shown below.

          h = bar (rand (10, 3));
          set (h(1), "facecolor", "r")
          set (h(2), "facecolor", "g")
          set (h(3), "facecolor", "b")

     See also: barh, hist, pie, plot, patch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Produce a bar graph from two vectors of X-Y data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
colorbar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2180
 -- Command: colorbar
 -- Function File: colorbar (LOC)
 -- Function File: colorbar (DELETE_OPTION)
 -- Function File: colorbar (HCB, ...)
 -- Function File: colorbar (HAX, ...)
 -- Function File: colorbar (..., "peer", HAX, ...)
 -- Function File: colorbar (..., "location", LOC, ...)
 -- Function File: colorbar (..., PROP, VAL, ...)
 -- Function File: H = colorbar (...)
     Add a colorbar to the current axes.

     A colorbar displays the current colormap along with numerical rulings so that the color scale can be interpreted.

     The optional input LOC determines the location of the colorbar.  Valid values for LOC are

     "EastOutside"
          Place the colorbar outside the plot to the right.  This is the default.

     "East"
          Place the colorbar inside the plot to the right.

     "WestOutside"
          Place the colorbar outside the plot to the left.

     "West"
          Place the colorbar inside the plot to the left.

     "NorthOutside"
          Place the colorbar above the plot.

     "North"
          Place the colorbar at the top of the plot.

     "SouthOutside"
          Place the colorbar under the plot.

     "South"
          Place the colorbar at the bottom of the plot.

     To remove a colorbar from a plot use any one of the following keywords for the DELETE_OPTION: "delete", "hide", "off".

     If the argument "peer" is given, then the following argument is treated as the axes handle in which to add the colorbar.  Alternatively, If the first argument HAX is an axes handle, then the colorbar is added to this axis, rather than the current axes returned by 'gca'.

     If the first argument HCB is a handle to a colorbar object, then operate on this colorbar directly.

     Additional property/value pairs are passed directly to the underlying axes object.

     The optional return value H is a graphics handle to the created colorbar object.

     Implementation Note: A colorbar is created as an additional axes to the current figure with the "tag" property set to "colorbar".  The created axes object has the extra property "location" which controls the positioning of the colorbar.

     See also: colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Add a colorbar to the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
comet3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 647
 -- Function File: comet3 (Z)
 -- Function File: comet3 (X, Y, Z)
 -- Function File: comet3 (X, Y, Z, P)
 -- Function File: comet3 (HAX, ...)
     Produce a simple comet style animation along the trajectory provided by the input coordinate vectors (X, Y, Z).

     If only Z is specified then X, Y default to the indices of Z.

     The speed of the comet may be controlled by P, which represents the time each point is displayed before moving to the next one.  The default for P is 0.1 seconds.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: comet.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 111
Produce a simple comet style animation along the trajectory provided by the input coordinate vectors (X, Y, Z).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
comet


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 628
 -- Function File: comet (Y)
 -- Function File: comet (X, Y)
 -- Function File: comet (X, Y, P)
 -- Function File: comet (HAX, ...)
     Produce a simple comet style animation along the trajectory provided by the input coordinate vectors (X, Y).

     If X is not specified it defaults to the indices of Y.

     The speed of the comet may be controlled by P, which represents the time each point is displayed before moving to the next one.  The default for P is 0.1 seconds.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: comet3.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
Produce a simple comet style animation along the trajectory provided by the input coordinate vectors (X, Y).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
compass


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 956
 -- Function File: compass (U, V)
 -- Function File: compass (Z)
 -- Function File: compass (..., STYLE)
 -- Function File: compass (HAX, ...)
 -- Function File: H = compass (...)

     Plot the '(U, V)' components of a vector field emanating from the origin of a polar plot.

     The arrow representing each vector has one end at the origin and the tip at [U(i), V(i)].  If a single complex argument Z is given, then 'U = real (Z)' and 'V = imag (Z)'.

     The style to use for the plot can be defined with a line style STYLE of the same format as the 'plot' command.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the line objects representing the drawn vectors.

          a = toeplitz ([1;randn(9,1)], [1,randn(1,9)]);
          compass (eig (a));

     See also: polar, feather, quiver, rose, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Plot the '(U, V)' components of a vector field emanating from the origin of a polar plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
contour3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1420
 -- Function File: contour3 (Z)
 -- Function File: contour3 (Z, VN)
 -- Function File: contour3 (X, Y, Z)
 -- Function File: contour3 (X, Y, Z, VN)
 -- Function File: contour3 (..., STYLE)
 -- Function File: contour3 (HAX, ...)
 -- Function File: [C, H] = contour3 (...)
     Create a 3-D contour plot.

     'contour3' plots level curves (contour lines) of the matrix Z at a Z level corresponding to each contour.  This is in contrast to 'contour' which plots all of the contour lines at the same Z level and produces a 2-D plot.

     The level curves are taken from the contour matrix C computed by 'contourc' for the same arguments; see the latter for their interpretation.

     The appearance of contour lines can be defined with a line style STYLE in the same manner as 'plot'.  Only line style and color are used; Any markers defined by STYLE are ignored.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional output C are the contour levels in 'contourc' format.

     The optional return value H is a graphics handle to the hggroup comprising the contour lines.

     Example:

          contour3 (peaks (19));
          colormap cool;
          hold on;
          surf (peaks (19), "facecolor", "none", "edgecolor", "black");

     See also: contour, contourc, contourf, clabel, meshc, surfc, caxis, colormap, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Create a 3-D contour plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
contourc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1473
 -- Function File: [C, LEV] = contourc (Z)
 -- Function File: [C, LEV] = contourc (Z, VN)
 -- Function File: [C, LEV] = contourc (X, Y, Z)
 -- Function File: [C, LEV] = contourc (X, Y, Z, VN)
     Compute contour lines (isolines of constant Z value).

     The matrix Z contains height values above the rectangular grid determined by X and Y.  If only a single input Z is provided then X is taken to be '1:rows (Z)' and Y is taken to be '1:columns (Z)'.

     The optional input VN is either a scalar denoting the number of contour lines to compute or a vector containing the Z values where lines will be computed.  When VN is a vector the number of contour lines is 'numel (VN)'.  However, to compute a single contour line at a given value use 'VN = [val, val]'.  If VN is omitted it defaults to 10.

     The return value C is a 2xN matrix containing the contour lines in the following format

          C = [lev1, x1, x2, ..., levn, x1, x2, ...
               len1, y1, y2, ..., lenn, y1, y2, ...]

     in which contour line N has a level (height) of LEVN and length of LENN.

     The optional return value LEV is a vector with the Z values of the contour levels.

     Example:

          x = 0:2;
          y = x;
          z = x' * y;
          contourc (x, y, z, 2:3)
             =>   2.0000   2.0000   1.0000   3.0000   1.5000   2.0000
                  2.0000   1.0000   2.0000   2.0000   2.0000   1.5000

     See also: contour, contourf, contour3, clabel.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compute contour lines (isolines of constant Z value).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
contourf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1340
 -- Function File: contourf (Z)
 -- Function File: contourf (Z, VN)
 -- Function File: contourf (X, Y, Z)
 -- Function File: contourf (X, Y, Z, VN)
 -- Function File: contourf (..., STYLE)
 -- Function File: contourf (HAX, ...)
 -- Function File: [C, H] = contourf (...)
     Create a 2-D contour plot with filled intervals.

     Plot level curves (contour lines) of the matrix Z and fill the region between lines with colors from the current colormap.

     The level curves are taken from the contour matrix C computed by 'contourc' for the same arguments; see the latter for their interpretation.

     The appearance of contour lines can be defined with a line style STYLE in the same manner as 'plot'.  Only line style and color are used; Any markers defined by STYLE are ignored.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional output C contains the contour levels in 'contourc' format.

     The optional return value H is a graphics handle to the hggroup comprising the contour lines.

     The following example plots filled contours of the 'peaks' function.

          [x, y, z] = peaks (50);
          contourf (x, y, z, -7:9)

     See also: ezcontourf, contour, contourc, contour3, clabel, meshc, surfc, caxis, colormap, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Create a 2-D contour plot with filled intervals.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
contour


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1171
 -- Function File: contour (Z)
 -- Function File: contour (Z, VN)
 -- Function File: contour (X, Y, Z)
 -- Function File: contour (X, Y, Z, VN)
 -- Function File: contour (..., STYLE)
 -- Function File: contour (HAX, ...)
 -- Function File: [C, H] = contour (...)
     Create a 2-D contour plot.

     Plot level curves (contour lines) of the matrix Z, using the contour matrix C computed by 'contourc' from the same arguments; see the latter for their interpretation.

     The appearance of contour lines can be defined with a line style STYLE in the same manner as 'plot'.  Only line style and color are used; Any markers defined by STYLE are ignored.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional output C contains the contour levels in 'contourc' format.

     The optional return value H is a graphics handle to the hggroup comprising the contour lines.

     Example:

          x = 0:2;
          y = x;
          z = x' * y;
          contour (x, y, z, 2:3)

     See also: ezcontour, contourc, contourf, contour3, clabel, meshc, surfc, caxis, colormap, plot.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Create a 2-D contour plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
cylinder


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 917
 -- Command: cylinder
 -- Function File: cylinder (R)
 -- Function File: cylinder (R, N)
 -- Function File: cylinder (HAX, ...)
 -- Function File: [X, Y, Z] = cylinder (...)
     Plot a 3-D unit cylinder.

     The optional input R is a vector specifying the radius along the unit z-axis.  The default is [1 1] indicating radius 1 at 'Z == 0' and at 'Z == 1'.

     The optional input N determines the number of faces around the circumference of the cylinder.  The default value is 20.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     If outputs are requested 'cylinder' returns three matrices in 'meshgrid' format, such that 'surf (X, Y, Z)' generates a unit cylinder.

     Example:

          [x, y, z] = cylinder (10:-1:0, 50);
          surf (x, y, z);
          title ("a cone");

     See also: ellipsoid, rectangle, sphere.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Plot a 3-D unit cylinder.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ellipsoid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 773
 -- Function File: ellipsoid (XC, YC, ZC, XR, YR, ZR, N)
 -- Function File: ellipsoid (..., N)
 -- Function File: ellipsoid (HAX, ...)
 -- Function File: [X, Y, Z] = ellipsoid (...)
     Plot a 3-D ellipsoid.

     The inputs XC, YC, ZC specify the center of the ellipsoid.  The inputs XR, YR, ZR specify the semi-major axis lengths.

     The optional input N determines the number of faces around the circumference of the cylinder.  The default value is 20.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     If outputs are requested 'ellipsoid' returns three matrices in 'meshgrid' format, such that 'surf (X, Y, Z)' generates the ellipsoid.

     See also: cylinder, rectangle, sphere.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Plot a 3-D ellipsoid.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
errorbar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4165
 -- Function File: errorbar (Y, EY)
 -- Function File: errorbar (Y, ..., FMT)
 -- Function File: errorbar (X, Y, EY)
 -- Function File: errorbar (X, Y, ERR, FMT)
 -- Function File: errorbar (X, Y, LERR, UERR, FMT)
 -- Function File: errorbar (X, Y, EX, EY, FMT)
 -- Function File: errorbar (X, Y, LX, UX, LY, UY, FMT)
 -- Function File: errorbar (X1, Y1, ..., FMT, XN, YN, ...)
 -- Function File: errorbar (HAX, ...)
 -- Function File: H = errorbar (...)
     Create a 2-D plot with errorbars.

     Many different combinations of arguments are possible.  The simplest form is

          errorbar (Y, EY)

     where the first argument is taken as the set of Y coordinates, the second argument EY are the errors around the Y values, and the X coordinates are taken to be the indices of the elements ('1:numel (Y)').

     The general form of the function is

          errorbar (X, Y, ERR1, ..., FMT, ...)

     After the X and Y arguments there can be 1, 2, or 4 parameters specifying the error values depending on the nature of the error values and the plot format FMT.

     ERR (scalar)
          When the error is a scalar all points share the same error value.  The errorbars are symmetric and are drawn from DATA-ERR to DATA+ERR.  The FMT argument determines whether ERR is in the x-direction, y-direction (default), or both.

     ERR (vector or matrix)
          Each data point has a particular error value.  The errorbars are symmetric and are drawn from DATA(n)-ERR(n) to DATA(n)+ERR(n).

     LERR, UERR (scalar)
          The errors have a single low-side value and a single upper-side value.  The errorbars are not symmetric and are drawn from DATA-LERR to DATA+UERR.

     LERR, UERR (vector or matrix)
          Each data point has a low-side error and an upper-side error.  The errorbars are not symmetric and are drawn from DATA(n)-LERR(n) to DATA(n)+UERR(n).

     Any number of data sets (X1,Y1, X2,Y2, ...) may appear as long as they are separated by a format string FMT.

     If Y is a matrix, X and the error parameters must also be matrices having the same dimensions.  The columns of Y are plotted versus the corresponding columns of X and errorbars are taken from the corresponding columns of the error parameters.

     If FMT is missing, the yerrorbars ("~") plot style is assumed.

     If the FMT argument is supplied then it is interpreted, as in normal plots, to specify the line style, marker, and color.  In addition, FMT may include an errorbar style which *must precede* the ordinary format codes.  The following errorbar styles are supported:

     '~'
          Set yerrorbars plot style (default).

     '>'
          Set xerrorbars plot style.

     '~>'
          Set xyerrorbars plot style.

     '#~'
          Set yboxes plot style.

     '#'
          Set xboxes plot style.

     '#~>'
          Set xyboxes plot style.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a handle to the hggroup object representing the data plot and errorbars.

     Note: For compatibility with MATLAB a line is drawn through all data points.  However, most scientific errorbar plots are a scatter plot of points with errorbars.  To accomplish this, add a marker style to the FMT argument such as ".".  Alternatively, remove the line by modifying the returned graphic handle with 'set (h, "linestyle", "none")'.

     Examples:

          errorbar (X, Y, EX, ">.r")

     produces an xerrorbar plot of Y versus X with X errorbars drawn from X-EX to X+EX.  The marker "."  is used so no connecting line is drawn and the errorbars appear in red.

          errorbar (X, Y1, EY, "~",
                    X, Y2, LY, UY)

     produces yerrorbar plots with Y1 and Y2 versus X.  Errorbars for Y1 are drawn from Y1-EY to Y1+EY, errorbars for Y2 from Y2-LY to Y2+UY.

          errorbar (X, Y, LX, UX,
                    LY, UY, "~>")

     produces an xyerrorbar plot of Y versus X in which X errorbars are drawn from X-LX to X+UX and Y errorbars from Y-LY to Y+UY.

     See also: semilogxerr, semilogyerr, loglogerr, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Create a 2-D plot with errorbars.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
ezcontourf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1107
 -- Function File: ezcontourf (F)
 -- Function File: ezcontourf (..., DOM)
 -- Function File: ezcontourf (..., N)
 -- Function File: ezcontourf (HAX, ...)
 -- Function File: H = ezcontourf (...)

     Plot the filled contour lines of a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     Example:

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezcontourf (f, [-3, 3]);

     See also: contourf, ezcontour, ezplot, ezmeshc, ezsurfc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Plot the filled contour lines of a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ezcontour


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1094
 -- Function File: ezcontour (F)
 -- Function File: ezcontour (..., DOM)
 -- Function File: ezcontour (..., N)
 -- Function File: ezcontour (HAX, ...)
 -- Function File: H = ezcontour (...)

     Plot the contour lines of a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     Example:

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezcontour (f, [-3, 3]);

     See also: contour, ezcontourf, ezplot, ezmeshc, ezsurfc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Plot the contour lines of a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ezmeshc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1522
 -- Function File: ezmeshc (F)
 -- Function File: ezmeshc (FX, FY, FZ)
 -- Function File: ezmeshc (..., DOM)
 -- Function File: ezmeshc (..., N)
 -- Function File: ezmeshc (..., "circ")
 -- Function File: ezmeshc (HAX, ...)
 -- Function File: H = ezmeshc (...)

     Plot the mesh and contour lines defined by a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If three functions are passed, then plot the parametrically defined function '[FX (S, T), FY (S, T), FZ (S, T)]'.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the argument "circ" is given, then the function is plotted over a disk centered on the middle of the domain DOM.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a 2-element vector with a graphics handle for the created mesh plot and a second handle for the created contour plot.

     Example: 2-argument function

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezmeshc (f, [-3, 3]);

     See also: meshc, ezmesh, ezplot, ezsurf, ezsurfc, hidden.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Plot the mesh and contour lines defined by a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ezmesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1653
 -- Function File: ezmesh (F)
 -- Function File: ezmesh (FX, FY, FZ)
 -- Function File: ezmesh (..., DOM)
 -- Function File: ezmesh (..., N)
 -- Function File: ezmesh (..., "circ")
 -- Function File: ezmesh (HAX, ...)
 -- Function File: H = ezmesh (...)

     Plot the mesh defined by a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If three functions are passed, then plot the parametrically defined function '[FX (S, T), FY (S, T), FZ (S, T)]'.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the argument "circ" is given, then the function is plotted over a disk centered on the middle of the domain DOM.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Example 1: 2-argument function

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezmesh (f, [-3, 3]);

     Example 2: parametrically defined function

          fx = @(s,t) cos (s) .* cos (t);
          fy = @(s,t) sin (s) .* cos (t);
          fz = @(s,t) sin (t);
          ezmesh (fx, fy, fz, [-pi, pi, -pi/2, pi/2], 20);

     See also: mesh, ezmeshc, ezplot, ezsurf, ezsurfc, hidden.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Plot the mesh defined by a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ezplot3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 993
 -- Function File: ezplot3 (FX, FY, FZ)
 -- Function File: ezplot3 (..., DOM)
 -- Function File: ezplot3 (..., N)
 -- Function File: ezplot3 (HAX, ...)
 -- Function File: H = ezplot3 (...)

     Plot a parametrically defined curve in three dimensions.

     FX, FY, and FZ are strings, inline functions, or function handles with one argument defining the function.  By default the plot is over the domain '0 <= T <= 2*pi' with 500 points.

     If DOM is a two element vector, it represents the minimum and maximum values of T.

     N is a scalar defining the number of points to use in plotting the function.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

          fx = @(t) cos (t);
          fy = @(t) sin (t);
          fz = @(t) t;
          ezplot3 (fx, fy, fz, [0, 10*pi], 100);

     See also: plot3, ezplot, ezmesh, ezsurf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Plot a parametrically defined curve in three dimensions.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ezplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1575
 -- Function File: ezplot (F)
 -- Function File: ezplot (F2V)
 -- Function File: ezplot (FX, FY)
 -- Function File: ezplot (..., DOM)
 -- Function File: ezplot (..., N)
 -- Function File: ezplot (HAX, ...)
 -- Function File: H = ezplot (...)

     Plot the 2-D curve defined by the function F.

     The function F may be a string, inline function, or function handle and can have either one or two variables.  If F has one variable, then the function is plotted over the domain '-2*pi < X < 2*pi' with 500 points.

     If F2V is a function of two variables then the implicit function 'F(X,Y) = 0' is calculated over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     For example:

          ezplot (@(X, Y) X.^2 - Y.^2 - 1)

     If two functions are passed as inputs then the parametric function

          X = FX (T)
          Y = FY (T)

     is plotted over the domain '-2*pi <= T <= 2*pi' with 500 points.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y, or T for a parametric plot.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in plotting the function.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the created line objects.

     See also: plot, ezplot3, ezpolar, ezcontour, ezcontourf, ezmesh, ezmeshc, ezsurf, ezsurfc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Plot the 2-D curve defined by the function F.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ezpolar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 934
 -- Function File: ezpolar (F)
 -- Function File: ezpolar (..., DOM)
 -- Function File: ezpolar (..., N)
 -- Function File: ezpolar (HAX, ...)
 -- Function File: H = ezpolar (...)

     Plot a 2-D function in polar coordinates.

     The function F is a string, inline function, or function handle with a single argument.  The expected form of the function is 'RHO = F(THETA)'.  By default the plot is over the domain '0 <= THETA <= 2*pi' with 500 points.

     If DOM is a two element vector, it represents the minimum and maximum values of THETA.

     N is a scalar defining the number of points to use in plotting the function.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     Example:

          ezpolar (@(t) sin (5/4 * t), [0, 8*pi]);

     See also: polar, ezplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Plot a 2-D function in polar coordinates.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ezsurfc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1509
 -- Function File: ezsurfc (F)
 -- Function File: ezsurfc (FX, FY, FZ)
 -- Function File: ezsurfc (..., DOM)
 -- Function File: ezsurfc (..., N)
 -- Function File: ezsurfc (..., "circ")
 -- Function File: ezsurfc (HAX, ...)
 -- Function File: H = ezsurfc (...)

     Plot the surface and contour lines defined by a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If three functions are passed, then plot the parametrically defined function '[FX (S, T), FY (S, T), FZ (S, T)]'.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the argument "circ" is given, then the function is plotted over a disk centered on the middle of the domain DOM.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a 2-element vector with a graphics handle for the created surface plot and a second handle for the created contour plot.

     Example:

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezsurfc (f, [-3, 3]);

     See also: surfc, ezsurf, ezplot, ezmesh, ezmeshc, shading.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Plot the surface and contour lines defined by a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ezsurf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1657
 -- Function File: ezsurf (F)
 -- Function File: ezsurf (FX, FY, FZ)
 -- Function File: ezsurf (..., DOM)
 -- Function File: ezsurf (..., N)
 -- Function File: ezsurf (..., "circ")
 -- Function File: ezsurf (HAX, ...)
 -- Function File: H = ezsurf (...)

     Plot the surface defined by a function.

     F is a string, inline function, or function handle with two arguments defining the function.  By default the plot is over the meshed domain '-2*pi <= X | Y <= 2*pi' with 60 points in each dimension.

     If three functions are passed, then plot the parametrically defined function '[FX (S, T), FY (S, T), FZ (S, T)]'.

     If DOM is a two element vector, it represents the minimum and maximum values of both X and Y.  If DOM is a four element vector, then the minimum and maximum values are '[xmin xmax ymin ymax]'.

     N is a scalar defining the number of points to use in each dimension.

     If the argument "circ" is given, then the function is plotted over a disk centered on the middle of the domain DOM.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Example 1: 2-argument function

          f = @(x,y) sqrt (abs (x .* y)) ./ (1 + x.^2 + y.^2);
          ezsurf (f, [-3, 3]);

     Example 2: parametrically defined function

          fx = @(s,t) cos (s) .* cos (t);
          fy = @(s,t) sin (s) .* cos (t);
          fz = @(s,t) sin (t);
          ezsurf (fx, fy, fz, [-pi, pi, -pi/2, pi/2], 20);

     See also: surf, ezsurfc, ezplot, ezmesh, ezmeshc, shading.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Plot the surface defined by a function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
feather


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 855
 -- Function File: feather (U, V)
 -- Function File: feather (Z)
 -- Function File: feather (..., STYLE)
 -- Function File: feather (HAX, ...)
 -- Function File: H = feather (...)

     Plot the '(U, V)' components of a vector field emanating from equidistant points on the x-axis.

     If a single complex argument Z is given, then 'U = real (Z)' and 'V = imag (Z)'.

     The style to use for the plot can be defined with a line style STYLE of the same format as the 'plot' command.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the line objects representing the drawn vectors.

          phi = [0 : 15 : 360] * pi/180;
          feather (sin (phi), cos (phi));

     See also: plot, quiver, compass.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Plot the '(U, V)' components of a vector field emanating from equidistant points on the x-axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fill


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1668
 -- Function File: fill (X, Y, C)
 -- Function File: fill (X1, Y1, C1, X2, Y2, C2)
 -- Function File: fill (..., PROP, VAL)
 -- Function File: fill (HAX, ...)
 -- Function File: H = fill (...)
     Create one or more filled 2-D polygons.

     The inputs X and Y are the coordinates of the polygon vertices.  If the inputs are matrices then the rows represent different vertices and each column produces a different polygon.  'fill' will close any open polygons before plotting.

     The input C determines the color of the polygon.  The simplest form is a single color specification such as a 'plot' format or an RGB-triple.  In this case the polygon(s) will have one unique color.  If C is a vector or matrix then the color data is first scaled using 'caxis' and then indexed into the current colormap.  A row vector will color each polygon (a column from matrices X and Y) with a single computed color.  A matrix C of the same size as X and Y will compute the color of each vertex and then interpolate the face color between the vertices.

     Multiple property/value pairs for the underlying patch object may be specified, but they must appear in pairs.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the created patch objects.

     Example: red square

          vertices = [0 0
                      1 0
                      1 1
                      0 1];
          fill (vertices(:,1), vertices(:,2), "r");
          axis ([-0.5 1.5, -0.5 1.5])
          axis equal

     See also: patch, caxis, colormap.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Create one or more filled 2-D polygons.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
fplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1813
 -- Function File: fplot (FN, LIMITS)
 -- Function File: fplot (..., TOL)
 -- Function File: fplot (..., N)
 -- Function File: fplot (..., FMT)
 -- Function File: [X, Y] = fplot (...)
     Plot a function FN within the range defined by LIMITS.

     FN is a function handle, inline function, or string containing the name of the function to evaluate.

     The limits of the plot are of the form '[XLO, XHI]' or '[XLO, XHI, YLO, YHI]'.

     The next three arguments are all optional and any number of them may be given in any order.

     TOL is the relative tolerance to use for the plot and defaults to 2e-3 (.2%).

     N is the minimum number of points to use.  When N is specified, the maximum stepsize will be 'XHI - XLO / N'.  More than N points may still be used in order to meet the relative tolerance requirement.

     The FMT argument specifies the linestyle to be used by the plot command.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     With no output arguments the results are immediately plotted.  With two output arguments the 2-D plot data is returned.  The data can subsequently be plotted manually with 'plot (X, Y)'.

     Example:

          fplot (@cos, [0, 2*pi])
          fplot ("[cos(x), sin(x)]", [0, 2*pi])

     Programming Notes:

     'fplot' works best with continuous functions.  Functions with discontinuities are unlikely to plot well.  This restriction may be removed in the future.

     'fplot' requires that the function accept and return a vector argument.  Consider this when writing user-defined functions and use '.*', './', etc.  See the function 'vectorize' for potentially converting inline or anonymous functions to vectorized versions.

     See also: ezplot, plot, vectorize.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Plot a function FN within the range defined by LIMITS.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
hist


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1619
 -- Function File: hist (Y)
 -- Function File: hist (Y, X)
 -- Function File: hist (Y, NBINS)
 -- Function File: hist (Y, X, NORM)
 -- Function File: hist (..., PROP, VAL, ...)
 -- Function File: hist (HAX, ...)
 -- Function File: [NN, XX] = hist (...)
     Produce histogram counts or plots.

     With one vector input argument, Y, plot a histogram of the values with 10 bins.  The range of the histogram bins is determined by the range of the data.  With one matrix input argument, Y, plot a histogram where each bin contains a bar per input column.

     Given a second vector argument, X, use that as the centers of the bins, with the width of the bins determined from the adjacent values in the vector.

     If scalar, the second argument, NBINS, defines the number of bins.

     If a third argument is provided, the histogram is normalized such that the sum of the bars is equal to NORM.

     Extreme values are lumped into the first and last bins.

     The histogram's appearance may be modified by specifying property/value pairs.  For example the face and edge color may be modified.

          hist (randn (1, 100), 25, "facecolor", "r", "edgecolor", "b");

     The histogram's colors also depend upon the current colormap.

          hist (rand (10, 3));
          colormap (summer ());

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     With two output arguments, produce the values NN (numbers of elements) and XX (bin centers) such that 'bar (XX, NN)' will plot the histogram.

     See also: histc, bar, pie, rose.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Produce histogram counts or plots.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
isocolors


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3351
 -- Function File: [CD] = isocolors (C, V)
 -- Function File: [CD] = isocolors (X, Y, Z, C, V)
 -- Function File: [CD] = isocolors (X, Y, Z, R, G, B, V)
 -- Function File: [CD] = isocolors (R, G, B, V)
 -- Function File: [CD] = isocolors (..., P)
 -- Function File: isocolors (...)

     Compute isosurface colors.

     If called with one output argument and the first input argument C is a three-dimensional array that contains color values and the second input argument V keeps the vertices of a geometry then return a matrix CD with color data information for the geometry at computed points '[x, y, z] = meshgrid (1:l, 1:m, 1:n)'.  The output argument CD can be taken to manually set FaceVertexCData of a patch.

     If called with further input arguments X, Y and Z which are three-dimensional arrays of the same size than C then the color data is taken at those given points.  Instead of the color data C this function can also be called with RGB values R, G, B.  If input argumnets X, Y, Z are not given then again 'meshgrid' computed values are taken.

     Optionally, the patch handle P can be given as the last input argument to all variations of function calls instead of the vertices data V.  Finally, if no output argument is given then directly change the colors of a patch that is given by the patch handle P.

     For example:

          function [] = isofinish (p)
            set (gca, "PlotBoxAspectRatioMode", "manual", ...
                      "PlotBoxAspectRatio", [1 1 1]);
            set (p, "FaceColor", "interp");
            ## set (p, "FaceLighting", "flat");
            ## light ("Position", [1 1 5]);  # Available with JHandles
          endfunction

          N = 15;    # Increase number of vertices in each direction
          iso = .4;  # Change isovalue to .1 to display a sphere
          lin = linspace (0, 2, N);
          [x, y, z] = meshgrid (lin, lin, lin);
          c = abs ((x-.5).^2 + (y-.5).^2 + (z-.5).^2);
          figure (); # Open another figure window

          subplot (2,2,1); view (-38, 20);
          [f, v] = isosurface (x, y, z, c, iso);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "none");
          cdat = rand (size (c));       # Compute random patch color data
          isocolors (x, y, z, cdat, p); # Directly set colors of patch
          isofinish (p);                # Call user function isofinish

          subplot (2,2,2); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "none");
          [r, g, b] = meshgrid (lin, 2-lin, 2-lin);
          cdat = isocolors (x, y, z, c, v); # Compute color data vertices
          set (p, "FaceVertexCData", cdat); # Set color data manually
          isofinish (p);

          subplot (2,2,3); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "none");
          cdat = isocolors (r, g, b, c, p); # Compute color data patch
          set (p, "FaceVertexCData", cdat); # Set color data manually
          isofinish (p);

          subplot (2,2,4); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "none");
          r = g = b = repmat ([1:N] / N, [N, 1, N]); # Black to white
          cdat = isocolors (x, y, z, r, g, b, v);
          set (p, "FaceVertexCData", cdat);
          isofinish (p);

     See also: isosurface, isonormals.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Compute isosurface colors.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
isonormals


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3282
 -- Function File: [N] = isonormals (VAL, V)
 -- Function File: [N] = isonormals (VAL, P)
 -- Function File: [N] = isonormals (X, Y, Z, VAL, V)
 -- Function File: [N] = isonormals (X, Y, Z, VAL, P)
 -- Function File: [N] = isonormals (..., "negate")
 -- Function File: isonormals (..., P)

     Calculate normals to an isosurface.

     If called with one output argument and the first input argument VAL is a three-dimensional array that contains the data for an isosurface geometry and the second input argument V keeps the vertices of an isosurface then return the normals N in form of a matrix with the same size than V at computed points '[x, y, z] = meshgrid (1:l, 1:m, 1:n)'.  The output argument N can be taken to manually set VERTEXNORMALS of a patch.

     If called with further input arguments X, Y and Z which are three-dimensional arrays with the same size than VAL then the volume data is taken at those given points.  Instead of the vertices data V a patch handle P can be passed to this function.

     If given the string input argument "negate" as last input argument then compute the reverse vector normals of an isosurface geometry.

     If no output argument is given then directly redraw the patch that is given by the patch handle P.

     For example:

          function [] = isofinish (p)
            set (gca, "PlotBoxAspectRatioMode", "manual", ...
                      "PlotBoxAspectRatio", [1 1 1]);
            set (p, "VertexNormals", -get (p,"VertexNormals")); # Revert normals
            set (p, "FaceColor", "interp");
            ## set (p, "FaceLighting", "phong");
            ## light ("Position", [1 1 5]); # Available with JHandles
          endfunction

          N = 15;    # Increase number of vertices in each direction
          iso = .4;  # Change isovalue to .1 to display a sphere
          lin = linspace (0, 2, N);
          [x, y, z] = meshgrid (lin, lin, lin);
          c = abs ((x-.5).^2 + (y-.5).^2 + (z-.5).^2);
          figure (); # Open another figure window

          subplot (2,2,1); view (-38, 20);
          [f, v, cdat] = isosurface (x, y, z, c, iso, y);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", cdat, ...
                     "FaceColor", "interp", "EdgeColor", "none");
          isofinish (p);  # Call user function isofinish

          subplot (2,2,2); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", cdat, ...
                     "FaceColor", "interp", "EdgeColor", "none");
          isonormals (x, y, z, c, p); # Directly modify patch
          isofinish (p);

          subplot (2,2,3); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", cdat, ...
                     "FaceColor", "interp", "EdgeColor", "none");
          n = isonormals (x, y, z, c, v); # Compute normals of isosurface
          set (p, "VertexNormals", n);    # Manually set vertex normals
          isofinish (p);

          subplot (2,2,4); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", cdat, ...
                     "FaceColor", "interp", "EdgeColor", "none");
          isonormals (x, y, z, c, v, "negate"); # Use reverse directly
          isofinish (p);

     See also: isosurface, isocolors.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Calculate normals to an isosurface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
isosurface


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4058
 -- Function File: [FV] = isosurface (VAL, ISO)
 -- Function File: [FV] = isosurface (X, Y, Z, VAL, ISO)
 -- Function File: [FV] = isosurface (..., "noshare", "verbose")
 -- Function File: [FVC] = isosurface (..., COL)
 -- Function File: [F, V] = isosurface (X, Y, Z, VAL, ISO)
 -- Function File: [F, V, C] = isosurface (X, Y, Z, VAL, ISO, COL)
 -- Function File: isosurface (X, Y, Z, VAL, ISO, COL, OPT)

     Calculate isosurface of 3-D data.

     If called with one output argument and the first input argument VAL is a three-dimensional array that contains the data of an isosurface geometry and the second input argument ISO keeps the isovalue as a scalar value then return a structure array FV that contains the fields FACES and VERTICES at computed points '[x, y, z] = meshgrid (1:l, 1:m, 1:n)'.  The output argument FV can directly be taken as an input argument for the 'patch' function.

     If called with further input arguments X, Y and Z which are three-dimensional arrays with the same size than VAL then the volume data is taken at those given points.

     The string input argument "noshare" is only for compatibility and has no effect.  If given the string input argument "verbose" then print messages to the command line interface about the current progress.

     If called with the input argument COL which is a three-dimensional array of the same size than VAL then take those values for the interpolation of coloring the isosurface geometry.  Add the field FACEVERTEXCDATA to the structure array FV.

     If called with two or three output arguments then return the information about the faces F, vertices V and color data C as separate arrays instead of a single structure array.

     If called with no output argument then directly process the isosurface geometry with the 'patch' command.

     For example,

          [x, y, z] = meshgrid (1:5, 1:5, 1:5);
          val = rand (5, 5, 5);
          isosurface (x, y, z, val, .5);

     will directly draw a random isosurface geometry in a graphics window.  Another example for an isosurface geometry with different additional coloring

          N = 15;    # Increase number of vertices in each direction
          iso = .4;  # Change isovalue to .1 to display a sphere
          lin = linspace (0, 2, N);
          [x, y, z] = meshgrid (lin, lin, lin);
          c = abs ((x-.5).^2 + (y-.5).^2 + (z-.5).^2);
          figure (); # Open another figure window

          subplot (2,2,1); view (-38, 20);
          [f, v] = isosurface (x, y, z, c, iso);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "none");
          set (gca, "PlotBoxAspectRatioMode", "manual", ...
                    "PlotBoxAspectRatio", [1 1 1]);
          # set (p, "FaceColor", "green", "FaceLighting", "phong");
          # light ("Position", [1 1 5]); # Available with the JHandles package

          subplot (2,2,2); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "EdgeColor", "blue");
          set (gca, "PlotBoxAspectRatioMode", "manual", ...
                    "PlotBoxAspectRatio", [1 1 1]);
          # set (p, "FaceColor", "none", "FaceLighting", "phong");
          # light ("Position", [1 1 5]);

          subplot (2,2,3); view (-38, 20);
          [f, v, c] = isosurface (x, y, z, c, iso, y);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", c, ...
                     "FaceColor", "interp", "EdgeColor", "none");
          set (gca, "PlotBoxAspectRatioMode", "manual", ...
                    "PlotBoxAspectRatio", [1 1 1]);
          # set (p, "FaceLighting", "phong");
          # light ("Position", [1 1 5]);

          subplot (2,2,4); view (-38, 20);
          p = patch ("Faces", f, "Vertices", v, "FaceVertexCData", c, ...
                     "FaceColor", "interp", "EdgeColor", "blue");
          set (gca, "PlotBoxAspectRatioMode", "manual", ...
                    "PlotBoxAspectRatio", [1 1 1]);
          # set (p, "FaceLighting", "phong");
          # light ("Position", [1 1 5]);

     See also: isonormals, isocolors.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Calculate isosurface of 3-D data.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
line


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 799
 -- Function File: line ()
 -- Function File: line (X, Y)
 -- Function File: line (X, Y, PROPERTY, VALUE, ...)
 -- Function File: line (X, Y, Z)
 -- Function File: line (X, Y, Z, PROPERTY, VALUE, ...)
 -- Function File: line (PROPERTY, VALUE, ...)
 -- Function File: line (HAX, ...)
 -- Function File: H = line (...)
     Create line object from X and Y (and possibly Z) and insert in the current axes.

     Multiple property-value pairs may be specified for the line object, but they must appear in pairs.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle (or vector of handles) to the line objects created.

     See also: image, patch, rectangle, surface, text.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Create line object from X and Y (and possibly Z) and insert in the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
loglogerr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1051
 -- Function File: loglogerr (Y, EY)
 -- Function File: loglogerr (Y, ..., FMT)
 -- Function File: loglogerr (X, Y, EY)
 -- Function File: loglogerr (X, Y, ERR, FMT)
 -- Function File: loglogerr (X, Y, LERR, UERR, FMT)
 -- Function File: loglogerr (X, Y, EX, EY, FMT)
 -- Function File: loglogerr (X, Y, LX, UX, LY, UY, FMT)
 -- Function File: loglogerr (X1, Y1, ..., FMT, XN, YN, ...)
 -- Function File: loglogerr (HAX, ...)
 -- Function File: H = loglogerr (...)
     Produce 2-D plots on a double logarithm axis with errorbars.

     Many different combinations of arguments are possible.  The most common form is

          loglogerr (X, Y, EY, FMT)

     which produces a double logarithm plot of Y versus X with errors in the Y-scale defined by EY and the plot format defined by FMT.  *Note errorbar: XREFerrorbar, for available formats and additional information.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: errorbar, semilogxerr, semilogyerr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Produce 2-D plots on a double logarithm axis with errorbars.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
loglog


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 635
 -- Function File: loglog (Y)
 -- Function File: loglog (X, Y)
 -- Function File: loglog (X, Y, PROP, VALUE, ...)
 -- Function File: loglog (X, Y, FMT)
 -- Function File: loglog (HAX, ...)
 -- Function File: H = loglog (...)
     Produce a 2-D plot using logarithmic scales for both axes.

     See the documentation of 'plot' for a description of the arguments that 'loglog' will accept.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     See also: plot, semilogx, semilogy.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Produce a 2-D plot using logarithmic scales for both axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
meshc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1480
 -- Function File: meshc (X, Y, Z)
 -- Function File: meshc (Z)
 -- Function File: meshc (..., C)
 -- Function File: meshc (..., PROP, VAL, ...)
 -- Function File: meshc (HAX, ...)
 -- Function File: H = meshc (...)
     Plot a 3-D wireframe mesh with underlying contour lines.

     The wireframe mesh is plotted using rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the mesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally the color of the mesh can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a 2-element vector with a graphics handle to the created surface object and to the created contour plot.

     See also: ezmeshc, mesh, meshz, contour, surfc, surface, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Plot a 3-D wireframe mesh with underlying contour lines.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
mesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1397
 -- Function File: mesh (X, Y, Z)
 -- Function File: mesh (Z)
 -- Function File: mesh (..., C)
 -- Function File: mesh (..., PROP, VAL, ...)
 -- Function File: mesh (HAX, ...)
 -- Function File: H = mesh (...)
     Plot a 3-D wireframe mesh.

     The wireframe mesh is plotted using rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the mesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally, the color of the mesh can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     See also: ezmesh, meshc, meshz, trimesh, contour, surf, surface, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Plot a 3-D wireframe mesh.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
meshz


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1430
 -- Function File: meshz (X, Y, Z)
 -- Function File: meshz (Z)
 -- Function File: meshz (..., C)
 -- Function File: meshz (..., PROP, VAL, ...)
 -- Function File: meshz (HAX, ...)
 -- Function File: H = meshz (...)
     Plot a 3-D wireframe mesh with a surrounding curtain.

     The wireframe mesh is plotted using rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 0:columns (Z) - 1, Y = 0:rows (Z) - 1'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the mesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally the color of the mesh can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     See also: mesh, meshc, contour, surf, surface, waterfall, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Plot a 3-D wireframe mesh with a surrounding curtain.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
pareto


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1706
 -- Function File: pareto (Y)
 -- Function File: pareto (Y, X)
 -- Function File: pareto (HAX, ...)
 -- Function File: H = pareto (...)
     Draw a Pareto chart.

     A Pareto chart is a bar graph that arranges information in such a way that priorities for process improvement can be established; It organizes and displays information to show the relative importance of data.  The chart is similar to the histogram or bar chart, except that the bars are arranged in decreasing magnitude from left to right along the x-axis.

     The fundamental idea (Pareto principle) behind the use of Pareto diagrams is that the majority of an effect is due to a small subset of the causes.  For quality improvement, the first few contributing causes (leftmost bars as presented on the diagram) to a problem usually account for the majority of the result.  Thus, targeting these "major causes" for elimination results in the most cost-effective improvement scheme.

     Typically only the magnitude data Y is present in which case X is taken to be the range '1 : length (Y)'.  If X is given it may be a string array, a cell array of strings, or a numerical vector.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a 2-element vector with a graphics handle for the created bar plot and a second handle for the created line plot.

     An example of the use of 'pareto' is

          Cheese = {"Cheddar", "Swiss", "Camembert", ...
                    "Munster", "Stilton", "Blue"};
          Sold = [105, 30, 70, 10, 15, 20];
          pareto (Sold, Cheese);

     See also: bar, barh, hist, pie, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Draw a Pareto chart.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
patch


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2375
 -- Function File: patch ()
 -- Function File: patch (X, Y, C)
 -- Function File: patch (X, Y, Z, C)
 -- Function File: patch (FV)
 -- Function File: patch ("Faces", FACES, "Vertices", VERTS, ...)
 -- Function File: patch (..., PROP, VAL, ...)
 -- Function File: patch (HAX, ...)
 -- Function File: H = patch (...)
     Create patch object in the current axes with vertices at locations (X, Y) and of color C.

     If the vertices are matrices of size MxN then each polygon patch has M vertices and a total of N polygons will be created.  If some polygons do not have M vertices use NaN to represent "no vertex".  If the Z input is present then 3-D patches will be created.

     The color argument C can take many forms.  To create polygons which all share a single color use a string value (e.g., "r" for red), a scalar value which is scaled by 'caxis' and indexed into the current colormap, or a 3-element RGB vector with the precise TrueColor.

     If C is a vector of length N then the ith polygon will have a color determined by scaling entry C(i) according to 'caxis' and then indexing into the current colormap.  More complicated coloring situations require directly manipulating patch property/value pairs.

     Instead of specifying polygons by matrices X and Y, it is possible to present a unique list of vertices and then a list of polygon faces created from those vertices.  In this case the "Vertices" matrix will be an Nx2 (2-D patch) or Nx3 (3-D patch).  The MxN "Faces" matrix describes M polygons having N vertices--each row describes a single polygon and each column entry is an index into the "Vertices" matrix to identify a vertex.  The patch object can be created by directly passing the property/value pairs "Vertices"/VERTS, "Faces"/FACES as inputs.

     A third input form is to create a structure FV with the fields "vertices", "faces", and optionally "facevertexcdata".

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created patch object.

     Implementation Note: Patches are highly configurable objects.  To truly customize them requires setting patch properties directly.  Useful patch properties are: "cdata", "edgecolor", "facecolor", "faces", "facevertexcdata".

     See also: fill, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Create patch object in the current axes with vertices at locations (X, Y) and of color C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
pcolor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1537
 -- Function File: pcolor (X, Y, C)
 -- Function File: pcolor (C)
 -- Function File: pcolor (HAX, ...)
 -- Function File: H = pcolor (...)
     Produce a 2-D density plot.

     A 'pcolor' plot draws rectangles with colors from the matrix C over the two-dimensional region represented by the matrices X and Y.  X and Y are the coordinates of the mesh's vertices and are typically the output of 'meshgrid'.  If X and Y are vectors, then a typical vertex is (X(j), Y(i), C(i,j)).  Thus, columns of C correspond to different X values and rows of C correspond to different Y values.

     The values in C are scaled to span the range of the current colormap.  Limits may be placed on the color axis by the command 'caxis', or by setting the 'clim' property of the parent axis.

     The face color of each cell of the mesh is determined by interpolating the values of C for each of the cell's vertices; Contrast this with 'imagesc' which renders one cell for each element of C.

     'shading' modifies an attribute determining the manner by which the face color of each cell is interpolated from the values of C, and the visibility of the cells' edges.  By default the attribute is "faceted", which renders a single color for each cell's face with the edge visible.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     See also: caxis, shading, meshgrid, contour, imagesc.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Produce a 2-D density plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
peaks


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1056
 -- Function File: peaks ()
 -- Function File: peaks (N)
 -- Function File: peaks (X, Y)
 -- Function File: Z = peaks (...)
 -- Function File: [X, Y, Z] = peaks (...)
     Plot a function with lots of local maxima and minima.

     The function has the form

     f(x,y) = 3*(1-x)^2*exp(-x^2 - (y+1)^2) ...
              - 10*(x/5 - x^3 - y^5)*exp(-x^2-y^2) ...
              - 1/3*exp(-(x+1)^2 - y^2)

     Called without a return argument, 'peaks' plots the surface of the above function using 'surf'.

     If N is a scalar, 'peaks' plots the value of the above function on an N-by-N mesh over the range [-3,3].  The default value for N is 49.

     If N is a vector, then it represents the grid values over which to calculate the function.  If X and Y are specified then the function value is calculated over the specified grid of vertices.

     When called with output arguments, return the data for the function evaluated over the meshgrid.  This can subsequently be plotted with 'surf (X, Y, Z)'.

     See also: sombrero, meshgrid, mesh, surf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Plot a function with lots of local maxima and minima.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
pie3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1227
 -- Function File: pie3 (X)
 -- Function File: pie3 (..., EXPLODE)
 -- Function File: pie3 (..., LABELS)
 -- Function File: pie3 (HAX, ...);
 -- Function File: H = pie3 (...);
     Plot a 3-D pie chart.

     Called with a single vector argument, produces a 3-D pie chart of the elements in X.  The size of the ith slice is the percentage that the element Xi represents of the total sum of X: 'pct = X(i) / sum (X)'.

     The optional input EXPLODE is a vector of the same length as X that, if nonzero, "explodes" the slice from the pie chart.

     The optional input LABELS is a cell array of strings of the same length as X specifying the label for each slice.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a list of graphics handles to the patch, surface, and text objects generating the plot.

     Note: If 'sum (X) <= 1' then the elements of X are interpreted as percentages directly and are not normalized by 'sum (x)'.  Furthermore, if the sum is less than 1 then there will be a missing slice in the pie plot to represent the missing, unspecified percentage.

     See also: pie, bar, hist, rose.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Plot a 3-D pie chart.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
pie


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1204
 -- Function File: pie (X)
 -- Function File: pie (..., EXPLODE)
 -- Function File: pie (..., LABELS)
 -- Function File: pie (HAX, ...);
 -- Function File: H = pie (...);
     Plot a 2-D pie chart.

     When called with a single vector argument, produce a pie chart of the elements in X.  The size of the ith slice is the percentage that the element Xi represents of the total sum of X: 'pct = X(i) / sum (X)'.

     The optional input EXPLODE is a vector of the same length as X that, if nonzero, "explodes" the slice from the pie chart.

     The optional input LABELS is a cell array of strings of the same length as X specifying the label for each slice.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a list of handles to the patch and text objects generating the plot.

     Note: If 'sum (X) <= 1' then the elements of X are interpreted as percentages directly and are not normalized by 'sum (x)'.  Furthermore, if the sum is less than 1 then there will be a missing slice in the pie plot to represent the missing, unspecified percentage.

     See also: pie3, bar, hist, rose.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Plot a 2-D pie chart.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
plot3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2083
 -- Function File: plot3 (X, Y, Z)
 -- Function File: plot3 (X, Y, Z, PROP, VALUE, ...)
 -- Function File: plot3 (X, Y, Z, FMT)
 -- Function File: plot3 (X, CPLX)
 -- Function File: plot3 (CPLX)
 -- Function File: plot3 (HAX, ...)
 -- Function File: H = plot3 (...)
     Produce 3-D plots.

     Many different combinations of arguments are possible.  The simplest form is

          plot3 (X, Y, Z)

     in which the arguments are taken to be the vertices of the points to be plotted in three dimensions.  If all arguments are vectors of the same length, then a single continuous line is drawn.  If all arguments are matrices, then each column of is treated as a separate line.  No attempt is made to transpose the arguments to make the number of rows match.

     If only two arguments are given, as

          plot3 (X, CPLX)

     the real and imaginary parts of the second argument are used as the Y and Z coordinates, respectively.

     If only one argument is given, as

          plot3 (CPLX)

     the real and imaginary parts of the argument are used as the Y and Z values, and they are plotted versus their index.

     Arguments may also be given in groups of three as

          plot3 (X1, Y1, Z1, X2, Y2, Z2, ...)

     in which each set of three arguments is treated as a separate line or set of lines in three dimensions.

     To plot multiple one- or two-argument groups, separate each group with an empty format string, as

          plot3 (X1, C1, "", C2, "", ...)

     Multiple property-value pairs may be specified which will affect the line objects drawn by 'plot3'.  If the FMT argument is supplied it will format the line objects in the same manner as 'plot'.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     Example:

          z = [0:0.05:5];
          plot3 (cos (2*pi*z), sin (2*pi*z), z, ";helix;");
          plot3 (z, exp (2i*pi*z), ";complex sinusoid;");

     See also: ezplot3, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
Produce 3-D plots.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
plot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6281
 -- Function File: plot (Y)
 -- Function File: plot (X, Y)
 -- Function File: plot (X, Y, FMT)
 -- Function File: plot (..., PROPERTY, VALUE, ...)
 -- Function File: plot (X1, Y1, ..., XN, YN)
 -- Function File: plot (HAX, ...)
 -- Function File: H = plot (...)
     Produce 2-D plots.

     Many different combinations of arguments are possible.  The simplest form is

          plot (Y)

     where the argument is taken as the set of Y coordinates and the X coordinates are taken to be the range '1:numel (Y)'.

     If more than one argument is given, they are interpreted as

          plot (Y, PROPERTY, VALUE, ...)

     or

          plot (X, Y, PROPERTY, VALUE, ...)

     or

          plot (X, Y, FMT, ...)

     and so on.  Any number of argument sets may appear.  The X and Y values are interpreted as follows:

        * If a single data argument is supplied, it is taken as the set of Y coordinates and the X coordinates are taken to be the indices of the elements, starting with 1.

        * If X and Y are scalars, a single point is plotted.

        * 'squeeze()' is applied to arguments with more than two dimensions, but no more than two singleton dimensions.

        * If both arguments are vectors, the elements of Y are plotted versus the elements of X.

        * If X is a vector and Y is a matrix, then the columns (or rows) of Y are plotted versus X.  (using whichever combination matches, with columns tried first.)

        * If the X is a matrix and Y is a vector, Y is plotted versus the columns (or rows) of X.  (using whichever combination matches, with columns tried first.)

        * If both arguments are matrices, the columns of Y are plotted versus the columns of X.  In this case, both matrices must have the same number of rows and columns and no attempt is made to transpose the arguments to make the number of rows match.

     Multiple property-value pairs may be specified, but they must appear in pairs.  These arguments are applied to the line objects drawn by 'plot'.  Useful properties to modify are "linestyle", "linewidth", "color", "marker", "markersize", "markeredgecolor", "markerfacecolor".  *Note Line Properties::.

     The FMT format argument can also be used to control the plot style.  It is a string composed of four optional parts: "<linestyle><marker><color><;displayname;>".  When a marker is specified, but no linestyle, only the markers are plotted.  Similarly, if a linestyle is specified, but no marker, then only lines are drawn.  If both are specified then lines and markers will be plotted.  If no FMT and no PROPERTY/VALUE pairs are given, then the default plot style is solid lines with no markers and the color determined by the "colororder" property of the current axes.

     Format arguments:

     linestyle

          '-'                                                           Use solid lines (default).
          '--'                                                          Use dashed lines.
          ':'                                                           Use dotted lines.
          '-.'                                                          Use dash-dotted lines.

     marker

          '+'                                                           crosshair
          'o'                                                           circle
          '*'                                                           star
          '.'                                                           point
          'x'                                                           cross
          's'                                                           square
          'd'                                                           diamond
          '^'                                                           upward-facing triangle
          'v'                                                           downward-facing triangle
          '>'                                                           right-facing triangle
          '<'                                                           left-facing triangle
          'p'                                                           pentagram
          'h'                                                           hexagram

     color

          'k'                                                           blacK
          'r'                                                           Red
          'g'                                                           Green
          'b'                                                           Blue
          'm'                                                           Magenta
          'c'                                                           Cyan
          'w'                                                           White

     ";displayname;"
          Here "displayname" is the label to use for the plot legend.

     The FMT argument may also be used to assign legend labels.  To do so, include the desired label between semicolons after the formatting sequence described above, e.g., "+b;Key Title;".  Note that the last semicolon is required and Octave will generate an error if it is left out.

     Here are some plot examples:

          plot (x, y, "or", x, y2, x, y3, "m", x, y4, "+")

     This command will plot 'y' with red circles, 'y2' with solid lines, 'y3' with solid magenta lines, and 'y4' with points displayed as '+'.

          plot (b, "*", "markersize", 10)

     This command will plot the data in the variable 'b', with points displayed as '*' and a marker size of 10.

          t = 0:0.1:6.3;
          plot (t, cos(t), "-;cos(t);", t, sin(t), "-b;sin(t);");

     This will plot the cosine and sine functions and label them accordingly in the legend.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the created line objects.

     To save a plot, in one of several image formats such as PostScript or PNG, use the 'print' command.

     See also: axis, box, grid, hold, legend, title, xlabel, ylabel, xlim, ylim, ezplot, errorbar, fplot, line, plot3, polar, loglog, semilogx, semilogy, subplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
Produce 2-D plots.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
plotmatrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1440
 -- Function File: plotmatrix (X, Y)
 -- Function File: plotmatrix (X)
 -- Function File: plotmatrix (..., STYLE)
 -- Function File: plotmatrix (HAX, ...)
 -- Function File: [H, AX, BIGAX, P, PAX] = plotmatrix (...)
     Scatter plot of the columns of one matrix against another.

     Given the arguments X and Y that have a matching number of rows, 'plotmatrix' plots a set of axes corresponding to

          plot (X(:, i), Y(:, j))

     When called with a single argument X this is equivalent to

          plotmatrix (X, X)

     except that the diagonal of the set of axes will be replaced with the histogram 'hist (X(:, i))'.

     The marker to use can be changed with the STYLE argument, that is a string defining a marker in the same manner as the 'plot' command.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H provides handles to the individual graphics objects in the scatter plots, whereas AX returns the handles to the scatter plot axis objects.

     BIGAX is a hidden axis object that surrounds the other axes, such that the commands 'xlabel', 'title', etc., will be associated with this hidden axis.

     Finally, P returns the graphics objects associated with the histogram and PAX the corresponding axes objects.

     Example:

          plotmatrix (randn (100, 3), "g+")

     See also: scatter, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Scatter plot of the columns of one matrix against another.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
plotyy


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1292
 -- Function File: plotyy (X1, Y1, X2, Y2)
 -- Function File: plotyy (..., FUN)
 -- Function File: plotyy (..., FUN1, FUN2)
 -- Function File: plotyy (HAX, ...)
 -- Function File: [AX, H1, H2] = plotyy (...)
     Plot two sets of data with independent y-axes and a common x-axis.

     The arguments X1 and Y1 define the arguments for the first plot and X1 and Y2 for the second.

     By default the arguments are evaluated with 'feval (@plot, X, Y)'.  However the type of plot can be modified with the FUN argument, in which case the plots are generated by 'feval (FUN, X, Y)'.  FUN can be a function handle, an inline function, or a string of a function name.

     The function to use for each of the plots can be independently defined with FUN1 and FUN2.

     If the first argument HAX is an axes handle, then it defines the principal axis in which to plot the X1 and Y1 data.

     The return value AX is a vector with the axis handles of the two y-axes.  H1 and H2 are handles to the objects generated by the plot commands.

          x = 0:0.1:2*pi;
          y1 = sin (x);
          y2 = exp (x - 1);
          ax = plotyy (x, y1, x - 1, y2, @plot, @semilogy);
          xlabel ("X");
          ylabel (ax(1), "Axis 1");
          ylabel (ax(2), "Axis 2");

     See also: plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Plot two sets of data with independent y-axes and a common x-axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
polar


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1286
 -- Function File: polar (THETA, RHO)
 -- Function File: polar (THETA, RHO, FMT)
 -- Function File: polar (CPLX)
 -- Function File: polar (CPLX, FMT)
 -- Function File: polar (HAX, ...)
 -- Function File: H = polar (...)
     Create a 2-D plot from polar coordinates THETA and RHO.

     If a single complex input CPLX is given then the real part is used for THETA and the imaginary part is used for RHO.

     The optional argument FMT specifies the line format in the same way as 'plot'.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     Implementation Note: The polar axis is drawn using line and text objects encapsulated in an hggroup.  The hggroup properties are linked to the original axes object such that altering an appearance property, for example 'fontname', will update the polar axis.  Two new properties are added to the original axes-'rtick', 'ttick'-which replace 'xtick', 'ytick'.  The first is a list of tick locations in the radial (rho) direction; The second is a list of tick locations in the angular (theta) direction specified in degrees, i.e., in the range 0-359.

     See also: rose, compass, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Create a 2-D plot from polar coordinates THETA and RHO.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
quiver3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1656
 -- Function File: quiver3 (U, V, W)
 -- Function File: quiver3 (X, Y, Z, U, V, W)
 -- Function File: quiver3 (..., S)
 -- Function File: quiver3 (..., STYLE)
 -- Function File: quiver3 (..., "filled")
 -- Function File: quiver3 (HAX, ...)
 -- Function File: H = quiver3 (...)

     Plot a 3-D vector field with arrows.

     Plot the (U, V, W) components of a vector field in an (X, Y, Z) meshgrid.  If the grid is uniform then X, Y, and Z can be specified as vectors.

     If X, Y, and Z are undefined they are assumed to be '(1:M, 1:N, 1:P)' where '[M, N] = size (U)' and 'P = max (size (W))'.

     The variable S is a scalar defining a scaling factor to use for the arrows of the field relative to the mesh spacing.  A value of 0 disables all scaling.  The default value is 0.9.

     The style to use for the plot can be defined with a line style STYLE of the same format as the 'plot' command.  If a marker is specified then markers at the grid points of the vectors are drawn rather than arrows.  If the argument "filled" is given then the markers are filled.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to a quiver object.  A quiver object regroups the components of the quiver plot (body, arrow, and marker), and allows them to be changed together.

          [x, y, z] = peaks (25);
          surf (x, y, z);
          hold on;
          [u, v, w] = surfnorm (x, y, z / 10);
          h = quiver3 (x, y, z, u, v, w);
          set (h, "maxheadsize", 0.33);

     See also: quiver, compass, feather, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Plot a 3-D vector field with arrows.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
quiver


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1545
 -- Function File: quiver (U, V)
 -- Function File: quiver (X, Y, U, V)
 -- Function File: quiver (..., S)
 -- Function File: quiver (..., STYLE)
 -- Function File: quiver (..., "filled")
 -- Function File: quiver (HAX, ...)
 -- Function File: H = quiver (...)

     Plot a 2-D vector field with arrows.

     Plot the (U, V) components of a vector field in an (X, Y) meshgrid.  If the grid is uniform then X and Y can be specified as vectors.

     If X and Y are undefined they are assumed to be '(1:M, 1:N)' where '[M, N] = size (U)'.

     The variable S is a scalar defining a scaling factor to use for the arrows of the field relative to the mesh spacing.  A value of 0 disables all scaling.  The default value is 0.9.

     The style to use for the plot can be defined with a line style STYLE of the same format as the 'plot' command.  If a marker is specified then markers at the grid points of the vectors are drawn rather than arrows.  If the argument "filled" is given then the markers are filled.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to a quiver object.  A quiver object regroups the components of the quiver plot (body, arrow, and marker), and allows them to be changed together.

     Example:

          [x, y] = meshgrid (1:2:20);
          h = quiver (x, y, sin (2*pi*x/10), sin (2*pi*y/10));
          set (h, "maxheadsize", 0.33);

     See also: quiver3, compass, feather, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Plot a 2-D vector field with arrows.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
rectangle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1517
 -- Function File: rectangle ()
 -- Function File: rectangle (..., "Position", POS)
 -- Function File: rectangle (..., "Curvature", CURV)
 -- Function File: rectangle (..., "EdgeColor", EC)
 -- Function File: rectangle (..., "FaceColor", FC)
 -- Function File: rectangle (HAX, ...)
 -- Function File: H = rectangle (...)
     Draw a rectangular patch defined by POS and CURV.

     The variable 'POS(1:2)' defines the lower left-hand corner of the patch and 'POS(3:4)' defines its width and height.  By default, the value of POS is '[0, 0, 1, 1]'.

     The variable CURV defines the curvature of the sides of the rectangle and may be a scalar or two-element vector with values between 0 and 1.  A value of 0 represents no curvature of the side, whereas a value of 1 means that the side is entirely curved into the arc of a circle.  If CURV is a two-element vector, then the first element is the curvature along the x-axis of the patch and the second along y-axis.

     If CURV is a scalar, it represents the curvature of the shorter of the two sides of the rectangle and the curvature of the other side is defined by

          min (pos(1:2)) / max (pos(1:2)) * curv

     Additional property/value pairs are passed to the underlying patch command.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created rectangle object.

See also: patch, line, cylinder, ellipsoid, sphere. 


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Draw a rectangular patch defined by POS and CURV.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ribbon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 682
 -- Function File: ribbon (Y)
 -- Function File: ribbon (X, Y)
 -- Function File: ribbon (X, Y, WIDTH)
 -- Function File: ribbon (HAX, ...)
 -- Function File: H = ribbon (...)
     Draw a ribbon plot for the columns of Y vs.  X.

     The optional parameter WIDTH specifies the width of a single ribbon (default is 0.75).  If X is omitted, a vector containing the row numbers is assumed ('1:rows (Y)').

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the surface objects representing each ribbon.

     See also: surface, waterfall.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Draw a ribbon plot for the columns of Y vs.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
rose


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1139
 -- Function File: rose (TH)
 -- Function File: rose (TH, NBINS)
 -- Function File: rose (TH, BINS)
 -- Function File: rose (HAX, ...)
 -- Function File: H = rose (...)
 -- Function File: [THOUT ROUT] = rose (...)
     Plot an angular histogram.

     With one vector argument, TH, plot the histogram with 20 angular bins.  If TH is a matrix then each column of TH produces a separate histogram.

     If NBINS is given and is a scalar, then the histogram is produced with NBIN bins.  If BINS is a vector, then the center of each bin is defined by the values of BINS and the number of bins is given by the number of elements in BINS.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a vector of graphics handles to the line objects representing each histogram.

     If two output arguments are requested then no plot is made and the polar vectors necessary to plot the histogram are returned instead.

          [th, r] = rose ([2*randn(1e5,1), pi + 2*randn(1e5,1)]);
          polar (th, r);

     See also: hist, polar.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Plot an angular histogram.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
scatter3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1692
 -- Function File: scatter3 (X, Y, Z)
 -- Function File: scatter3 (X, Y, Z, S)
 -- Function File: scatter3 (X, Y, Z, S, C)
 -- Function File: scatter3 (..., STYLE)
 -- Function File: scatter3 (..., "filled")
 -- Function File: scatter3 (..., PROP, VAL)
 -- Function File: scatter3 (HAX, ...)
 -- Function File: H = scatter3 (...)
     Draw a 3-D scatter plot.

     A marker is plotted at each point defined by the coordinates in the vectors X, Y, and Z.

     The size of the markers is determined by S, which can be a scalar or a vector of the same length as X, Y, and Z.  If S is not given, or is an empty matrix, then a default value of 8 points is used.

     The color of the markers is determined by C, which can be a string defining a fixed color; a 3-element vector giving the red, green, and blue components of the color; a vector of the same length as X that gives a scaled index into the current colormap; or an Nx3 matrix defining the RGB color of each marker individually.

     The marker to use can be changed with the STYLE argument, that is a string defining a marker in the same manner as the 'plot' command.  If no marker is specified it defaults to "o" or circles.  If the argument "filled" is given then the markers are filled.

     Additional property/value pairs are passed directly to the underlying patch object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the hggroup object representing the points.

          [x, y, z] = peaks (20);
          scatter3 (x(:), y(:), z(:), [], z(:));

     See also: scatter, patch, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Draw a 3-D scatter plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
scatter


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1697
 -- Function File: scatter (X, Y)
 -- Function File: scatter (X, Y, S)
 -- Function File: scatter (X, Y, S, C)
 -- Function File: scatter (..., STYLE)
 -- Function File: scatter (..., "filled")
 -- Function File: scatter (..., PROP, VAL, ...)
 -- Function File: scatter (HAX, ...)
 -- Function File: H = scatter (...)
     Draw a 2-D scatter plot.

     A marker is plotted at each point defined by the coordinates in the vectors X and Y.

     The size of the markers is determined by S, which can be a scalar or a vector of the same length as X and Y.  If S is not given, or is an empty matrix, then a default value of 8 points is used.

     The color of the markers is determined by C, which can be a string defining a fixed color; a 3-element vector giving the red, green, and blue components of the color; a vector of the same length as X that gives a scaled index into the current colormap; or an Nx3 matrix defining the RGB color of each marker individually.

     The marker to use can be changed with the STYLE argument, that is a string defining a marker in the same manner as the 'plot' command.  If no marker is specified it defaults to "o" or circles.  If the argument "filled" is given then the markers are filled.

     Additional property/value pairs are passed directly to the underlying patch object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created patch object.

     Example:

          x = randn (100, 1);
          y = randn (100, 1);
          scatter (x, y, [], sqrt (x.^2 + y.^2));

     See also: scatter3, patch, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Draw a 2-D scatter plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
semilogxerr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1103
 -- Function File: semilogxerr (Y, EY)
 -- Function File: semilogxerr (Y, ..., FMT)
 -- Function File: semilogxerr (X, Y, EY)
 -- Function File: semilogxerr (X, Y, ERR, FMT)
 -- Function File: semilogxerr (X, Y, LERR, UERR, FMT)
 -- Function File: semilogxerr (X, Y, EX, EY, FMT)
 -- Function File: semilogxerr (X, Y, LX, UX, LY, UY, FMT)
 -- Function File: semilogxerr (X1, Y1, ..., FMT, XN, YN, ...)
 -- Function File: semilogxerr (HAX, ...)
 -- Function File: H = semilogxerr (...)
     Produce 2-D plots using a logarithmic scale for the x-axis and errorbars at each data point.

     Many different combinations of arguments are possible.  The most common form is

          semilogxerr (X, Y, EY, FMT)

     which produces a semi-logarithmic plot of Y versus X with errors in the Y-scale defined by EY and the plot format defined by FMT.  *Note errorbar: XREFerrorbar, for available formats and additional information.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: errorbar, semilogyerr, loglogerr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 92
Produce 2-D plots using a logarithmic scale for the x-axis and errorbars at each data point.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
semilogx


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 653
 -- Function File: semilogx (Y)
 -- Function File: semilogx (X, Y)
 -- Function File: semilogx (X, Y, PROPERTY, VALUE, ...)
 -- Function File: semilogx (X, Y, FMT)
 -- Function File: semilogx (HAX, ...)
 -- Function File: H = semilogx (...)
     Produce a 2-D plot using a logarithmic scale for the x-axis.

     See the documentation of 'plot' for a description of the arguments that 'semilogx' will accept.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     See also: plot, semilogy, loglog.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Produce a 2-D plot using a logarithmic scale for the x-axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
semilogyerr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1103
 -- Function File: semilogyerr (Y, EY)
 -- Function File: semilogyerr (Y, ..., FMT)
 -- Function File: semilogyerr (X, Y, EY)
 -- Function File: semilogyerr (X, Y, ERR, FMT)
 -- Function File: semilogyerr (X, Y, LERR, UERR, FMT)
 -- Function File: semilogyerr (X, Y, EX, EY, FMT)
 -- Function File: semilogyerr (X, Y, LX, UX, LY, UY, FMT)
 -- Function File: semilogyerr (X1, Y1, ..., FMT, XN, YN, ...)
 -- Function File: semilogyerr (HAX, ...)
 -- Function File: H = semilogyerr (...)
     Produce 2-D plots using a logarithmic scale for the y-axis and errorbars at each data point.

     Many different combinations of arguments are possible.  The most common form is

          semilogyerr (X, Y, EY, FMT)

     which produces a semi-logarithmic plot of Y versus X with errors in the Y-scale defined by EY and the plot format defined by FMT.  *Note errorbar: XREFerrorbar, for available formats and additional information.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     See also: errorbar, semilogxerr, loglogerr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 92
Produce 2-D plots using a logarithmic scale for the y-axis and errorbars at each data point.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
semilogy


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 651
 -- Function File: semilogy (Y)
 -- Function File: semilogy (X, Y)
 -- Function File: semilogy (X, Y, PROPERTY, VALUE, ...)
 -- Function File: semilogy (X, Y, FMT)
 -- Function File: semilogy (H, ...)
 -- Function File: H = semilogy (...)
     Produce a 2-D plot using a logarithmic scale for the y-axis.

     See the documentation of 'plot' for a description of the arguments that 'semilogy' will accept.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created plot.

     See also: plot, semilogx, loglog.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Produce a 2-D plot using a logarithmic scale for the y-axis.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
shrinkfaces


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1714
 -- Function File: shrinkfaces (P, SF)
 -- Function File: NFV = shrinkfaces (P, SF)
 -- Function File: NFV = shrinkfaces (FV, SF)
 -- Function File: NFV = shrinkfaces (F, V, SF)
 -- Function File: [NF, NV] = shrinkfaces (...)

     Reduce the size of faces in a patch by the shrink factor SF.

     The patch object can be specified by a graphics handle (P), a patch structure (FV) with the fields "faces" and "vertices", or as two separate matrices (F, V) of faces and vertices.

     The shrink factor SF is a positive number specifying the percentage of the original area the new face will occupy.  If no factor is given the default is 0.3 (a reduction to 30% of the original size).  A factor greater than 1.0 will result in the expansion of faces.

     Given a patch handle as the first input argument and no output parameters, perform the shrinking of the patch faces in place and redraw the patch.

     If called with one output argument, return a structure with fields "faces", "vertices", and "facevertexcdata" containing the data after shrinking.  This structure can be used directly as an input argument to the 'patch' function.

     *Caution:*: Performing the shrink operation on faces which are not convex can lead to undesirable results.

     Example: a triangulated 3/4 circle and the corresponding shrunken version.

          [phi r] = meshgrid (linspace (0, 1.5*pi, 16), linspace (1, 2, 4));
          tri = delaunay (phi(:), r(:));
          v = [r(:).*sin(phi(:)) r(:).*cos(phi(:))];
          clf ()
          p = patch ("Faces", tri, "Vertices", v, "FaceColor", "none");
          fv = shrinkfaces (p);
          patch (fv)
          axis equal
          grid on

     See also: patch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Reduce the size of faces in a patch by the shrink factor SF.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
slice


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1900
 -- Function File: slice (X, Y, Z, V, SX, SY, SZ)
 -- Function File: slice (X, Y, Z, V, XI, YI, ZI)
 -- Function File: slice (V, SX, SY, SZ)
 -- Function File: slice (V, XI, YI, ZI)
 -- Function File: slice (..., METHOD)
 -- Function File: slice (HAX, ...)
 -- Function File: H = slice (...)
     Plot slices of 3-D data/scalar fields.

     Each element of the 3-dimensional array V represents a scalar value at a location given by the parameters X, Y, and Z.  The parameters X, X, and Z are either 3-dimensional arrays of the same size as the array V in the "meshgrid" format or vectors.  The parameters XI, etc.  respect a similar format to X, etc., and they represent the points at which the array VI is interpolated using interp3.  The vectors SX, SY, and SZ contain points of orthogonal slices of the respective axes.

     If X, Y, Z are omitted, they are assumed to be 'x = 1:size (V, 2)', 'y = 1:size (V, 1)' and 'z = 1:size (V, 3)'.

     METHOD is one of:

     "nearest"
          Return the nearest neighbor.

     "linear"
          Linear interpolation from nearest neighbors.

     "cubic"
          Cubic interpolation from four nearest neighbors (not implemented yet).

     "spline"
          Cubic spline interpolation--smooth first and second derivatives throughout the curve.

     The default method is "linear".

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Examples:

          [x, y, z] = meshgrid (linspace (-8, 8, 32));
          v = sin (sqrt (x.^2 + y.^2 + z.^2)) ./ (sqrt (x.^2 + y.^2 + z.^2));
          slice (x, y, z, v, [], 0, []);

          [xi, yi] = meshgrid (linspace (-7, 7));
          zi = xi + yi;
          slice (x, y, z, v, xi, yi, zi);

     See also: interp3, surface, pcolor.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Plot slices of 3-D data/scalar fields.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
sombrero


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 711
 -- Function File: sombrero ()
 -- Function File: sombrero (N)
 -- Function File: Z = sombrero (...)
 -- Function File: [X, Y, Z] = sombrero (...)
     Plot the familiar 3-D sombrero function.

     The function plotted is

          z = sin (sqrt (x^2 + y^2)) / (sqrt (x^2 + y^2))

     Called without a return argument, 'sombrero' plots the surface of the above function over the meshgrid [-8,8] using 'surf'.

     If N is a scalar the plot is made with N grid lines.  The default value for N is 41.

     When called with output arguments, return the data for the function evaluated over the meshgrid.  This can subsequently be plotted with 'surf (X, Y, Z)'.

     See also: peaks, meshgrid, mesh, surf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Plot the familiar 3-D sombrero function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
sphere


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 750
 -- Function File: sphere ()
 -- Function File: sphere (N)
 -- Function File: sphere (HAX, ...)
 -- Function File: [X, Y, Z] = sphere (...)
     Plot a 3-D unit sphere.

     The optional input N determines the number of faces around the circumference of the sphere.  The default value is 20.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     If outputs are requested 'sphere' returns three matrices in 'meshgrid' format such that 'surf (X, Y, Z)' generates a unit sphere.

     Example:

          [x, y, z] = sphere (40);
          surf (3*x, 3*y, 3*z);
          axis equal;
          title ("sphere of radius 3");

     See also: cylinder, ellipsoid, rectangle.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Plot a 3-D unit sphere.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
stairs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1173
 -- Function File: stairs (Y)
 -- Function File: stairs (X, Y)
 -- Function File: stairs (..., STYLE)
 -- Function File: stairs (..., PROP, VAL, ...)
 -- Function File: stairs (HAX, ...)
 -- Function File: H = stairs (...)
 -- Function File: [XSTEP, YSTEP] = stairs (...)
     Produce a stairstep plot.

     The arguments X and Y may be vectors or matrices.  If only one argument is given, it is taken as a vector of Y values and the X coordinates are taken to be the indices of the elements.

     The style to use for the plot can be defined with a line style STYLE of the same format as the 'plot' command.

     Multiple property/value pairs may be specified, but they must appear in pairs.

     If the first argument HAX is an axis handle, then plot into this axis, rather than the current axis handle returned by 'gca'.

     If one output argument is requested, return a graphics handle to the created plot.  If two output arguments are specified, the data are generated but not plotted.  For example,

          stairs (x, y);

     and

          [xs, ys] = stairs (x, y);
          plot (xs, ys);

     are equivalent.

     See also: bar, hist, plot, stem.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Produce a stairstep plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
stem3


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1350
 -- Function File: stem3 (X, Y, Z)
 -- Function File: stem3 (..., LINESPEC)
 -- Function File: stem3 (..., "filled")
 -- Function File: stem3 (..., PROP, VAL, ...)
 -- Function File: stem3 (HAX, ...)
 -- Function File: H = stem3 (...)
     Plot a 3-D stem graph.

     Stems are drawn from the height Z to the location in the x-y plane determined by X and Y.  The default color is "b" (blue), the default line style is "-", and the default marker is "o".

     The line style can be altered by the 'linespec' argument in the same manner as the 'plot' command.  If the "filled" argument is present the markers at the top of the stems will be filled in.

     Optional property/value pairs may be specified to control the appearance of the plot.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a handle to the "stem series" hggroup containing the line and marker objects used for the plot.  *Note stem: XREFstem, for a description of the "stem series" object.

     Example:

          theta = 0:0.2:6;
          stem3 (cos (theta), sin (theta), theta);

     plots 31 stems with heights from 0 to 6 lying on a circle.

     Implementation Note: Color definitions with RGB-triples are not valid.

     See also: stem, bar, hist, plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Plot a 3-D stem graph.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
stemleaf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2454
 -- Function File: stemleaf (X, CAPTION)
 -- Function File: stemleaf (X, CAPTION, STEM_SZ)
 -- Function File: PLOTSTR = stemleaf (...)
     Compute and display a stem and leaf plot of the vector X.

     The input X should be a vector of integers.  Any non-integer values will be converted to integer by 'X = fix (X)'.  By default each element of X will be plotted with the last digit of the element as a leaf value and the remaining digits as the stem.  For example, 123 will be plotted with the stem '12' and the leaf '3'.  The second argument, CAPTION, should be a character array which provides a description of the data.  It is included as a heading for the output.

     The optional input STEM_SZ sets the width of each stem.  The stem width is determined by '10^(STEM_SZ + 1)'.  The default stem width is 10.

     The output of 'stemleaf' is composed of two parts: a "Fenced Letter Display," followed by the stem-and-leaf plot itself.  The Fenced Letter Display is described in 'Exploratory Data Analysis'.  Briefly, the entries are as shown:


                  Fenced Letter Display
          #% nx|___________________     nx = numel (x)
          M% mi|       md         |     mi median index, md median
          H% hi|hl              hu| hs  hi lower hinge index, hl,hu hinges,
          1    |x(1)         x(nx)|     hs h_spreadx(1), x(nx) first
                     _______            and last data value.
               ______|step |_______     step 1.5*h_spread
              f|ifl            ifh|     inner fence, lower and higher
               |nfl            nfh|     no.\ of data points within fences
              F|ofl            ofh|     outer fence, lower and higher
               |nFl            nFh|     no.\ of data points outside outer
                                        fences

     The stem-and-leaf plot shows on each line the stem value followed by the string made up of the leaf digits.  If the STEM_SZ is not 1 the successive leaf values are separated by ",".

     With no return argument, the plot is immediately displayed.  If an output argument is provided, the plot is returned as an array of strings.

     The leaf digits are not sorted.  If sorted leaf values are desired, use 'XS = sort (X)' before calling 'stemleaf (XS)'.

     The stem and leaf plot and associated displays are described in: Ch.  3, 'Exploratory Data Analysis' by J. W. Tukey, Addison-Wesley, 1977.

     See also: hist, printd.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Compute and display a stem and leaf plot of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
stem


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2780
 -- Function File: stem (Y)
 -- Function File: stem (X, Y)
 -- Function File: stem (..., LINESPEC)
 -- Function File: stem (..., "filled")
 -- Function File: stem (..., PROP, VAL, ...)
 -- Function File: stem (HAX, ...)
 -- Function File: H = stem (...)
     Plot a 2-D stem graph.

     If only one argument is given, it is taken as the y-values and the x-coordinates are taken from the indices of the elements.

     If Y is a matrix, then each column of the matrix is plotted as a separate stem graph.  In this case X can either be a vector, the same length as the number of rows in Y, or it can be a matrix of the same size as Y.

     The default color is "b" (blue), the default line style is "-", and the default marker is "o".  The line style can be altered by the 'linespec' argument in the same manner as the 'plot' command.  If the "filled" argument is present the markers at the top of the stems will be filled in.  For example,

          x = 1:10;
          y = 2*x;
          stem (x, y, "r");

     plots 10 stems with heights from 2 to 20 in red;

     Optional property/value pairs may be specified to control the appearance of the plot.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a handle to a "stem series" hggroup.  The single hggroup handle has all of the graphical elements comprising the plot as its children; This allows the properties of multiple graphics objects to be changed by modifying just a single property of the "stem series" hggroup.

     For example,

          x = [0:10]';
          y = [sin(x), cos(x)]
          h = stem (x, y);
          set (h(2), "color", "g");
          set (h(1), "basevalue", -1)

     changes the color of the second "stem series" and moves the base line of the first.

     Stem Series Properties

     linestyle
          The linestyle of the stem.  (Default: "-")

     linewidth
          The width of the stem.  (Default: 0.5)

     color
          The color of the stem, and if not separately specified, the marker.  (Default: "b" [blue])

     marker
          The marker symbol to use at the top of each stem.  (Default: "o")

     markeredgecolor
          The edge color of the marker.  (Default: "color" property)

     markerfacecolor
          The color to use for "filling" the marker.  (Default: "none" [unfilled])

     markersize
          The size of the marker.  (Default: 6)

     baseline
          The handle of the line object which implements the baseline.  Use 'set' with the returned handle to change graphic properties of the baseline.

     basevalue
          The y-value where the baseline is drawn.  (Default: 0)

     See also: stem3, bar, hist, plot, stairs.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Plot a 2-D stem graph.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
surface


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1026
 -- Function File: surface (X, Y, Z, C)
 -- Function File: surface (X, Y, Z)
 -- Function File: surface (Z, C)
 -- Function File: surface (Z)
 -- Function File: surface (..., PROP, VAL, ...)
 -- Function File: surface (HAX, ...)
 -- Function File: H = surface (...)
     Create a surface graphic object given matrices X and Y from 'meshgrid' and a matrix of values Z corresponding to the X and Y coordinates of the surface.

     If X and Y are vectors, then a typical vertex is (X(j), Y(i), Z(i,j)).  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.  If only a single input Z is given then X is taken to be '1:rows (Z)' and Y is '1:columns (Z)'.

     Any property/value input pairs are assigned to the surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     See also: surf, mesh, patch, line.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
Create a surface graphic object given matrices X and Y from 'meshgrid' and a matrix of values Z corresponding to the X and Y coordinates of the surface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
surfc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1601
 -- Function File: surfc (X, Y, Z)
 -- Function File: surfc (Z)
 -- Function File: surfc (..., C)
 -- Function File: surfc (..., PROP, VAL, ...)
 -- Function File: surfc (HAX, ...)
 -- Function File: H = surfc (...)
     Plot a 3-D surface mesh with underlying contour lines.

     The surface mesh is plotted using shaded rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the surface is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally, the color of the surface can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Note: The exact appearance of the surface can be controlled with the 'shading' command or by using 'set' to control surface object properties.

     See also: ezsurfc, surf, surfl, surfnorm, trisurf, contour, mesh, surface, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Plot a 3-D surface mesh with underlying contour lines.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
surfl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2011
 -- Function File: surfl (Z)
 -- Function File: surfl (X, Y, Z)
 -- Function File: surfl (..., LSRC)
 -- Function File: surfl (X, Y, Z, LSRC, P)
 -- Function File: surfl (..., "cdata")
 -- Function File: surfl (..., "light")
 -- Function File: surfl (HAX, ...)
 -- Function File: H = surfl (...)
     Plot a 3-D surface using shading based on various lighting models.

     The surface mesh is plotted using shaded rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The default lighting mode "cdata", changes the cdata property of the surface object to give the impression of a lighted surface.  *Warning:* The alternative mode "light" mode which creates a light object to illuminate the surface is not implemented (yet).

     The light source location can be specified using LSRC.  It can be given as a 2-element vector [azimuth, elevation] in degrees, or as a 3-element vector [lx, ly, lz].  The default value is rotated 45 degrees counterclockwise to the current view.

     The material properties of the surface can specified using a 4-element vector P = [AM D SP EXP] which defaults to P = [0.55 0.6 0.4 10].

     "AM" strength of ambient light

     "D" strength of diffuse reflection

     "SP" strength of specular reflection

     "EXP" specular exponent

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Example:

          colormap (bone (64));
          surfl (peaks);
          shading interp;

     See also: diffuse, specular, surf, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Plot a 3-D surface using shading based on various lighting models.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
surf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1565
 -- Function File: surf (X, Y, Z)
 -- Function File: surf (Z)
 -- Function File: surf (..., C)
 -- Function File: surf (..., PROP, VAL, ...)
 -- Function File: surf (HAX, ...)
 -- Function File: H = surf (...)
     Plot a 3-D surface mesh.

     The surface mesh is plotted using shaded rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the surface is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally, the color of the surface can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     Note: The exact appearance of the surface can be controlled with the 'shading' command or by using 'set' to control surface object properties.

     See also: ezsurf, surfc, surfl, surfnorm, trisurf, contour, mesh, surface, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
Plot a 3-D surface mesh.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
surfnorm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1460
 -- Function File: surfnorm (X, Y, Z)
 -- Function File: surfnorm (Z)
 -- Function File: surfnorm (..., PROP, VAL, ...)
 -- Function File: surfnorm (HAX, ...)
 -- Function File: [NX, NY, NZ] = surfnorm (...)
     Find the vectors normal to a meshgridded surface.

     If X and Y are vectors, then a typical vertex is (X(j), Y(i), Z(i,j)).  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.  If only a single input Z is given then X is taken to be '1:rows (Z)' and Y is '1:columns (Z)'.

     If no return arguments are requested, a surface plot with the normal vectors to the surface is plotted.

     Any property/value input pairs are assigned to the surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     If output arguments are requested then the components of the normal vectors are returned in NX, NY, and NZ and no plot is made.

     An example of the use of 'surfnorm' is

          surfnorm (peaks (25));

     Algorithm: The normal vectors are calculated by taking the cross product of the diagonals of each of the quadrilaterals in the meshgrid to find the normal vectors of the centers of these quadrilaterals.  The four nearest normal vectors to the meshgrid points are then averaged to obtain the normal to the surface at the meshgridded points.

     See also: isonormals, quiver3, surf, meshgrid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Find the vectors normal to a meshgridded surface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
tetramesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1305
 -- Function File: tetramesh (T, X)
 -- Function File: tetramesh (T, X, C)
 -- Function File: tetramesh (..., PROPERTY, VAL, ...)
 -- Function File: H = tetramesh (...)
     Display the tetrahedrons defined in the m-by-4 matrix T as 3-D patches.

     T is typically the output of a Delaunay triangulation of a 3-D set of points.  Every row of T contains four indices into the n-by-3 matrix X of the vertices of a tetrahedron.  Every row in X represents one point in 3-D space.

     The vector C specifies the color of each tetrahedron as an index into the current colormap.  The default value is 1:m where m is the number of tetrahedrons; the indices are scaled to map to the full range of the colormap.  If there are more tetrahedrons than colors in the colormap then the values in C are cyclically repeated.

     Calling 'tetramesh (..., "property", "value", ...)' passes all property/value pairs directly to the patch function as additional arguments.

     The optional return value H is a vector of patch handles where each handle represents one tetrahedron in the order given by T.  A typical use case for H is to turn the respective patch "visible" property "on" or "off".

     Type 'demo tetramesh' to see examples on using 'tetramesh'.

     See also: trimesh, delaunay, delaunayn, patch.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Display the tetrahedrons defined in the m-by-4 matrix T as 3-D patches.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
trimesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1357
 -- Function File: trimesh (TRI, X, Y, Z, C)
 -- Function File: trimesh (TRI, X, Y, Z)
 -- Function File: trimesh (TRI, X, Y)
 -- Function File: trimesh (..., PROP, VAL, ...)
 -- Function File: H = trimesh (...)
     Plot a 3-D triangular wireframe mesh.

     In contrast to 'mesh', which plots a mesh using rectangles, 'trimesh' plots the mesh using triangles.

     TRI is typically the output of a Delaunay triangulation over the grid of X, Y.  Every row of TRI represents one triangle and contains three indices into [X, Y] which are the vertices of the triangles in the x-y plane.  Z determines the height above the plane of each vertex.  If no Z input is given then the triangles are plotted as a 2-D figure.

     The color of the trimesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally, the color of the mesh can be specified independently of Z by supplying a color matrix, C.  If Z has N elements, then C should be an Nx1 vector for colormap data or an Nx3 matrix for RGB data.

     Any property/value pairs are passed directly to the underlying patch object.

     The optional return value H is a graphics handle to the created patch object.

     See also: mesh, tetramesh, triplot, trisurf, delaunay, patch, hidden.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Plot a 3-D triangular wireframe mesh.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
triplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 643
 -- Function File: triplot (TRI, X, Y)
 -- Function File: triplot (TRI, X, Y, LINESPEC)
 -- Function File: H = triplot (...)
     Plot a 2-D triangular mesh.

     TRI is typically the output of a Delaunay triangulation over the grid of X, Y.  Every row of TRI represents one triangle and contains three indices into [X, Y] which are the vertices of the triangles in the x-y plane.

     The linestyle to use for the plot can be defined with the argument LINESPEC of the same format as the 'plot' command.

     The optional return value H is a graphics handle to the created patch object.

     See also: plot, trimesh, trisurf, delaunay.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
Plot a 2-D triangular mesh.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
trisurf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1237
 -- Function File: trisurf (TRI, X, Y, Z, C)
 -- Function File: trisurf (TRI, X, Y, Z)
 -- Function File: trisurf (..., PROP, VAL, ...)
 -- Function File: H = trisurf (...)
     Plot a 3-D triangular surface.

     In contrast to 'surf', which plots a surface mesh using rectangles, 'trisurf' plots the mesh using triangles.

     TRI is typically the output of a Delaunay triangulation over the grid of X, Y.  Every row of TRI represents one triangle and contains three indices into [X, Y] which are the vertices of the triangles in the x-y plane.  Z determines the height above the plane of each vertex.

     The color of the trimesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally, the color of the mesh can be specified independently of Z by supplying a color matrix, C.  If Z has N elements, then C should be an Nx1 vector for colormap data or an Nx3 matrix for RGB data.

     Any property/value pairs are passed directly to the underlying patch object.

     The optional return value H is a graphics handle to the created patch object.

     See also: surf, triplot, trimesh, delaunay, patch, shading.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Plot a 3-D triangular surface.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
waterfall


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1538
 -- Function File: waterfall (X, Y, Z)
 -- Function File: waterfall (Z)
 -- Function File: waterfall (..., C)
 -- Function File: waterfall (..., PROP, VAL, ...)
 -- Function File: waterfall (HAX, ...)
 -- Function File: H = waterfall (...)
     Plot a 3-D waterfall plot.

     A waterfall plot is similar to a 'meshz' plot except only mesh lines for the rows of Z (x-values) are shown.

     The wireframe mesh is plotted using rectangles.  The vertices of the rectangles [X, Y] are typically the output of 'meshgrid'.  over a 2-D rectangular region in the x-y plane.  Z determines the height above the plane of each vertex.  If only a single Z matrix is given, then it is plotted over the meshgrid 'X = 1:columns (Z), Y = 1:rows (Z)'.  Thus, columns of Z correspond to different X values and rows of Z correspond to different Y values.

     The color of the mesh is computed by linearly scaling the Z values to fit the range of the current colormap.  Use 'caxis' and/or change the colormap to control the appearance.

     Optionally the color of the mesh can be specified independently of Z by supplying a color matrix, C.

     Any property/value pairs are passed directly to the underlying surface object.

     If the first argument HAX is an axes handle, then plot into this axis, rather than the current axes returned by 'gca'.

     The optional return value H is a graphics handle to the created surface object.

     See also: meshz, mesh, meshc, contour, surf, surface, ribbon, meshgrid, hidden, shading, colormap, caxis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Plot a 3-D waterfall plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
allchild


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 441
 -- Function File: H = allchild (HANDLES)
     Find all children, including hidden children, of a graphics object.

     This function is similar to 'get (h, "children")', but also returns hidden objects (HandleVisibility = "off").

     If HANDLES is a scalar, H will be a vector.  Otherwise, H will be a cell matrix of the same size as HANDLES and each cell will contain a vector of handles.

     See also: findall, findobj, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Find all children, including hidden children, of a graphics object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ancestor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 605
 -- Function File: PARENT = ancestor (H, TYPE)
 -- Function File: PARENT = ancestor (H, TYPE, "toplevel")
     Return the first ancestor of handle object H whose type matches TYPE, where TYPE is a character string.

     If TYPE is a cell array of strings, return the first parent whose type matches any of the given type strings.

     If the handle object H itself is of type TYPE, return H.

     If "toplevel" is given as a third argument, return the highest parent in the object hierarchy that matches the condition, instead of the first (nearest) one.

     See also: findobj, findall, allchild.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Return the first ancestor of handle object H whose type matches TYPE, where TYPE is a character string.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
axes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 708
 -- Function File: axes ()
 -- Function File: axes (PROPERTY, VALUE, ...)
 -- Function File: axes (HAX)
 -- Function File: H = axes (...)
     Create an axes object and return a handle to it, or set the current axes to HAX.

     Called without any arguments, or with PROPERTY/VALUE pairs, construct a new axes.  For accepted properties and corresponding values, *note set: XREFset.

     Called with a single axes handle argument HAX, the function makes HAX the current axis.  It also restacks the axes in the corresponding figure so that HAX is the first entry in the list of children.  This causes HAX to be displayed on top of any other axes objects (Z-order stacking).

     See also: gca, set, get.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Create an axes object and return a handle to it, or set the current axes to HAX.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
cla


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 633
 -- Command: cla
 -- Command: cla reset
 -- Function File: cla (HAX)
 -- Function File: cla (HAX, "reset")
     Clear the current axes.

     'cla' operates by deleting child graphic objects with visible handles (HandleVisibility = "on").

     If the optional argument "reset" is specified, delete all child objects including those with hidden handles and reset all axis properties to their defaults.  However, the following properties are not reset: Position, Units.

     If the first argument HAX is an axes handle, then operate on this axis rather than the current axes returned by 'gca'.

     See also: clf, delete, reset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Clear the current axes.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
clf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 816
 -- Command: clf
 -- Command: clf reset
 -- Function File: clf (HFIG)
 -- Function File: clf (HFIG, "reset")
 -- Function File: H = clf (...)
     Clear the current figure window.

     'clf' operates by deleting child graphics objects with visible handles (HandleVisibility = "on").

     If the optional argument "reset" is specified, delete all child objects including those with hidden handles and reset all figure properties to their defaults.  However, the following properties are not reset: Position, Units, PaperPosition, PaperUnits.

     If the first argument HFIG is a figure handle, then operate on this figure rather than the current figure returned by 'gcf'.

     The optional return value H is the graphics handle of the figure window that was cleared.

     See also: cla, close, delete, reset.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Clear the current figure window.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
close


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1190
 -- Command: close
 -- Command: close (H)
 -- Command: close H
 -- Command: close all
 -- Command: close all hidden
 -- Command: close all force
     Close figure window(s).

     When called with no arguments, close the current figure.  This is equivalent to 'close (gcf)'.  If the input H is a graphic handle, or vector of graphics handles, then close each figure in H.

     If the argument "all" is given then all figures with visible handles (HandleVisibility = "on") are closed.

     If the argument "all hidden" is given then all figures, including hidden ones, are closed.

     If the argument "all force" is given then all figures are closed even when "closerequestfcn" has been altered to prevent closing the window.

     Implementation Note: 'close' operates by calling the function specified by the "closerequestfcn" property for each figure.  By default, the function 'closereq' is used.  It is possible that the function invoked will delay or abort removing the figure.  To remove a figure without executing any callback functions use 'delete'.  When writing a callback function to close a window do not use 'close' to avoid recursion.

     See also: closereq, delete.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Close figure window(s).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
closereq


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 -- Function File: closereq ()
     Close the current figure and delete all graphics objects associated with it.

     By default, the "closerequestfcn" property of a new plot figure points to this function.

     See also: close, delete.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Close the current figure and delete all graphics objects associated with it.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
colstyle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 -- Function File: [STYLE, COLOR, MARKER, MSG] = colstyle (LINESPEC)
     Parse LINESPEC and return the line style, color, and markers given.

     In the case of an error, the string MSG will return the text of the error.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
Parse LINESPEC and return the line style, color, and markers given.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
copyobj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 399
 -- Function File: HNEW = copyobj (HORIG)
 -- Function File: HNEW = copyobj (HORIG, HPARENT)
     Construct a copy of the graphic object associated with handle HORIG and return a handle HNEW to the new object.

     If a parent handle HPARENT (root, figure, axes, or hggroup) is specified, the copied object will be created as a child of HPARENT.

     See also: struct2hdl, hdl2struct, findobj.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 111
Construct a copy of the graphic object associated with handle HORIG and return a handle HNEW to the new object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
figure


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 763
 -- Command: figure
 -- Command: figure N
 -- Function File: figure (N)
 -- Function File: figure (..., "PROPERTY", VALUE, ...)
 -- Function File: H = figure (...)
     Create a new figure window for plotting.

     If no arguments are specified, a new figure with the next available number is created.

     If called with an integer N, and no such numbered figure exists, then a new figure with the specified number is created.  If the figure already exists then it is made visible and becomes the current figure for plotting.

     Multiple property-value pairs may be specified for the figure object, but they must appear in pairs.

     The optional return value H is a graphics handle to the created figure object.

     See also: axes, gcf, clf, close.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Create a new figure window for plotting.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
findall


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 832
 -- Function File: H = findall ()
 -- Function File: H = findall (PROP_NAME, PROP_VALUE, ...)
 -- Function File: H = findall (PROP_NAME, PROP_VALUE, "-LOGICAL_OP", PROP_NAME, PROP_VALUE)
 -- Function File: H = findall ("-property", PROP_NAME)
 -- Function File: H = findall ("-regexp", PROP_NAME, PATTERN)
 -- Function File: H = findall (HLIST, ...)
 -- Function File: H = findall (HLIST, "flat", ...)
 -- Function File: H = findall (HLIST, "-depth", D, ...)
     Find graphics object, including hidden ones, with specified property values.

     The return value H is a list of handles to the found graphic objects.

     'findall' performs the same search as 'findobj', but it includes hidden objects (HandleVisibility = "off").  For full documentation, *note findobj: XREFfindobj.

     See also: findobj, allchild, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Find graphics object, including hidden ones, with specified property values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
findfigs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 173
 -- Function File: findfigs ()
     Find all visible figures that are currently off the screen and move them onto the screen.

     See also: allchild, figure, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Find all visible figures that are currently off the screen and move them onto the screen.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
findobj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1988
 -- Function File: H = findobj ()
 -- Function File: H = findobj (PROP_NAME, PROP_VALUE, ...)
 -- Function File: H = findobj (PROP_NAME, PROP_VALUE, "-LOGICAL_OP", PROP_NAME, PROP_VALUE)
 -- Function File: H = findobj ("-property", PROP_NAME)
 -- Function File: H = findobj ("-regexp", PROP_NAME, PATTERN)
 -- Function File: H = findobj (HLIST, ...)
 -- Function File: H = findobj (HLIST, "flat", ...)
 -- Function File: H = findobj (HLIST, "-depth", D, ...)
     Find graphics object with specified property values.

     The simplest form is

          findobj (PROP_NAME, PROP_VALUE)

     which returns the handles of all objects which have a property named PROP_NAME that has the value PROP_VALUE.  If multiple property/value pairs are specified then only objects meeting all of the conditions are returned.

     The search can be limited to a particular set of objects and their descendants, by passing a handle or set of handles HLIST as the first argument.

     The depth of the object hierarchy to search can be limited with the "-depth" argument.  An example of searching only three generations of children is:

          findobj (HLIST, "-depth", 3, PROP_NAME, PROP_VALUE)

     Specifying a depth D of 0, limits the search to the set of objects passed in HLIST.  A depth D of 0 is equivalent to the "flat" argument.

     A specified logical operator may be applied to the pairs of PROP_NAME and PROP_VALUE.  The supported logical operators are: "-and", "-or", "-xor", "-not".

     Objects may also be matched by comparing a regular expression to the property values, where property values that match 'regexp (PROP_VALUE, PATTERN)' are returned.

     Finally, objects may be matched by property name only by using the "-property" option.

     Implementation Note: The search only includes objects with visible handles (HandleVisibility = "on").  *Note findall: XREFfindall, to search for all objects including hidden ones.

     See also: findall, allchild, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Find graphics object with specified property values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
frame2im


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 420
 -- Function File: [X, MAP] = frame2im (F)
     Convert movie frame to indexed image.

     A movie frame is simply a struct with the fields "cdata" and "colormap".

     Support for N-dimensional images or movies is given when F is a struct array.  In such cases, X will be a MxNx1xK or MxNx3xK for indexed and RGB movies respectively, with each frame concatenated along the 4th dimension.

     See also: im2frame.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Convert movie frame to indexed image.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
gca


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 840
 -- Function File: H = gca ()
     Return a handle to the current axis object.

     The current axis is the default target for graphics output.  In the case of a figure with multiple axes, 'gca' returns the last created axes or the last axes that was clicked on with the mouse.

     If no current axes object exists, create one and return its handle.  The handle may then be used to examine or set properties of the axes.  For example,

          ax = gca ();
          set (ax, "position", [0.5, 0.5, 0.5, 0.5]);

     creates an empty axes object and then changes its location and size in the figure window.

     Note: To find the current axis without creating a new axes object if it does not exist, query the "CurrentAxes" property of a figure.

          get (gcf, "currentaxes");

     See also: gcf, gco, gcbf, gcbo, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Return a handle to the current axis object.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
gcbf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 345
 -- Function File: FIG = gcbf ()
     Return a handle to the figure containing the object whose callback is currently executing.

     If no callback is executing, this function returns the empty matrix.  The handle returned by this function is the same as the second output argument of 'gcbo'.

     See also: gcbo, gcf, gco, gca, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Return a handle to the figure containing the object whose callback is currently executing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
gcbo


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 563
 -- Function File: H = gcbo ()
 -- Function File: [H, FIG] = gcbo ()
     Return a handle to the object whose callback is currently executing.

     If no callback is executing, this function returns the empty matrix.  This handle is obtained from the root object property "CallbackObject".

     When called with a second output argument, return the handle of the figure containing the object whose callback is currently executing.  If no callback is executing the second output is also set to the empty matrix.

     See also: gcbf, gco, gca, gcf, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Return a handle to the object whose callback is currently executing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
gcf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 914
 -- Function File: H = gcf ()
     Return a handle to the current figure.

     The current figure is the default target for graphics output.  If multiple figures exist, 'gcf' returns the last created figure or the last figure that was clicked on with the mouse.

     If a current figure does not exist, create one and return its handle.  The handle may then be used to examine or set properties of the figure.  For example,

          fplot (@sin, [-10, 10]);
          fig = gcf ();
          set (fig, "numbertitle", "off", "name", "sin plot")

     plots a sine wave, finds the handle of the current figure, and then renames the figure window to describe the contents.

     Note: To find the current figure without creating a new one if it does not exist, query the "CurrentFigure" property of the root graphics object.

          get (0, "currentfigure");

     See also: gca, gco, gcbf, gcbo, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Return a handle to the current figure.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
gco


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 855
 -- Function File: H = gco ()
 -- Function File: H = gco (FIG)
     Return a handle to the current object of the current figure, or a handle to the current object of the figure with handle FIG.

     The current object of a figure is the object that was last clicked on.  It is stored in the "CurrentObject" property of the target figure.

     If the last mouse click did not occur on any child object of the figure, then the current object is the figure itself.

     If no mouse click occurred in the target figure, this function returns an empty matrix.

     Programming Note: The value returned by this function is not necessarily the same as the one returned by 'gcbo' during callback execution.  An executing callback can be interrupted by another callback and the current object may be changed.

     See also: gcbo, gca, gcf, gcbf, get, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
Return a handle to the current object of the current figure, or a handle to the current object of the figure with handle FIG.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ginput


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 849
 -- Function File: [X, Y, BUTTONS] = ginput (N)
 -- Function File: [X, Y, BUTTONS] = ginput ()
     Return the position and type of mouse button clicks and/or key strokes in the current figure window.

     If N is defined, then capture N events before returning.  When N is not defined 'ginput' will loop until the return key <RET> is pressed.

     The return values X, Y are the coordinates where the mouse was clicked in the units of the current axes.  The return value BUTTON is 1, 2, or 3 for the left, middle, or right button.  If a key is pressed the ASCII value is returned in BUTTON.

     Implementation Note: 'ginput' is intenteded for 2-D plots.  For 3-D plots see the CURRENTPOINT property of the current axes which can be transformed with knowledge of the current 'view' into data units.

     See also: gtext, waitforbuttonpress.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 100
Return the position and type of mouse button clicks and/or key strokes in the current figure window.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
graphics_toolkit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 817
 -- Function File: NAME = graphics_toolkit ()
 -- Function File: NAME = graphics_toolkit (HLIST)
 -- Function File: graphics_toolkit (NAME)
 -- Function File: graphics_toolkit (HLIST, NAME)
     Query or set the default graphics toolkit which is assigned to new figures.

     With no inputs, return the current default graphics toolkit.  If the input is a list of figure graphic handles, HLIST, then return the name of the graphics toolkit in use for each figure.

     When called with a single input NAME set the default graphics toolkit to NAME.  If the toolkit is not already loaded, it is initialized by calling the function '__init_NAME__'.  If the first input is a list of figure handles, HLIST, then the graphics toolkit is set to NAME for these figures only.

     See also: available_graphics_toolkits.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Query or set the default graphics toolkit which is assigned to new figures.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
hdl2struct


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- Function File: S = hdl2struct (H)
     Return a structure, S, whose fields describe the properties of the object, and its children, associated with the handle, H.

     The fields of the structure S are "type", "handle", "properties", "children", and "special".

     See also: struct2hdl, hgsave, findobj.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
Return a structure, S, whose fields describe the properties of the object, and its children, associated with the handle, H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hggroup


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 880
 -- Function File: hggroup ()
 -- Function File: hggroup (HAX)
 -- Function File: hggroup (..., PROPERTY, VALUE, ...)
 -- Function File: H = hggroup (...)
     Create handle graphics group object with axes parent HAX.

     If no parent is specified, the group is created in the current axes.

     Multiple property/value pairs may be specified for the hggroup, but they must appear in pairs.

     The optional return value H is a graphics handle to the created hggroup object.

     Programming Note: An hggroup is a way to group base graphics objects such as line objects or patch objects into a single unit which can react appropriately.  For example, the individual lines of a contour plot are collected into a single hggroup so that they can be made visible/invisible with a single command, 'set (hg_handle, "visible", "off")'.

     See also: addproperty, addlistener.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Create handle graphics group object with axes parent HAX.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
hgload


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 271
 -- Function File: H = hgload (FILENAME)
     Load the graphics object in FILENAME into the graphics handle H.

     If FILENAME has no extension, Octave will try to find the file with and without the standard extension of '.ofig'.

     See also: hgsave, struct2hdl.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Load the graphics object in FILENAME into the graphics handle H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
hgsave


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 864
 -- Function File: hgsave (FILENAME)
 -- Function File: hgsave (H, FILENAME)
 -- Function File: hgsave (H, FILENAME, FMT)
     Save the graphics handle H to the file FILENAME in the format FMT.

     If unspecified, H is the current figure as returned by 'gcf'.

     When FILENAME does not have an extension the default filename extension '.ofig' will be appended.

     If present, FMT should be one of the following:

        * '-binary', '-float-binary'

        * '-hdf5', '-float-hdf5'

        * '-V7', '-v7', '-7', '-mat7-binary'

        * '-V6', '-v6', '-6', '-mat6-binary'

        * '-text'

        * '-zip', '-z'

     When producing graphics for final publication use 'print' or 'saveas'.  When it is important to be able to continue to edit a figure as an Octave object, use 'hgsave'/'hgload'.

     See also: hgload, hdl2struct, saveas, print.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Save the graphics handle H to the file FILENAME in the format FMT.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
hold


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1033
 -- Command: hold
 -- Command: hold on
 -- Command: hold off
 -- Command: hold all
 -- Function File: hold (HAX, ...)
     Toggle or set the "hold" state of the plotting engine which determines whether new graphic objects are added to the plot or replace the existing objects.

     'hold on'
          Retain plot data and settings so that subsequent plot commands are displayed on a single graph.

     'hold all'
          Retain plot line color, line style, data, and settings so that subsequent plot commands are displayed on a single graph with the next line color and style.

     'hold off'
          Restore default graphics settings which clear the graph and reset axis properties before each new plot command.  (default).

     'hold'
          Toggle the current hold state.

     When given the additional argument HAX, the hold state is modified for this axis rather than the current axes returned by 'gca'.

     To query the current hold state use the 'ishold' function.

     See also: ishold, cla, clf, newplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 153
Toggle or set the "hold" state of the plotting engine which determines whether new graphic objects are added to the plot or replace the existing objects.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
im2frame


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 434
 -- Function File: im2frame (RGB)
 -- Function File: im2frame (X, MAP)
     Convert image to movie frame.

     A movie frame is simply a struct with the fields "cdata" and "colormap".

     Support for N-dimensional images is given when each image projection, matrix sizes of MxN and MxNx3 for RGB images, is concatenated along the fourth dimension.  In such cases, the returned value is a struct array.

     See also: frame2im.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Convert image to movie frame.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
isaxes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: isaxes (H)
     Return true if H is an axes graphics handle and false otherwise.

     If H is a matrix then return a logical array which is true where the elements of H are axes graphics handles and false where they are not.

     See also: isaxes, ishandle.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Return true if H is an axes graphics handle and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
isfigure


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 287
 -- Function File: isfigure (H)
     Return true if H is a figure graphics handle and false otherwise.

     If H is a matrix then return a logical array which is true where the elements of H are figure graphics handles and false where they are not.

     See also: isaxes, ishandle.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Return true if H is a figure graphics handle and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
ishghandle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 222
 -- Function File: ishghandle (H)
     Return true if H is a graphics handle and false otherwise.

     This function is equivalent to 'ishandle' and is provided for compatibility with MATLAB.

     See also: ishandle.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Return true if H is a graphics handle and false otherwise.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ishold


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 -- Command: ishold
 -- Function File: ishold (HAX)
 -- Function File: ishold (HFIG)
     Return true if the next plot will be added to the current plot, or false if the plot device will be cleared before drawing the next plot.

     If the first argument is an axes handle HAX or figure handle HFIG then operate on this plot rather than the current one.

     See also: hold, newplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
Return true if the next plot will be added to the current plot, or false if the plot device will be cleared before drawing the next plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
isprop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 399
 -- Function File: RES = isprop (OBJ, "PROP")
     Return true if PROP is a property of the object OBJ.

     OBJ may also be an array of objects in which case RES will be a logical array indicating whether each handle has the property PROP.

     For plotting, OBJ is a handle to a graphics object.  Otherwise, OBJ should be an instance of a class.

     See also: get, set, ismethod, isobject.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return true if PROP is a property of the object OBJ.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
linkaxes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 808
 -- Function File: linkaxes (HAX)
 -- Function File: linkaxes (HAX, OPTSTR)
     Link the axis limits of 2-D plots such that a change in one is propagated to the others.

     The axes handles to be linked are passed as the first argument HAX.

     The optional second argument is a string which defines which axis limits will be linked.  The possible values for OPTSTR are:

     "x"
          Link x-axes

     "y"
          Link y-axes

     "xy" (default)
          Link both axes

     "off"
          Turn off linking

     If unspecified the default is to link both X and Y axes.

     When linking, the limits from the first axes in HAX are applied to the other axes in the list.  Subsequent changes to any one of the axes will be propagated to the others.

     See also: linkprop, addproperty.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 88
Link the axis limits of 2-D plots such that a change in one is propagated to the others.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
linkprop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1236
 -- Function File: HLINK = linkprop (H, "PROP")
 -- Function File: HLINK = linkprop (H, {"PROP1", "PROP2", ...})
     Link graphic object properties, such that a change in one is propagated to the others.

     The input H is a vector of graphic handles to link.

     PROP may be a string when linking a single property, or a cell array of strings for multiple properties.  During the linking process all properties in PROP will initially be set to the values that exist on the first object in the list H.

     The function returns HLINK which is a special object describing the link.  As long as the reference HLINK exists the link between graphic objects will be active.  This means that HLINK must be preserved in a workspace variable, a global variable, or otherwise stored using a function such as 'setappdata', 'guidata'.  To unlink properties, execute 'clear HLINK'.

     An example of the use of 'linkprop' is

          x = 0:0.1:10;
          subplot (1,2,1);
          h1 = plot (x, sin (x));
          subplot (1,2,2);
          h2 = plot (x, cos (x));
          hlink = linkprop ([h1, h2], {"color","linestyle"});
          set (h1, "color", "green");
          set (h2, "linestyle", "--");

     See also: linkaxes.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Link graphic object properties, such that a change in one is propagated to the others.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
meshgrid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1523
 -- Function File: [XX, YY] = meshgrid (X, Y)
 -- Function File: [XX, YY, ZZ] = meshgrid (X, Y, Z)
 -- Function File: [XX, YY] = meshgrid (X)
 -- Function File: [XX, YY, ZZ] = meshgrid (X)
     Given vectors of X and Y coordinates, return matrices XX and YY corresponding to a full 2-D grid.

     The rows of XX are copies of X, and the columns of YY are copies of Y.  If Y is omitted, then it is assumed to be the same as X.

     If the optional Z input is given, or ZZ is requested, then the output will be a full 3-D grid.

     'meshgrid' is most frequently used to produce input for a 2-D or 3-D function that will be plotted.  The following example creates a surface plot of the "sombrero" function.

          f = @(x,y) sin (sqrt (x.^2 + y.^2)) ./ sqrt (x.^2 + y.^2);
          range = linspace (-8, 8, 41);
          [X, Y] = meshgrid (range, range);
          Z = f (X, Y);
          surf (X, Y, Z);

     Programming Note: 'meshgrid' is restricted to 2-D or 3-D grid generation.  The 'ndgrid' function will generate 1-D through N-D grids.  However, the functions are not completely equivalent.  If X is a vector of length M and Y is a vector of length N, then 'meshgrid' will produce an output grid which is NxM.  'ndgrid' will produce an output which is MxN (transpose) for the same input.  Some core functions expect 'meshgrid' input and others expect 'ndgrid' input.  Check the documentation for the function in question to determine the proper input format.

     See also: ndgrid, mesh, contour, surf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Given vectors of X and Y coordinates, return matrices XX and YY corresponding to a full 2-D grid.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ndgrid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 860
 -- Function File: [Y1, Y2, ..., Yn] = ndgrid (X1, X2, ..., Xn)
 -- Function File: [Y1, Y2, ..., Yn] = ndgrid (X)
     Given n vectors X1, ..., Xn, 'ndgrid' returns n arrays of dimension n.

     The elements of the i-th output argument contains the elements of the vector Xi repeated over all dimensions different from the i-th dimension.  Calling ndgrid with only one input argument X is equivalent to calling ndgrid with all n input arguments equal to X:

     [Y1, Y2, ..., Yn] = ndgrid (X, ..., X)

     Programming Note: 'ndgrid' is very similar to the function 'meshgrid' except that the first two dimensions are transposed in comparison to 'meshgrid'.  Some core functions expect 'meshgrid' input and others expect 'ndgrid' input.  Check the documentation for the function in question to determine the proper input format.

     See also: meshgrid.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Given n vectors X1, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
newplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7506
 -- Function File: newplot ()
 -- Function File: newplot (HFIG)
 -- Function File: newplot (HAX)
 -- Function File: HAX = newplot (...)
     Prepare graphics engine to produce a new plot.

     This function is called at the beginning of all high-level plotting functions.  It is not normally required in user programs.  'newplot' queries the "NextPlot" field of the current figure and axis to determine what to do.

     Figure NextPlot                                                                                                                                                                                                                                                  Action
     ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     "new"                                                                                                                                                                                                                                                            Create a new figure and make it the current figure.
                                                                                                                                                                                                                                                                      
     "add" (default)                                                                                                                                                                                                                                                  Add new graphic objects to the current figure.
                                                                                                                                                                                                                                                                      
     "replacechildren"                                                                                                                                                                                                                                                Delete child objects whose HandleVisibility is set to "on".  Set NextPlot property to "add".  This typically clears a figure, but leaves in place hidden objects such as menubars.  This is equivalent to 'clf'.
                                                                                                                                                                                                                                                                      
     "replace"                                                                                                                                                                                                                                                        Delete all child objects of the figure and reset all figure properties to their defaults.  However, the following four properties are not reset: Position, Units, PaperPosition, PaperUnits.  This is equivalent to 'clf reset'.

     Axis NextPlot                                                                                                                                                                                                                                                    Action
     ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     "add"                                                                                                                                                                                                                                                            Add new graphic objects to the current axes.  This is equivalent to 'hold on'.
                                                                                                                                                                                                                                                                      
     "replacechildren"                                                                                                                                                                                                                                                Delete child objects whose HandleVisibility is set to "on", but leave axis properties unmodified.  This typically clears a plot, but preserves special settings such as log scaling for axes.  This is equivalent to 'cla'.
                                                                                                                                                                                                                                                                      
     "replace" (default)                                                                                                                                                                                                                                              Delete all child objects of the axis and reset all axis properties to their defaults.  However, the following properties are not reset: Position, Units.  This is equivalent to 'cla reset'.

     If the optional input HFIG or HAX is given then prepare the specified figure or axes rather than the current figure and axes.

     The optional return value HAX is a graphics handle to the created axes object (not figure).

     *Caution:* Calling 'newplot' may change the current figure and current axis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Prepare graphics engine to produce a new plot.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
pan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 -- Command: pan
 -- Command: pan on
 -- Command: pan off
 -- Command: pan xon
 -- Command: pan yon
 -- Function File: pan (HFIG, OPTION)
     Control the interactive panning mode of a figure in the GUI.

     Given the option "on" or "off", set the interactive pan mode on or off.

     With no arguments, toggle the current pan mode on or off.

     Given the option "xon" or "yon", enable pan mode for the x or y axis only.

     If the first argument HFIG is a figure, then operate on the given figure rather than the current figure as returned by 'gcf'.

     See also: rotate3d, zoom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Control the interactive panning mode of a figure in the GUI.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
printd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 408
 -- Function File: printd (OBJ, FILENAME)
 -- Function File: OUT_FILE = printd (...)

     Convert any object acceptable to 'disp' into the format selected by the suffix of FILENAME.

     If the return argument OUT_FILE is given, the name of the created file is returned.

     This function is intended to facilitate manipulation of the output of functions such as 'stemleaf'.

     See also: stemleaf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 91
Convert any object acceptable to 'disp' into the format selected by the suffix of FILENAME.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
print


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8025
 -- Function File: print ()
 -- Function File: print (OPTIONS)
 -- Function File: print (FILENAME, OPTIONS)
 -- Function File: print (H, FILENAME, OPTIONS)
     Print a plot, or save it to a file.

     Both output formatted for printing (PDF and PostScript), and many bitmapped and vector image formats are supported.

     FILENAME defines the name of the output file.  If the file name has no suffix, one is inferred from the specified device and appended to the file name.  If no filename is specified, the output is sent to the printer.

     H specifies the handle of the figure to print.  If no handle is specified the current figure is used.

     For output to a printer, PostScript file, or PDF file, the paper size is specified by the figure's 'papersize' property.  The location and size of the image on the page are specified by the figure's 'paperposition' property.  The orientation of the page is specified by the figure's 'paperorientation' property.

     The width and height of images are specified by the figure's 'paperpositon(3:4)' property values.

     The 'print' command supports many OPTIONS:

     '-fH'
          Specify the handle, H, of the figure to be printed.  The default is the current figure.

     '-PPRINTER'
          Set the PRINTER name to which the plot is sent if no FILENAME is specified.

     '-GGHOSTSCRIPT_COMMAND'
          Specify the command for calling Ghostscript.  For Unix and Windows the defaults are "gs" and "gswin32c", respectively.

     '-color'
     '-mono'
          Color or monochrome output.

     '-solid'
     '-dashed'
          Force all lines to be solid or dashed, respectively.

     '-portrait'
     '-landscape'
          Specify the orientation of the plot for printed output.  For non-printed output the aspect ratio of the output corresponds to the plot area defined by the "paperposition" property in the orientation specified.  This option is equivalent to changing the figure's "paperorientation" property.

     '-TextAlphaBits=N'
     '-GraphicsAlphaBits=N'
          Octave is able to produce output for various printers, bitmaps, and vector formats by using Ghostscript.  For bitmap and printer output anti-aliasing is applied using Ghostscript's TextAlphaBits and GraphicsAlphaBits options.  The default number of bits for each is 4.  Allowed values for N are 1, 2, or 4.

     '-dDEVICE'
          The available output format is specified by the option DEVICE, and is one of:

          'ps'
          'ps2'
          'psc'
          'psc2'
               PostScript (level 1 and 2, mono and color).  The FLTK graphics toolkit generates PostScript level 3.0.

          'eps'
          'eps2'
          'epsc'
          'epsc2'
               Encapsulated PostScript (level 1 and 2, mono and color).  The FLTK graphic toolkit generates PostScript level 3.0.

          'pslatex'
          'epslatex'
          'pdflatex'
          'pslatexstandalone'
          'epslatexstandalone'
          'pdflatexstandalone'
               Generate a LaTeX file 'FILENAME.tex' for the text portions of a plot and a file 'FILENAME.(ps|eps|pdf)' for the remaining graphics.  The graphics file suffix .ps|eps|pdf is determined by the specified device type.  The LaTeX file produced by the 'standalone' option can be processed directly by LaTeX.  The file generated without the 'standalone' option is intended to be included from another LaTeX document.  In either case, the LaTeX file contains an '\includegraphics' command so that the generated graphics file is automatically included when the LaTeX file is processed.  The text that is written to the LaTeX file contains the strings *exactly* as they were specified in the plot.  If any special characters of the TeX mode interpreter were used, the file must be edited before LaTeX processing.  Specifically, the special characters must be enclosed with dollar signs ('$ ... $'), and other characters that are recognized by LaTeX may also need editing (.e.g., braces).  The 'pdflatex' device, and any
               of the 'standalone' formats, are not available with the Gnuplot toolkit.

          'tikz'
               Generate a LaTeX file using PGF/TikZ.  For the FLTK toolkit the result is PGF.

          'ill'
          'aifm'
               Adobe Illustrator (Obsolete for Gnuplot versions > 4.2)

          'cdr'
          'corel'
               CorelDraw

          'dxf'
               AutoCAD

          'emf'
          'meta'
               Microsoft Enhanced Metafile

          'fig'
               XFig.  For the Gnuplot graphics toolkit, the additional options '-textspecial' or '-textnormal' can be used to control whether the special flag should be set for the text in the figure.  (default is '-textnormal')

          'hpgl'
               HP plotter language

          'mf'
               Metafont

          'png'
               Portable network graphics

          'jpg'
          'jpeg'
               JPEG image

          'gif'
               GIF image (only available for the Gnuplot graphics toolkit)

          'pbm'
               PBMplus

          'svg'
               Scalable vector graphics

          'pdf'
               Portable document format

               NOTE: The gnuplot binary as shipped by Debian cannot create PDF files, see http://bugs.debian.org/478677

          If the device is omitted, it is inferred from the file extension, or if there is no filename it is sent to the printer as PostScript.

     '-dGHOSTSCRIPT_DEVICE'
          Additional devices are supported by Ghostscript.  Some examples are;

          'pdfwrite'
               Produces pdf output from eps

          'ljet2p'
               HP LaserJet IIP

          'pcx24b'
               24-bit color PCX file format

          'ppm'
               Portable Pixel Map file format

          For a complete list, type 'system ("gs -h")' to see what formats and devices are available.

          When Ghostscript output is sent to a printer the size is determined by the figure's "papersize" property.  When the output is sent to a file the size is determined by the plot box defined by the figure's "paperposition" property.

     '-append'
          Append PostScript or PDF output to a pre-existing file of the same type.

     '-rNUM'
          Resolution of bitmaps in pixels per inch.  For both metafiles and SVG the default is the screen resolution; for other formats it is 150 dpi.  To specify screen resolution, use "-r0".

     '-loose'
     '-tight'
          Force a tight or loose bounding box for eps files.  The default is loose.

     '-PREVIEW'
          Add a preview to eps files.  Supported formats are:

          '-interchange'
               Provide an interchange preview.

          '-metafile'
               Provide a metafile preview.

          '-pict'
               Provide pict preview.

          '-tiff'
               Provide a tiff preview.

     '-SXSIZE,YSIZE'
          Plot size in pixels for EMF, GIF, JPEG, PBM, PNG, and SVG.  For PS, EPS, PDF, and other vector formats the plot size is in points.  This option is equivalent to changing the size of the plot box associated with the "paperposition" property.  When using the command form of the print function you must quote the XSIZE,YSIZE option.  For example, by writing "-S640,480".

     '-FFONTNAME'
     '-FFONTNAME:SIZE'
     '-F:SIZE'
          Use FONTNAME and/or FONTSIZE for all text.  FONTNAME is ignored for some devices: dxf, fig, hpgl, etc.

     The filename and options can be given in any order.

     Example: Print to a file using the pdf device.

          figure (1);
          clf ();
          surf (peaks);
          print figure1.pdf

     Example: Print to a file using jpg device.

          clf ();
          surf (peaks);
          print -djpg figure2.jpg

     Example: Print to printer named PS_printer using ps format.

          clf ();
          surf (peaks);
          print -dpswrite -PPS_printer

     See also: saveas, hgsave, orient, figure.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
Print a plot, or save it to a file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
refreshdata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 939
 -- Function File: refreshdata ()
 -- Function File: refreshdata (H)
 -- Function File: refreshdata (H, WORKSPACE)
     Evaluate any 'datasource' properties of the current figure and update the plot if the corresponding data has changed.

     If the first argument H is a list of graphic handles, then operate on these objects rather than the current figure returned by 'gcf'.

     The optional second argument WORKSPACE can take the following values:

     "base"
          Evaluate the datasource properties in the base workspace.  (default).

     "caller"
          Evaluate the datasource properties in the workspace of the function that called 'refreshdata'.

     An example of the use of 'refreshdata' is:

          x = 0:0.1:10;
          y = sin (x);
          plot (x, y, "ydatasource", "y");
          for i = 1 : 100
            pause (0.1);
            y = sin (x + 0.1*i);
            refreshdata ();
          endfor
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
Evaluate any 'datasource' properties of the current figure and update the plot if the corresponding data has changed.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
refresh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 264
 -- Function File: refresh ()
 -- Function File: refresh (H)
     Refresh a figure, forcing it to be redrawn.

     When called without an argument the current figure is redrawn.  Otherwise, the figure with graphic handle H is redrawn.

     See also: drawnow.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Refresh a figure, forcing it to be redrawn.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rotate


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 451
 -- Function File: rotate (H, DIR, ALPHA)
 -- Function File: rotate (..., ORIGIN)
     Rotate the plot object H through ALPHA degrees around the line with direction DIR and origin ORIGIN.

     The default value of ORIGIN is the center of the axes object that is the parent of H.

     If H is a vector of handles, they must all have the same parent axes object.

     Graphics objects that may be rotated are lines, surfaces, patches, and images.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 100
Rotate the plot object H through ALPHA degrees around the line with direction DIR and origin ORIGIN.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
rotate3d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 497
 -- Command: rotate3d
 -- Command: rotate3d on
 -- Command: rotate3d off
 -- Function File: rotate3d (HFIG, OPTION)
     Control the interactive 3-D rotation mode of a figure in the GUI.

     Given the option "on" or "off", set the interactive rotate mode on or off.

     With no arguments, toggle the current rotate mode on or off.

     If the first argument HFIG is a figure, then operate on the given figure rather than the current figure as returned by 'gcf'.

     See also: pan, zoom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Control the interactive 3-D rotation mode of a figure in the GUI.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
saveas


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 720
 -- Function File: saveas (H, FILENAME)
 -- Function File: saveas (H, FILENAME, FMT)
     Save graphic object H to the file FILENAME in graphic format FMT.

     FMT should be one of the following formats:

     'ps'
          PostScript

     'eps'
          Encapsulated PostScript

     'jpg'
          JPEG Image

     'png'
          PNG Image

     'emf'
          Enhanced Meta File

     'pdf'
          Portable Document Format

     All device formats specified in 'print' may also be used.  If FMT is omitted it is extracted from the extension of FILENAME.  The default format is "pdf".

          clf ();
          surf (peaks);
          saveas (1, "figure1.png");

     See also: print, hgsave, orient.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Save graphic object H to the file FILENAME in graphic format FMT.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
shg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 139
 -- Command: shg
     Show the graph window.

     Currently, this is the same as executing 'drawnow'.

     See also: drawnow, figure.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Show the graph window.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
struct2hdl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 786
 -- Function File: H = struct2hdl (S)
 -- Function File: H = struct2hdl (S, P)
 -- Function File: H = struct2hdl (S, P, HILEV)
     Construct a graphics handle object H from the structure S.

     The structure must contain the fields "handle", "type", "children", "properties", and "special".

     If the handle of an existing figure or axes is specified, P, the new object will be created as a child of that object.  If no parent handle is provided then a new figure and the necessary children will be constructed using the default values from the root figure.

     A third boolean argument HILEV can be passed to specify whether the function should preserve listeners/callbacks, e.g., for legends or hggroups.  The default is false.

     See also: hdl2struct, hgload, findobj.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Construct a graphics handle object H from the structure S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
subplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2166
 -- Function File: subplot (ROWS, COLS, INDEX)
 -- Function File: subplot (RCN)
 -- Function File: subplot (HAX)
 -- Function File: subplot (..., "align")
 -- Function File: subplot (..., "replace")
 -- Function File: subplot (..., "position", POS)
 -- Function File: subplot (..., PROP, VAL, ...)
 -- Function File: HAX = subplot (...)
     Set up a plot grid with ROWS by COLS subwindows and set the current axes for plotting ('gca') to the location given by INDEX.

     If only one numeric argument is supplied, then it must be a three digit value specifying the number of rows in digit 1, the number of columns in digit 2, and the plot index in digit 3.

     The plot index runs row-wise; First, all columns in a row are numbered and then the next row is filled.

     For example, a plot with 2x3 grid will have plot indices running as follows:

          +-----+-----+-----+
          |  1  |  2  |  3  |
          +-----+-----+-----+
          |  4  |  5  |  6  |
          +-----+-----+-----+

     INDEX may also be a vector.  In this case, the new axis will enclose the grid locations specified.  The first demo illustrates this:

          demo ("subplot", 1)

     The index of the subplot to make active may also be specified by its axes handle, HAX, returned from a previous 'subplot' command.

     If the option "align" is given then the plot boxes of the subwindows will align, but this may leave no room for axis tick marks or labels.

     If the option "replace" is given then the subplot axis will be reset, rather than just switching the current axis for plotting to the requested subplot.

     The "position" property can be used to exactly position the subplot axes within the current figure.  The option POS is a 4-element vector [x, y, width, height] that determines the location and size of the axes.  The values in POS are normalized in the range [0,1].

     Any property/value pairs are passed directly to the underlying axes object.

     If the output HAX is requested, subplot returns the axis handle for the subplot.  This is useful for modifying the properties of a subplot using 'set'.

     See also: axes, plot, gca, set.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
Set up a plot grid with ROWS by COLS subwindows and set the current axes for plotting ('gca') to the location given by INDEX.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
zoom


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1194
 -- Command: zoom
 -- Command: zoom (FACTOR)
 -- Command: zoom on
 -- Command: zoom off
 -- Command: zoom xon
 -- Command: zoom yon
 -- Command: zoom out
 -- Command: zoom reset
 -- Command: zoom (HFIG, OPTION)
     Zoom the current axes object or control the interactive zoom mode of a figure in the GUI.

     Given a numeric argument greater than zero, zoom by the given factor.  If the zoom factor is greater than one, zoom in on the plot.  If the factor is less than one, zoom out.  If the zoom factor is a two- or three-element vector, then the elements specify the zoom factors for the x, y, and z axes respectively.

     Given the option "on" or "off", set the interactive zoom mode on or off.

     With no arguments, toggle the current zoom mode on or off.

     Given the option "xon" or "yon", enable zoom mode for the x or y-axis only.

     Given the option "out", zoom to the initial zoom setting.

     Given the option "reset", store the current zoom setting so that 'zoom out' will return to this zoom level.

     If the first argument HFIG is a figure, then operate on the given figure rather than the current figure as returned by 'gcf'.

     See also: pan, rotate3d.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 89
Zoom the current axes object or control the interactive zoom mode of a figure in the GUI.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
compan


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 869
 -- Function File: compan (C)
     Compute the companion matrix corresponding to polynomial coefficient vector C.

     The companion matrix is

               _                                                        _
              |  -c(2)/c(1)   -c(3)/c(1)  ...  -c(N)/c(1)  -c(N+1)/c(1)  |
              |       1            0      ...       0             0      |
              |       0            1      ...       0             0      |
          A = |       .            .      .         .             .      |
              |       .            .       .        .             .      |
              |       .            .        .       .             .      |
              |_      0            0      ...       1             0     _|

     The eigenvalues of the companion matrix are equal to the roots of the polynomial.

     See also: roots, poly, eig.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Compute the companion matrix corresponding to polynomial coefficient vector C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
conv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 597
 -- Function File: conv (A, B)
 -- Function File: conv (A, B, SHAPE)
     Convolve two vectors A and B.

     The output convolution is a vector with length equal to 'length (A) + length (B) - 1'.  When A and B are the coefficient vectors of two polynomials, the convolution represents the coefficient vector of the product polynomial.

     The optional SHAPE argument may be

     SHAPE = "full"
          Return the full convolution.  (default)

     SHAPE = "same"
          Return the central part of the convolution with the same size as A.

     See also: deconv, conv2, convn, fftconv.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Convolve two vectors A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
deconv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 345
 -- Function File: deconv (Y, A)
     Deconvolve two vectors.

     '[b, r] = deconv (y, a)' solves for B and R such that 'y = conv (a, b) + r'.

     If Y and A are polynomial coefficient vectors, B will contain the coefficients of the polynomial quotient and R will be a remainder polynomial of lowest order.

     See also: conv, residue.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Deconvolve two vectors.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
mkpp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 997
 -- Function File: PP = mkpp (BREAKS, COEFS)
 -- Function File: PP = mkpp (BREAKS, COEFS, D)

     Construct a piecewise polynomial (pp) structure from sample points BREAKS and coefficients COEFS.

     BREAKS must be a vector of strictly increasing values.  The number of intervals is given by 'NI = length (BREAKS) - 1'.

     When M is the polynomial order COEFS must be of size: NI x M + 1.

     The i-th row of COEFS, 'COEFS (I,:)', contains the coefficients for the polynomial over the I-th interval, ordered from highest (M) to lowest (0).

     COEFS may also be a multi-dimensional array, specifying a vector-valued or array-valued polynomial.  In that case the polynomial order is defined by the length of the last dimension of COEFS.  The size of first dimension(s) are given by the scalar or vector D.  If D is not given it is set to '1'.  In any case COEFS is reshaped to a 2-D matrix of size '[NI*prod(D M)] '

     See also: unmkpp, ppval, spline, pchip, ppder, ppint, ppjumps.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Construct a piecewise polynomial (pp) structure from sample points BREAKS and coefficients COEFS.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mpoles


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 890
 -- Function File: [MULTP, IDXP] = mpoles (P)
 -- Function File: [MULTP, IDXP] = mpoles (P, TOL)
 -- Function File: [MULTP, IDXP] = mpoles (P, TOL, REORDER)
     Identify unique poles in P and their associated multiplicity.

     The output is ordered from largest pole to smallest pole.

     If the relative difference of two poles is less than TOL then they are considered to be multiples.  The default value for TOL is 0.001.

     If the optional parameter REORDER is zero, poles are not sorted.

     The output MULTP is a vector specifying the multiplicity of the poles.  'MULTP(n)' refers to the multiplicity of the Nth pole 'P(IDXP(n))'.

     For example:

          p = [2 3 1 1 2];
          [m, n] = mpoles (p)
             => m = [1; 1; 2; 1; 2]
             => n = [2; 5; 1; 4; 3]
             => p(n) = [3, 2, 2, 1, 1]

     See also: residue, poly, roots, conv, deconv.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Identify unique poles in P and their associated multiplicity.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
pchip


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1070
 -- Function File: PP = pchip (X, Y)
 -- Function File: YI = pchip (X, Y, XI)
     Return the Piecewise Cubic Hermite Interpolating Polynomial (pchip) of points X and Y.

     If called with two arguments, return the piecewise polynomial PP that may be used with 'ppval' to evaluate the polynomial at specific points.

     When called with a third input argument, 'pchip' evaluates the pchip polynomial at the points XI.  The third calling form is equivalent to 'ppval (pchip (X, Y), XI)'.

     The variable X must be a strictly monotonic vector (either increasing or decreasing) of length N.

     Y can be either a vector or array.  If Y is a vector then it must be the same length N as X.  If Y is an array then the size of Y must have the form '[S1, S2, ..., SK, N]' The array is reshaped internally to a matrix where the leading dimension is given by 'S1 * S2 * ... * SK' and each row of this matrix is then treated separately.  Note that this is exactly opposite to 'interp1' but is done for MATLAB compatibility.

     See also: spline, ppval, mkpp, unmkpp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Return the Piecewise Cubic Hermite Interpolating Polynomial (pchip) of points X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
poly


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 938
 -- Function File: poly (A)
 -- Function File: poly (X)
     If A is a square N-by-N matrix, 'poly (A)' is the row vector of the coefficients of 'det (z * eye (N) - A)', the characteristic polynomial of A.

     For example, the following code finds the eigenvalues of A which are the roots of 'poly (A)'.

          roots (poly (eye (3)))
              => 1.00001 + 0.00001i
                 1.00001 - 0.00001i
                 0.99999 + 0.00000i

     In fact, all three eigenvalues are exactly 1 which emphasizes that for numerical performance the 'eig' function should be used to compute eigenvalues.

     If X is a vector, 'poly (X)' is a vector of the coefficients of the polynomial whose roots are the elements of X.  That is, if C is a polynomial, then the elements of 'D = roots (poly (C))' are contained in C.  The vectors C and D are not identical, however, due to sorting and numerical errors.

     See also: roots, eig.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
If A is a square N-by-N matrix, 'poly (A)' is the row vector of the coefficients of 'det (z * eye (N) - A)', the characteristic polynomial of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
polyaffine


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 323
 -- Function File: polyaffine (F, MU)
     Return the coefficients of the polynomial vector F after an affine transformation.

     If F is the vector representing the polynomial f(x), then 'G = polyaffine (F, MU)' is the vector representing:

          g(x) = f( (x - MU(1)) / MU(2) )

     See also: polyval, polyfit.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 82
Return the coefficients of the polynomial vector F after an affine transformation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyder


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 516
 -- Function File: polyder (P)
 -- Function File: [K] = polyder (A, B)
 -- Function File: [Q, D] = polyder (B, A)
     Return the coefficients of the derivative of the polynomial whose coefficients are given by the vector P.

     If a pair of polynomials is given, return the derivative of the product A*B.

     If two inputs and two outputs are given, return the derivative of the polynomial quotient B/A.  The quotient numerator is in Q and the denominator in D.

     See also: polyint, polyval, polyreduce.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 105
Return the coefficients of the derivative of the polynomial whose coefficients are given by the vector P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyeig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 545
 -- Function File: Z = polyeig (C0, C1, ..., CL)
 -- Function File: [V, Z] = polyeig (C0, C1, ..., CL)

     Solve the polynomial eigenvalue problem of degree L.

     Given an N*N matrix polynomial

     'C(s) = C0 + C1 s + ... + CL s^l'

     'polyeig' solves the eigenvalue problem

     '(C0 + C1 + ... + CL)v = 0'.

     Note that the eigenvalues Z are the zeros of the matrix polynomial.  Z is a row vector with N*L elements.  V is a matrix (N x N*L) with columns that correspond to the eigenvectors.

     See also: eig, eigs, compan.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Solve the polynomial eigenvalue problem of degree L.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyfit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1583
 -- Function File: P = polyfit (X, Y, N)
 -- Function File: [P, S] = polyfit (X, Y, N)
 -- Function File: [P, S, MU] = polyfit (X, Y, N)
     Return the coefficients of a polynomial P(X) of degree N that minimizes the least-squares-error of the fit to the points '[X, Y]'.

     If N is a logical vector, it is used as a mask to selectively force the corresponding polynomial coefficients to be used or ignored.

     The polynomial coefficients are returned in a row vector.

     The optional output S is a structure containing the following fields:

     'R'
          Triangular factor R from the QR decomposition.

     'X'
          The Vandermonde matrix used to compute the polynomial coefficients.

     'C'
          The unscaled covariance matrix, formally equal to the inverse of X'*X, but computed in a way minimizing roundoff error propagation.

     'df'
          The degrees of freedom.

     'normr'
          The norm of the residuals.

     'yf'
          The values of the polynomial for each value of X.

     The second output may be used by 'polyval' to calculate the statistical error limits of the predicted values.  In particular, the standard deviation of P coefficients is given by

     'sqrt (diag (s.C)/s.df)*s.normr'.

     When the third output, MU, is present the coefficients, P, are associated with a polynomial in

     'XHAT = (X - MU(1)) / MU(2)'
     where MU(1) = mean (X), and MU(2) = std (X).

     This linear transformation of X improves the numerical stability of the fit.

     See also: polyval, polyaffine, roots, vander, zscore.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 130
Return the coefficients of a polynomial P(X) of degree N that minimizes the least-squares-error of the fit to the points '[X, Y]'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polygcd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 727
 -- Function File: Q = polygcd (B, A)
 -- Function File: Q = polygcd (B, A, TOL)

     Find the greatest common divisor of two polynomials.

     This is equivalent to the polynomial found by multiplying together all the common roots.  Together with deconv, you can reduce a ratio of two polynomials.

     The tolerance TOL defaults to 'sqrt (eps)'.

     *Caution:* This is a numerically unstable algorithm and should not be used on large polynomials.

     Example code:

          polygcd (poly (1:8), poly (3:12)) - poly (3:8)
          => [ 0, 0, 0, 0, 0, 0, 0 ]
          deconv (poly (1:8), polygcd (poly (1:8), poly (3:12))) - poly (1:2)
          => [ 0, 0, 0 ]

     See also: poly, roots, conv, deconv, residue.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Find the greatest common divisor of two polynomials.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 303
 -- Function File: polyint (P)
 -- Function File: polyint (P, K)
     Return the coefficients of the integral of the polynomial whose coefficients are represented by the vector P.

     The variable K is the constant of integration, which by default is set to zero.

     See also: polyder, polyval.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
Return the coefficients of the integral of the polynomial whose coefficients are represented by the vector P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyout


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 459
 -- Function File: polyout (C)
 -- Function File: polyout (C, X)
 -- Function File: STR = polyout (...)
     Display a formatted version of the polynomial C.

     The formatted polynomial

          c(x) = c(1) * x^n + ... + c(n) x + c(n+1)

     is returned as a string or written to the screen if 'nargout' is zero.

     The second argument X specifies the variable name to use for each term and defaults to the string "s".

     See also: polyreduce.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Display a formatted version of the polynomial C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
polyreduce


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 171
 -- Function File: polyreduce (C)
     Reduce a polynomial coefficient vector to a minimum number of terms by stripping off any leading zeros.

     See also: polyout.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Reduce a polynomial coefficient vector to a minimum number of terms by stripping off any leading zeros.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
polyval


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 750
 -- Function File: Y = polyval (P, X)
 -- Function File: Y = polyval (P, X, [], MU)
 -- Function File: [Y, DY] = polyval (P, X, S)
 -- Function File: [Y, DY] = polyval (P, X, S, MU)

     Evaluate the polynomial P at the specified values of X.

     If X is a vector or matrix, the polynomial is evaluated for each of the elements of X.

     When MU is present, evaluate the polynomial for (X-MU(1))/MU(2).

     In addition to evaluating the polynomial, the second output represents the prediction interval, Y +/- DY, which contains at least 50% of the future predictions.  To calculate the prediction interval, the structured variable S, originating from 'polyfit', must be supplied.

     See also: polyvalm, polyaffine, polyfit, roots, poly.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Evaluate the polynomial P at the specified values of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
polyvalm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 347
 -- Function File: polyvalm (C, X)
     Evaluate a polynomial in the matrix sense.

     'polyvalm (C, X)' will evaluate the polynomial in the matrix sense, i.e., matrix multiplication is used instead of element by element multiplication as used in 'polyval'.

     The argument X must be a square matrix.

     See also: polyval, roots, poly.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Evaluate a polynomial in the matrix sense.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ppval


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 397
 -- Function File: YI = ppval (PP, XI)
     Evaluate the piecewise polynomial structure PP at the points XI.

     If PP describes a scalar polynomial function, the result is an array of the same shape as XI.  Otherwise, the size of the result is '[pp.dim, length(XI)]' if XI is a vector, or '[pp.dim, size(XI)]' if it is a multi-dimensional array.

     See also: mkpp, unmkpp, spline, pchip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Evaluate the piecewise polynomial structure PP at the points XI.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ppder


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 252
 -- Function File: ppd = ppder (pp)
 -- Function File: ppd = ppder (pp, m)
     Compute the piecewise M-th derivative of a piecewise polynomial struct PP.

     If M is omitted the first derivative is calculated.

     See also: mkpp, ppval, ppint.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Compute the piecewise M-th derivative of a piecewise polynomial struct PP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ppint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 230
 -- Function File: PPI = ppint (PP)
 -- Function File: PPI = ppint (PP, C)
     Compute the integral of the piecewise polynomial struct PP.

     C, if given, is the constant of integration.

     See also: mkpp, ppval, ppder.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Compute the integral of the piecewise polynomial struct PP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ppjumps


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 239
 -- Function File: JUMPS = ppjumps (PP)
     Evaluate the boundary jumps of a piecewise polynomial.

     If there are n intervals, and the dimensionality of PP is d, the resulting array has dimensions '[d, n-1]'.

     See also: mkpp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Evaluate the boundary jumps of a piecewise polynomial.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
residue


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2384
 -- Function File: [R, P, K, E] = residue (B, A)
 -- Function File: [B, A] = residue (R, P, K)
 -- Function File: [B, A] = residue (R, P, K, E)
     The first calling form computes the partial fraction expansion for the quotient of the polynomials, B and A.

     The quotient is defined as

          B(s)    M       r(m)        N
          ---- = SUM ------------- + SUM k(i)*s^(N-i)
          A(s)   m=1 (s-p(m))^e(m)   i=1

     where M is the number of poles (the length of the R, P, and E), the K vector is a polynomial of order N-1 representing the direct contribution, and the E vector specifies the multiplicity of the m-th residue's pole.

     For example,

          b = [1, 1, 1];
          a = [1, -5, 8, -4];
          [r, p, k, e] = residue (b, a)
             => r = [-2; 7; 3]
             => p = [2; 2; 1]
             => k = [](0x0)
             => e = [1; 2; 1]

     which represents the following partial fraction expansion

                  s^2 + s + 1       -2        7        3
             ------------------- = ----- + ------- + -----
             s^3 - 5s^2 + 8s - 4   (s-2)   (s-2)^2   (s-1)

     The second calling form performs the inverse operation and computes the reconstituted quotient of polynomials, B(s)/A(s), from the partial fraction expansion; represented by the residues, poles, and a direct polynomial specified by R, P and K, and the pole multiplicity E.

     If the multiplicity, E, is not explicitly specified the multiplicity is determined by the function 'mpoles'.

     For example:

          r = [-2; 7; 3];
          p = [2; 2; 1];
          k = [1, 0];
          [b, a] = residue (r, p, k)
             => b = [1, -5, 9, -3, 1]
             => a = [1, -5, 8, -4]

          where mpoles is used to determine e = [1; 2; 1]

     Alternatively the multiplicity may be defined explicitly, for example,

          r = [7; 3; -2];
          p = [2; 1; 2];
          k = [1, 0];
          e = [2; 1; 1];
          [b, a] = residue (r, p, k, e)
             => b = [1, -5, 9, -3, 1]
             => a = [1, -5, 8, -4]

     which represents the following partial fraction expansion

           -2        7        3         s^4 - 5s^3 + 9s^2 - 3s + 1
          ----- + ------- + ----- + s = --------------------------
          (s-2)   (s-2)^2   (s-1)          s^3 - 5s^2 + 8s - 4

     See also: mpoles, poly, roots, conv, deconv.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
The first calling form computes the partial fraction expansion for the quotient of the polynomials, B and A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
roots


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 517
 -- Function File: roots (C)

     Compute the roots of the polynomial C.

     For a vector C with N components, return the roots of the polynomial

          c(1) * x^(N-1) + ... + c(N-1) * x + c(N)

     As an example, the following code finds the roots of the quadratic polynomial

          p(x) = x^2 - 5.

          c = [1, 0, -5];
          roots (c)
          =>  2.2361
          => -2.2361

     Note that the true result is +/- sqrt(5) which is roughly +/- 2.2361.

     See also: poly, compan, fzero.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Compute the roots of the polynomial C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
spline


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1275
 -- Function File: PP = spline (X, Y)
 -- Function File: YI = spline (X, Y, XI)
     Return the cubic spline interpolant of points X and Y.

     When called with two arguments, return the piecewise polynomial PP that may be used with 'ppval' to evaluate the polynomial at specific points.

     When called with a third input argument, 'spline' evaluates the spline at the points XI.  The third calling form 'spline (X, Y, XI)' is equivalent to 'ppval (spline (X, Y), XI)'.

     The variable X must be a vector of length N.

     Y can be either a vector or array.  If Y is a vector it must have a length of either N or 'N + 2'.  If the length of Y is N, then the "not-a-knot" end condition is used.  If the length of Y is 'N + 2', then the first and last values of the vector Y are the values of the first derivative of the cubic spline at the endpoints.

     If Y is an array, then the size of Y must have the form '[S1, S2, ..., SK, N]' or '[S1, S2, ..., SK, N + 2]'.  The array is reshaped internally to a matrix where the leading dimension is given by 'S1 * S2 * ... * SK' and each row of this matrix is then treated separately.  Note that this is exactly the opposite of 'interp1' but is done for MATLAB compatibility.

     See also: pchip, ppval, mkpp, unmkpp.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Return the cubic spline interpolant of points X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
splinefit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2668
 -- Function File: PP = splinefit (X, Y, BREAKS)
 -- Function File: PP = splinefit (X, Y, P)
 -- Function File: PP = splinefit (..., "periodic", PERIODIC)
 -- Function File: PP = splinefit (..., "robust", ROBUST)
 -- Function File: PP = splinefit (..., "beta", BETA)
 -- Function File: PP = splinefit (..., "order", ORDER)
 -- Function File: PP = splinefit (..., "constraints", CONSTRAINTS)

     Fit a piecewise cubic spline with breaks (knots) BREAKS to the noisy data, X and Y.

     X is a vector, and Y is a vector or N-D array.  If Y is an N-D array, then X(j) is matched to Y(:,...,:,j).

     P is a positive integer defining the number of intervals along X, and P+1 is the number of breaks.  The number of points in each interval differ by no more than 1.

     The optional property PERIODIC is a logical value which specifies whether a periodic boundary condition is applied to the spline.  The length of the period is 'max (BREAKS) - min (BREAKS)'.  The default value is 'false'.

     The optional property ROBUST is a logical value which specifies if robust fitting is to be applied to reduce the influence of outlying data points.  Three iterations of weighted least squares are performed.  Weights are computed from previous residuals.  The sensitivity of outlier identification is controlled by the property BETA.  The value of BETA is restricted to the range, 0 < BETA < 1.  The default value is BETA = 1/2.  Values close to 0 give all data equal weighting.  Increasing values of BETA reduce the influence of outlying data.  Values close to unity may cause instability or rank deficiency.

     The fitted spline is returned as a piecewise polynomial, PP, and may be evaluated using 'ppval'.

     The splines are constructed of polynomials with degree ORDER.  The default is a cubic, ORDER=3.  A spline with P pieces has P+ORDER degrees of freedom.  With periodic boundary conditions the degrees of freedom are reduced to P.

     The optional property, CONSTAINTS, is a structure specifying linear constraints on the fit.  The structure has three fields, "xc", "yc", and "cc".

     "xc"
          Vector of the x-locations of the constraints.

     "yc"
          Constraining values at the locations XC.  The default is an array of zeros.

     "cc"
          Coefficients (matrix).  The default is an array of ones.  The number of rows is limited to the order of the piecewise polynomials, ORDER.

     Constraints are linear combinations of derivatives of order 0 to ORDER-1 according to

          cc(1,j) * y(xc(j)) + cc(2,j) * y'(xc(j)) + ... = yc(:,...,:,j).

     See also: interp1, unmkpp, ppval, spline, pchip, ppder, ppint, ppjumps.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Fit a piecewise cubic spline with breaks (knots) BREAKS to the noisy data, X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
unmkpp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 666
 -- Function File: [X, P, N, K, D] = unmkpp (PP)

     Extract the components of a piecewise polynomial structure PP.

     The components are:

     X
          Sample points.

     P
          Polynomial coefficients for points in sample interval.  'P (I, :)' contains the coefficients for the polynomial over interval I ordered from highest to lowest.  If 'D > 1', 'P (R, I, :)' contains the coefficients for the r-th polynomial defined on interval I.

     N
          Number of polynomial pieces.

     K
          Order of the polynomial plus 1.

     D
          Number of polynomials defined for each interval.

     See also: mkpp, ppval, spline, pchip.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Extract the components of a piecewise polynomial structure PP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
addpref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 494
 -- Function File: addpref (GROUP, PREF, VAL)
     Add a preference PREF and associated value VAL to the named preference group GROUP.

     The named preference group must be a character string.

     The preference PREF may be a character string or a cell array of character strings.

     The corresponding value VAL may be any value, or, if PREF is a cell array of strings, VAL must be a cell array of values with the same size as PREF.

     See also: setpref, getpref, ispref, rmpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Add a preference PREF and associated value VAL to the named preference group GROUP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
getpref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 914
 -- Function File: getpref (GROUP, PREF)
 -- Function File: getpref (GROUP, PREF, DEFAULT)
 -- Function File: getpref (GROUP)
     Return the preference value corresponding to the named preference PREF in the preference group GROUP.

     The named preference group must be a character string.

     If PREF does not exist in GROUP and DEFAULT is specified, return DEFAULT.

     The preference PREF may be a character string or a cell array of character strings.

     The corresponding default value DEFAULT may be any value, or, if PREF is a cell array of strings, DEFAULT must be a cell array of values with the same size as PREF.

     If neither PREF nor DEFAULT are specified, return a structure of preferences for the preference group GROUP.

     If no arguments are specified, return a structure containing all groups of preferences and their values.

     See also: addpref, setpref, ispref, rmpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
Return the preference value corresponding to the named preference PREF in the preference group GROUP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ispref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 445
 -- Function File: ispref (GROUP, PREF)
 -- Function File: ispref (GROUP)
     Return true if the named preference PREF exists in the preference group GROUP.

     The named preference group must be a character string.

     The preference PREF may be a character string or a cell array of character strings.

     If PREF is not specified, return true if the preference group GROUP exists.

     See also: getpref, addpref, setpref, rmpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Return true if the named preference PREF exists in the preference group GROUP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
prefdir


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 316
 -- Command: prefdir
 -- Command: DIR = prefdir
     Return the directory that contains the preferences for Octave.

     Examples:

     Display the preferences directory

          prefdir

     Change to the preferences folder

          cd (prefdir)

     See also: getpref, setpref, addpref, rmpref, ispref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Return the directory that contains the preferences for Octave.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
preferences


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 87
 -- Command: preferences
     Display the GUI preferences dialog window for Octave.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Display the GUI preferences dialog window for Octave.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rmpref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 471
 -- Function File: rmpref (GROUP, PREF)
 -- Function File: rmpref (GROUP)
     Remove the named preference PREF from the preference group GROUP.

     The named preference group must be a character string.

     The preference PREF may be a character string or cell array of strings.

     If PREF is not specified, remove the preference group GROUP.

     It is an error to remove a nonexistent preference or group.

     See also: addpref, ispref, setpref, getpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Remove the named preference PREF from the preference group GROUP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
setpref


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 554
 -- Function File: setpref (GROUP, PREF, VAL)
     Set a preference PREF to the given VAL in the named preference group GROUP.

     The named preference group must be a character string.

     The preference PREF may be a character string or a cell array of character strings.

     The corresponding value VAL may be any value, or, if PREF is a cell array of strings, VAL must be a cell array of values with the same size as PREF.

     If the named preference or group does not exist, it is added.

     See also: addpref, getpref, ispref, rmpref.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Set a preference PREF to the given VAL in the named preference group GROUP.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
intersect


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 647
 -- Function File: C = intersect (A, B)
 -- Function File: C = intersect (A, B, "rows")
 -- Function File: [C, IA, IB] = intersect (...)

     Return the unique elements common to both A and B sorted in ascending order.

     If A and B are both row vectors then return a row vector; Otherwise, return a column vector.  The inputs may also be cell arrays of strings.

     If the optional input "rows" is given then return the common rows of A and B.  The inputs must be 2-D matrices to use this option.

     If requested, return index vectors IA and IB such that 'C = A(IA)' and 'C = B(IB)'.

See also: unique, union, setdiff, setxor, ismember. 


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Return the unique elements common to both A and B sorted in ascending order.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
ismember


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1198
 -- Function File: TF = ismember (A, S)
 -- Function File: TF = ismember (A, S, "rows")
 -- Function File: [TF, S_IDX] = ismember (...)

     Return a logical matrix TF with the same shape as A which is true (1) if the element in A is found in S and false (0) if it is not.

     If a second output argument is requested then the index into S of each matching element is also returned.

          a = [3, 10, 1];
          s = [0:9];
          [tf, s_idx] = ismember (a, s)
               => tf = [1, 0, 1]
               => s_idx = [4, 0, 2]

     The inputs A and S may also be cell arrays.

          a = {"abc"};
          s = {"abc", "def"};
          [tf, s_idx] = ismember (a, s)
               => tf = [1, 0]
               => s_idx = [1, 0]

     If the optional third argument "rows" is given then compare rows in A with rows in S.  The inputs must be 2-D matrices with the same number of columns to use this option.

          a = [1:3; 5:7; 4:6];
          s = [0:2; 1:3; 2:4; 3:5; 4:6];
          [tf, s_idx] = ismember (a, s, "rows")
               => tf = logical ([1; 0; 1])
               => s_idx = [2; 0; 5];

     See also: lookup, unique, union, intersect, setdiff, setxor.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 131
Return a logical matrix TF with the same shape as A which is true (1) if the element in A is found in S and false (0) if it is not.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
powerset


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 502
 -- Function File: powerset (A)
 -- Function File: powerset (A, "rows")
     Compute the powerset (all subsets) of the set A.

     The set A must be a numerical matrix or a cell array of strings.  The output will always be a cell array of either vectors or strings.

     With the optional argument "rows", each row of the set A is considered one element of the set.  The input must be a 2-D numeric matrix to use this argument.

     See also: unique, union, intersect, setdiff, setxor, ismember.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Compute the powerset (all subsets) of the set A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
setdiff


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 618
 -- Function File: C = setdiff (A, B)
 -- Function File: C = setdiff (A, B, "rows")
 -- Function File: [C, IA] = setdiff (...)
     Return the unique elements in A that are not in B sorted in ascending order.

     If A is a row vector return a column vector; Otherwise, return a column vector.  The inputs may also be cell arrays of strings.

     If the optional input "rows" is given then return the rows in A that are not in B.  The inputs must be 2-D matrices to use this option.

     If requested, return the index vector IA such that 'C = A(IA)'.

     See also: unique, union, intersect, setxor, ismember.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Return the unique elements in A that are not in B sorted in ascending order.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
setxor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 686
 -- Function File: C = setxor (A, B)
 -- Function File: C = setxor (A, B, "rows")
 -- Function File: [C, IA, IB] = setxor (...)

     Return the unique elements exclusive to sets A or B sorted in ascending order.

     If A and B are both row vectors then return a row vector; Otherwise, return a column vector.  The inputs may also be cell arrays of strings.

     If the optional input "rows" is given then return the rows exclusive to sets A and B.  The inputs must be 2-D matrices to use this option.

     If requested, return index vectors IA and IB such that 'A(IA)' and 'B(IB)' are disjoint sets whose union is C.

     See also: unique, union, intersect, setdiff, ismember.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Return the unique elements exclusive to sets A or B sorted in ascending order.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
union


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 685
 -- Function File: C = union (A, B)
 -- Function File: C = union (A, B, "rows")
 -- Function File: [C, IA, IB] = union (...)

     Return the unique elements that are in either A or B sorted in ascending order.

     If A and B are both row vectors then return a row vector; Otherwise, return a column vector.  The inputs may also be cell arrays of strings.

     If the optional input "rows" is given then return rows that are in either A or B.  The inputs must be 2-D matrices to use this option.

     The optional outputs IA and IB are index vectors such that 'A(IA)' and 'B(IB)' are disjoint sets whose union is C.

     See also: unique, intersect, setdiff, setxor, ismember.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
Return the unique elements that are in either A or B sorted in ascending order.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
unique


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 980
 -- Function File: unique (X)
 -- Function File: unique (X, "rows")
 -- Function File: [Y, I, J] = unique (...)
 -- Function File: [Y, I, J] = unique (..., "first")
 -- Function File: [Y, I, J] = unique (..., "last")
     Return the unique elements of X sorted in ascending order.

     If the input X is a column vector then return a column vector; Otherwise, return a row vector.  X may also be a cell array of strings.

     If the optional argument "rows" is given then return the unique rows of X sorted in ascending order.  The input must be a 2-D matrix to use this option.

     If requested, return index vectors I and J such that 'Y = X(I)' and 'X = Y(J)'.

     Additionally, if I is a requested output then one of "first" or "last" may be given as an input.  If "last" is specified, return the highest possible indices in I, otherwise, if "first" is specified, return the lowest.  The default is "last".

     See also: union, intersect, setdiff, setxor, ismember.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
Return the unique elements of X sorted in ascending order.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
arch_fit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 864
 -- Function File: [A, B] = arch_fit (Y, X, P, ITER, GAMMA, A0, B0)
     Fit an ARCH regression model to the time series Y using the scoring algorithm in Engle's original ARCH paper.

     The model is

          y(t) = b(1) * x(t,1) + ... + b(k) * x(t,k) + e(t),
          h(t) = a(1) + a(2) * e(t-1)^2 + ... + a(p+1) * e(t-p)^2

     in which e(t) is N(0, h(t)), given a time-series vector Y up to time t-1 and a matrix of (ordinary) regressors X up to t.  The order of the regression of the residual variance is specified by P.

     If invoked as 'arch_fit (Y, K, P)' with a positive integer K, fit an ARCH(K, P) process, i.e., do the above with the t-th row of X given by

          [1, y(t-1), ..., y(t-k)]

     Optionally, one can specify the number of iterations ITER, the updating factor GAMMA, and initial values a0 and b0 for the scoring algorithm.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
Fit an ARCH regression model to the time series Y using the scoring algorithm in Engle's original ARCH paper.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
arch_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 374
 -- Function File: arch_rnd (A, B, T)
     Simulate an ARCH sequence of length T with AR coefficients B and CH coefficients A.

     The result y(t) follows the model

          y(t) = b(1) + b(2) * y(t-1) + ... + b(lb) * y(t-lb+1) + e(t),

     where e(t), given Y up to time t-1, is N(0, h(t)), with

          h(t) = a(1) + a(2) * e(t-1)^2 + ... + a(la) * e(t-la+1)^2
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Simulate an ARCH sequence of length T with AR coefficients B and CH coefficients A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
arch_test


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 949
 -- Function File: [PVAL, LM] = arch_test (Y, X, P)
     For a linear regression model

          y = x * b + e

     perform a Lagrange Multiplier (LM) test of the null hypothesis of no conditional heteroscedascity against the alternative of CH(P).

     I.e., the model is

          y(t) = b(1) * x(t,1) + ... + b(k) * x(t,k) + e(t),

     given Y up to t-1 and X up to t, e(t) is N(0, h(t)) with

          h(t) = v + a(1) * e(t-1)^2 + ... + a(p) * e(t-p)^2,

     and the null is a(1) == ... == a(p) == 0.

     If the second argument is a scalar integer, k, perform the same test in a linear autoregression model of order k, i.e., with

          [1, y(t-1), ..., y(t-K)]

     as the t-th row of X.

     Under the null, LM approximately has a chisquare distribution with P degrees of freedom and PVAL is the p-value (1 minus the CDF of this distribution at LM) of the test.

     If no output argument is given, the p-value is displayed.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
For a linear regression model 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
arma_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 597
 -- Function File: arma_rnd (A, B, V, T, N)
     Return a simulation of the ARMA model.

     The ARMA model is defined by

          x(n) = a(1) * x(n-1) + ... + a(k) * x(n-k)
               + e(n) + b(1) * e(n-1) + ... + b(l) * e(n-l)

     in which K is the length of vector A, L is the length of vector B and E is Gaussian white noise with variance V.  The function returns a vector of length T.

     The optional parameter N gives the number of dummy X(I) used for initialization, i.e., a sequence of length T+N is generated and X(N+1:T+N) is returned.  If N is omitted, N = 100 is used.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Return a simulation of the ARMA model.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
autoreg_matrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 356
 -- Function File: autoreg_matrix (Y, K)
     Given a time series (vector) Y, return a matrix with ones in the first column and the first K lagged values of Y in the other columns.

     In other words, for T > K, '[1, Y(T-1), ..., Y(T-K)]' is the t-th row of the result.

     The resulting matrix may be used as a regressor matrix in autoregressions.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 134
Given a time series (vector) Y, return a matrix with ones in the first column and the first K lagged values of Y in the other columns.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bartlett


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 -- Function File: bartlett (M)
     Return the filter coefficients of a Bartlett (triangular) window of length M.

     For a definition of the Bartlett window see, e.g., A.V. Oppenheim & R. W. Schafer, 'Discrete-Time Signal Processing'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Return the filter coefficients of a Bartlett (triangular) window of length M.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
blackman


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 585
 -- Function File: blackman (M)
 -- Function File: blackman (M, "periodic")
 -- Function File: blackman (M, "symmetric")
     Return the filter coefficients of a Blackman window of length M.

     If the optional argument "periodic" is given, the periodic form of the window is returned.  This is equivalent to the window of length M+1 with the last coefficient removed.  The optional argument "symmetric" is equivalent to not specifying a second argument.

     For a definition of the Blackman window, see, e.g., A.V. Oppenheim & R. W. Schafer, 'Discrete-Time Signal Processing'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Return the filter coefficients of a Blackman window of length M.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
detrend


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 547
 -- Function File: detrend (X, P)
     If X is a vector, 'detrend (X, P)' removes the best fit of a polynomial of order P from the data X.

     If X is a matrix, 'detrend (X, P)' does the same for each column in X.

     The second argument P is optional.  If it is not specified, a value of 1 is assumed.  This corresponds to removing a linear trend.

     The order of the polynomial can also be given as a string, in which case P must be either "constant" (corresponds to 'P=0') or "linear" (corresponds to 'P=1').

     See also: polyfit.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 99
If X is a vector, 'detrend (X, P)' removes the best fit of a polynomial of order P from the data X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
diffpara


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 702
 -- Function File: [D, DD] = diffpara (X, A, B)
     Return the estimator D for the differencing parameter of an integrated time series.

     The frequencies from [2*pi*a/t, 2*pi*b/T] are used for the estimation.  If B is omitted, the interval [2*pi/T, 2*pi*a/T] is used.  If both B and A are omitted then a = 0.5 * sqrt (T) and b = 1.5 * sqrt (T) is used, where T is the sample size.  If X is a matrix, the differencing parameter of each column is estimated.

     The estimators for all frequencies in the intervals described above is returned in DD.

     The value of D is simply the mean of DD.

     Reference: P.J. Brockwell & R.A. Davis.  'Time Series: Theory and Methods'.  Springer 1987.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Return the estimator D for the differencing parameter of an integrated time series.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
durbinlevinson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 -- Function File: durbinlevinson (C, OLDPHI, OLDV)
     Perform one step of the Durbin-Levinson algorithm.

     The vector C specifies the autocovariances '[gamma_0, ..., gamma_t]' from lag 0 to T, OLDPHI specifies the coefficients based on C(T-1) and OLDV specifies the corresponding error.

     If OLDPHI and OLDV are omitted, all steps from 1 to T of the algorithm are performed.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Perform one step of the Durbin-Levinson algorithm.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fftconv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 530
 -- Function File: fftconv (X, Y)
 -- Function File: fftconv (X, Y, N)
     Convolve two vectors using the FFT for computation.

     'c = fftconv (X, Y)' returns a vector of length equal to 'length (X) + length (Y) - 1'.  If X and Y are the coefficient vectors of two polynomials, the returned value is the coefficient vector of the product polynomial.

     The computation uses the FFT by calling the function 'fftfilt'.  If the optional argument N is specified, an N-point FFT is used.

     See also: deconv, conv, conv2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Convolve two vectors using the FFT for computation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
fftfilt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 545
 -- Function File: fftfilt (B, X)
 -- Function File: fftfilt (B, X, N)
     Filter X with the FIR filter B using the FFT.

     If X is a matrix, filter each column of the matrix.

     Given the optional third argument, N, 'fftfilt' uses the overlap-add method to filter X with B using an N-point FFT.  The FFT size must be an even power of 2 and must be greater than or equal to the length of B.  If the specified N does not meet these criteria, it is automatically adjusted to the nearest value that does.

     See also: filter, filter2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Filter X with the FIR filter B using the FFT.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
fftshift


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 709
 -- Function File: fftshift (X)
 -- Function File: fftshift (X, DIM)
     Perform a shift of the vector X, for use with the 'fft' and 'ifft' functions, in order the move the frequency 0 to the center of the vector or matrix.

     If X is a vector of N elements corresponding to N time samples spaced by dt, then 'fftshift (fft (X))' corresponds to frequencies

          f = [ -(ceil((N-1)/2):-1:1)*df 0 (1:floor((N-1)/2))*df ]

     where df = 1 / dt.

     If X is a matrix, the same holds for rows and columns.  If X is an array, then the same holds along each dimension.

     The optional DIM argument can be used to limit the dimension along which the permutation occurs.

     See also: ifftshift.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
Perform a shift of the vector X, for use with the 'fft' and 'ifft' functions, in order the move the frequency 0 to the center of the vector or matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
filter2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 552
 -- Function File: Y = filter2 (B, X)
 -- Function File: Y = filter2 (B, X, SHAPE)
     Apply the 2-D FIR filter B to X.

     If the argument SHAPE is specified, return an array of the desired shape.  Possible values are:

     "full"
          pad X with zeros on all sides before filtering.

     "same"
          unpadded X (default)

     "valid"
          trim X after filtering so edge effects are no included.

     Note this is just a variation on convolution, with the parameters reversed and B rotated 180 degrees.

     See also: conv2.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Apply the 2-D FIR filter B to X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
fractdiff


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: fractdiff (X, D)
     Compute the fractional differences (1-L)^d x where L denotes the lag-operator and d is greater than -1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
Compute the fractional differences (1-L)^d x where L denotes the lag-operator and d is greater than -1.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
freqz


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1415
 -- Function File: [H, W] = freqz (B, A, N, "whole")
 -- Function File: [H, W] = freqz (B)
 -- Function File: [H, W] = freqz (B, A)
 -- Function File: [H, W] = freqz (B, A, N)
 -- Function File: H = freqz (B, A, W)
 -- Function File: [H, W] = freqz (..., FS)
 -- Function File: freqz (...)

     Return the complex frequency response H of the rational IIR filter whose numerator and denominator coefficients are B and A, respectively.

     The response is evaluated at N angular frequencies between 0 and 2*pi.

     The output value W is a vector of the frequencies.

     If A is omitted, the denominator is assumed to be 1 (this corresponds to a simple FIR filter).

     If N is omitted, a value of 512 is assumed.  For fastest computation, N should factor into a small number of small primes.

     If the fourth argument, "whole", is omitted the response is evaluated at frequencies between 0 and pi.

     'freqz (B, A, W)'

     Evaluate the response at the specific frequencies in the vector W.  The values for W are measured in radians.

     '[...] = freqz (..., FS)'

     Return frequencies in Hz instead of radians assuming a sampling rate FS.  If you are evaluating the response at specific frequencies W, those frequencies should be requested in Hz rather than radians.

     'freqz (...)'

     Plot the magnitude and phase response of H rather than returning them.

     See also: freqz_plot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 138
Return the complex frequency response H of the rational IIR filter whose numerator and denominator coefficients are B and A, respectively.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
freqz_plot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 335
 -- Function File: freqz_plot (W, H)
 -- Function File: freqz_plot (W, H, FREQ_NORM)
     Plot the magnitude and phase response of H.

     If the optional FREQ_NORM argument is true, the frequency vector W is in units of normalized radians.  If FREQ_NORM is false, or not given, then W is measured in Hertz.

     See also: freqz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Plot the magnitude and phase response of H.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hamming


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 579
 -- Function File: hamming (M)
 -- Function File: hamming (M, "periodic")
 -- Function File: hamming (M, "symmetric")
     Return the filter coefficients of a Hamming window of length M.

     If the optional argument "periodic" is given, the periodic form of the window is returned.  This is equivalent to the window of length M+1 with the last coefficient removed.  The optional argument "symmetric" is equivalent to not specifying a second argument.

     For a definition of the Hamming window see, e.g., A.V. Oppenheim & R. W. Schafer, 'Discrete-Time Signal Processing'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Return the filter coefficients of a Hamming window of length M.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hanning


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 579
 -- Function File: hanning (M)
 -- Function File: hanning (M, "periodic")
 -- Function File: hanning (M, "symmetric")
     Return the filter coefficients of a Hanning window of length M.

     If the optional argument "periodic" is given, the periodic form of the window is returned.  This is equivalent to the window of length M+1 with the last coefficient removed.  The optional argument "symmetric" is equivalent to not specifying a second argument.

     For a definition of the Hanning window see, e.g., A.V. Oppenheim & R. W. Schafer, 'Discrete-Time Signal Processing'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Return the filter coefficients of a Hanning window of length M.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
hurst


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 181
 -- Function File: hurst (X)
     Estimate the Hurst parameter of sample X via the rescaled range statistic.

     If X is a matrix, the parameter is estimated for every column.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Estimate the Hurst parameter of sample X via the rescaled range statistic.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ifftshift


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 238
 -- Function File: ifftshift (X)
 -- Function File: ifftshift (X, DIM)
     Undo the action of the 'fftshift' function.

     For even length X, 'fftshift' is its own inverse, but odd lengths differ slightly.

     See also: fftshift.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Undo the action of the 'fftshift' function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
periodogram


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1908
 -- Function File: [PXX, W] = periodogram (X)
 -- Function File: [PXX, W] = periodogram (X, WIN)
 -- Function File: [PXX, W] = periodogram (X, WIN, NFFT)
 -- Function File: [PXX, F] = periodogram (X, WIN, NFFT, FS)
 -- Function File: [PXX, F] = periodogram (..., "RANGE")
 -- Function File: periodogram (...)
     Return the periodogram (Power Spectral Density) of X.

     The possible inputs are:

     X

          data vector.  If X is real-valued a one-sided spectrum is estimated.  If X is complex-valued, or "RANGE" specifies "twosided", the full spectrum is estimated.

     WIN
          window weight data.  If window is empty or unspecified a default rectangular window is used.  Otherwise, the window is applied to the signal ('X .* WIN') before computing the periodogram.  The window data must be a vector of the same length as X.

     NFFT
          number of frequency bins.  The default is 256 or the next higher power of 2 greater than the length of X ('max (256, 2.^nextpow2 (length (x)))').  If NFFT is greater than the length of the input then X will be zero-padded to the length of NFFT.

     FS
          sampling rate.  The default is 1.

     RANGE
          range of spectrum.  "onesided" computes spectrum from [0..nfft/2+1].  "twosided" computes spectrum from [0..nfft-1].

     The optional second output W are the normalized angular frequencies.  For a one-sided calculation W is in the range [0, pi] if NFFT is even and [0, pi) if NFFT is odd.  Similarly, for a two-sided calculation W is in the range [0, 2*pi] or [0, 2*pi) depending on NFFT.

     If a sampling frequency is specified, FS, then the output frequencies F will be in the range [0, FS/2] or [0, FS/2) for one-sided calculations.  For two-sided calculations the range will be [0, FS).

     When called with no outputs the periodogram is immediately plotted in the current figure window.

     See also: fft.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Return the periodogram (Power Spectral Density) of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
sinc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
 -- Function File: sinc (X)
     Compute the sinc function.

     Return sin (pi*x) / (pi*x).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Compute the sinc function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
sinetone


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 323
 -- Function File: sinetone (FREQ, RATE, SEC, AMPL)
     Return a sinetone of frequency FREQ with a length of SEC seconds at sampling rate RATE and with amplitude AMPL.

     The arguments FREQ and AMPL may be vectors of common size.

     The defaults are RATE = 8000, SEC = 1, and AMPL = 64.

     See also: sinewave.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 111
Return a sinetone of frequency FREQ with a length of SEC seconds at sampling rate RATE and with amplitude AMPL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
sinewave


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 225
 -- Function File: sinewave (M, N, D)
     Return an M-element vector with I-th element given by 'sin (2 * pi * (I+D-1) / N)'.

     The default value for D is 0 and the default value for N is M.

     See also: sinetone.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Return an M-element vector with I-th element given by 'sin (2 * pi * (I+D-1) / N)'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
spectral_adf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 484
 -- Function File: spectral_adf (C)
 -- Function File: spectral_adf (C, WIN)
 -- Function File: spectral_adf (C, WIN, B)
     Return the spectral density estimator given a vector of autocovariances C, window name WIN, and bandwidth, B.

     The window name, e.g., "triangle" or "rectangle" is used to search for a function called 'WIN_lw'.

     If WIN is omitted, the triangle window is used.

     If B is omitted, '1 / sqrt (length (X))' is used.

     See also: spectral_xdf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 109
Return the spectral density estimator given a vector of autocovariances C, window name WIN, and bandwidth, B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
spectral_xdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 470
 -- Function File: spectral_xdf (X)
 -- Function File: spectral_xdf (X, WIN)
 -- Function File: spectral_xdf (X, WIN, B)
     Return the spectral density estimator given a data vector X, window name WIN, and bandwidth, B.

     The window name, e.g., "triangle" or "rectangle" is used to search for a function called 'WIN_sw'.

     If WIN is omitted, the triangle window is used.

     If B is omitted, '1 / sqrt (length (X))' is used.

     See also: spectral_adf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Return the spectral density estimator given a data vector X, window name WIN, and bandwidth, B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
spencer


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
 -- Function File: spencer (X)
     Return Spencer's 15 point moving average of each column of X.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Return Spencer's 15 point moving average of each column of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
stft


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1204
 -- Function File: Y = stft (X)
 -- Function File: Y = stft (X, WIN_SIZE)
 -- Function File: Y = stft (X, WIN_SIZE, INC)
 -- Function File: Y = stft (X, WIN_SIZE, INC, NUM_COEF)
 -- Function File: Y = stft (X, WIN_SIZE, INC, NUM_COEF, WIN_TYPE)
 -- Function File: [Y, C] = stft (...)
     Compute the short-time Fourier transform of the vector X with NUM_COEF coefficients by applying a window of WIN_SIZE data points and an increment of INC points.

     Before computing the Fourier transform, one of the following windows is applied:

     "hanning"
          win_type = 1

     "hamming"
          win_type = 2

     "rectangle"
          win_type = 3

     The window names can be passed as strings or by the WIN_TYPE number.

     The following defaults are used for unspecified arguments: WIN_SIZE = 80, INC = 24, NUM_COEF = 64, and WIN_TYPE = 1.

     'Y = stft (X, ...)' returns the absolute values of the Fourier coefficients according to the NUM_COEF positive frequencies.

     '[Y, C] = stft (x, ...)' returns the entire STFT-matrix Y and a 3-element vector C containing the window size, increment, and window type, which is needed by the 'synthesis' function.

     See also: synthesis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 160
Compute the short-time Fourier transform of the vector X with NUM_COEF coefficients by applying a window of WIN_SIZE data points and an increment of INC points.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
synthesis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 282
 -- Function File: X = synthesis (Y, C)
     Compute a signal from its short-time Fourier transform Y and a 3-element vector C specifying window size, increment, and window type.

     The values Y and C can be derived by

          [Y, C] = stft (X , ...)

     See also: stft.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
Compute a signal from its short-time Fourier transform Y and a 3-element vector C specifying window size, increment, and window type.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
unwrap


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 371
 -- Function File: B = unwrap (X)
 -- Function File: B = unwrap (X, TOL)
 -- Function File: B = unwrap (X, TOL, DIM)

     Unwrap radian phases by adding multiples of 2*pi as appropriate to remove jumps greater than TOL.

     TOL defaults to pi.

     Unwrap will work along the dimension DIM.  If DIM is unspecified it defaults to the first non-singleton dimension.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Unwrap radian phases by adding multiples of 2*pi as appropriate to remove jumps greater than TOL.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
yulewalker


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 235
 -- Function File: [A, V] = yulewalker (C)
     Fit an AR (p)-model with Yule-Walker estimates given a vector C of autocovariances '[gamma_0, ..., gamma_p]'.

     Returns the AR coefficients, A, and the variance of white noise, V.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Fit an AR (p)-model with Yule-Walker estimates given a vector C of autocovariances '[gamma_0, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
bicg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1631
 -- Function File: X = bicg (A, B, RTOL, MAXIT, M1, M2, X0)
 -- Function File: X = bicg (A, B, RTOL, MAXIT, P)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = bicg (A, B, ...)
     Solve 'A x = b' using the Bi-conjugate gradient iterative method.

        - RTOL is the relative tolerance, if not given or set to [] the default value 1e-6 is used.

        - MAXIT the maximum number of outer iterations, if not given or set to [] the default value 'min (20, numel (b))' is used.

        - X0 the initial guess, if not given or set to [] the default value 'zeros (size (b))' is used.

     A can be passed as a matrix or as a function handle or inline function 'f' such that 'f(x, "notransp") = A*x' and 'f(x, "transp") = A'*x'.

     The preconditioner P is given as 'P = M1 * M2'.  Both M1 and M2 can be passed as a matrix or as a function handle or inline function 'g' such that 'g(x, "notransp") = M1 \ x' or 'g(x, "notransp") = M2 \ x' and 'g(x, "transp") = M1' \ x' or 'g(x, "transp") = M2' \ x'.

     If called with more than one output parameter

        - FLAG indicates the exit status:

             - 0: iteration converged to the within the chosen tolerance

             - 1: the maximum number of iterations was reached before convergence

             - 3: the algorithm reached stagnation

          (the value 2 is unused but skipped for compatibility).

        - RELRES is the final value of the relative residual.

        - ITER is the number of iterations performed.

        - RESVEC is a vector containing the relative residual at each iteration.

     See also: bicgstab, cgs, gmres, pcg, qmr.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Solve 'A x = b' using the Bi-conjugate gradient iterative method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
bicgstab


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1526
 -- Function File: X = bicgstab (A, B, RTOL, MAXIT, M1, M2, X0)
 -- Function File: X = bicgstab (A, B, RTOL, MAXIT, P)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = bicgstab (A, B, ...)
     Solve 'A x = b' using the stabilizied Bi-conjugate gradient iterative method.

        - RTOL is the relative tolerance, if not given or set to [] the default value 1e-6 is used.

        - MAXIT the maximum number of outer iterations, if not given or set to [] the default value 'min (20, numel (b))' is used.

        - X0 the initial guess, if not given or set to [] the default value 'zeros (size (b))' is used.

     A can be passed as a matrix or as a function handle or inline function 'f' such that 'f(x) = A*x'.

     The preconditioner P is given as 'P = M1 * M2'.  Both M1 and M2 can be passed as a matrix or as a function handle or inline function 'g' such that 'g(x) = M1 \ x' or 'g(x) = M2 \ x'.

     If called with more than one output parameter

        - FLAG indicates the exit status:

             - 0: iteration converged to the within the chosen tolerance

             - 1: the maximum number of iterations was reached before convergence

             - 3: the algorithm reached stagnation

          (the value 2 is unused but skipped for compatibility).

        - RELRES is the final value of the relative residual.

        - ITER is the number of iterations performed.

        - RESVEC is a vector containing the relative residual at each iteration.

     See also: bicg, cgs, gmres, pcg, qmr.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
Solve 'A x = b' using the stabilizied Bi-conjugate gradient iterative method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
cgs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1528
 -- Function File: X = cgs (A, B, RTOL, MAXIT, M1, M2, X0)
 -- Function File: X = cgs (A, B, RTOL, MAXIT, P)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = cgs (A, B, ...)
     Solve 'A x = b', where A is a square matrix, using the Conjugate Gradients Squared method.

        - RTOL is the relative tolerance, if not given or set to [] the default value 1e-6 is used.

        - MAXIT the maximum number of outer iterations, if not given or set to [] the default value 'min (20, numel (b))' is used.

        - X0 the initial guess, if not given or set to [] the default value 'zeros (size (b))' is used.

     A can be passed as a matrix or as a function handle or inline function 'f' such that 'f(x) = A*x'.

     The preconditioner P is given as 'P = M1 * M2'.  Both M1 and M2 can be passed as a matrix or as a function handle or inline function 'g' such that 'g(x) = M1 \ x' or 'g(x) = M2 \ x'.

     If called with more than one output parameter

        - FLAG indicates the exit status:

             - 0: iteration converged to the within the chosen tolerance

             - 1: the maximum number of iterations was reached before convergence

             - 3: the algorithm reached stagnation

          (the value 2 is unused but skipped for compatibility).

        - RELRES is the final value of the relative residual.

        - ITER is the number of iterations performed.

        - RESVEC is a vector containing the relative residual at each iteration.

     See also: pcg, bicgstab, bicg, gmres, qmr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Solve 'A x = b', where A is a square matrix, using the Conjugate Gradients Squared method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
colperm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 309
 -- Function File: P = colperm (S)
     Return the column permutations such that the columns of 'S (:, P)' are ordered in terms of increasing number of nonzero elements.

     If S is symmetric, then P is chosen such that 'S (P, P)' orders the rows and columns with increasing number of nonzeros elements.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
Return the column permutations such that the columns of 'S (:, P)' are ordered in terms of increasing number of nonzero elements.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
eigs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5549
 -- Function File: D = eigs (A)
 -- Function File: D = eigs (A, K)
 -- Function File: D = eigs (A, K, SIGMA)
 -- Function File: D = eigs (A, K, SIGMA, OPTS)
 -- Function File: D = eigs (A, B)
 -- Function File: D = eigs (A, B, K)
 -- Function File: D = eigs (A, B, K, SIGMA)
 -- Function File: D = eigs (A, B, K, SIGMA, OPTS)
 -- Function File: D = eigs (AF, N)
 -- Function File: D = eigs (AF, N, B)
 -- Function File: D = eigs (AF, N, K)
 -- Function File: D = eigs (AF, N, B, K)
 -- Function File: D = eigs (AF, N, K, SIGMA)
 -- Function File: D = eigs (AF, N, B, K, SIGMA)
 -- Function File: D = eigs (AF, N, K, SIGMA, OPTS)
 -- Function File: D = eigs (AF, N, B, K, SIGMA, OPTS)
 -- Function File: [V, D] = eigs (A, ...)
 -- Function File: [V, D] = eigs (AF, N, ...)
 -- Function File: [V, D, FLAG] = eigs (A, ...)
 -- Function File: [V, D, FLAG] = eigs (AF, N, ...)
     Calculate a limited number of eigenvalues and eigenvectors of A, based on a selection criteria.

     The number of eigenvalues and eigenvectors to calculate is given by K and defaults to 6.

     By default, 'eigs' solve the equation 'A * v = lambda * v', where 'lambda' is a scalar representing one of the eigenvalues, and 'v' is the corresponding eigenvector.  If given the positive definite matrix B then 'eigs' solves the general eigenvalue equation 'A * v = lambda * B * v'.

     The argument SIGMA determines which eigenvalues are returned.  SIGMA can be either a scalar or a string.  When SIGMA is a scalar, the K eigenvalues closest to SIGMA are returned.  If SIGMA is a string, it must have one of the following values.

     "lm"
          Largest Magnitude (default).

     "sm"
          Smallest Magnitude.

     "la"
          Largest Algebraic (valid only for real symmetric problems).

     "sa"
          Smallest Algebraic (valid only for real symmetric problems).

     "be"
          Both Ends, with one more from the high-end if K is odd (valid only for real symmetric problems).

     "lr"
          Largest Real part (valid only for complex or unsymmetric problems).

     "sr"
          Smallest Real part (valid only for complex or unsymmetric problems).

     "li"
          Largest Imaginary part (valid only for complex or unsymmetric problems).

     "si"
          Smallest Imaginary part (valid only for complex or unsymmetric problems).

     If OPTS is given, it is a structure defining possible options that 'eigs' should use.  The fields of the OPTS structure are:

     'issym'
          If AF is given, then flags whether the function AF defines a symmetric problem.  It is ignored if A is given.  The default is false.

     'isreal'
          If AF is given, then flags whether the function AF defines a real problem.  It is ignored if A is given.  The default is true.

     'tol'
          Defines the required convergence tolerance, calculated as 'tol * norm (A)'.  The default is 'eps'.

     'maxit'
          The maximum number of iterations.  The default is 300.

     'p'
          The number of Lanzcos basis vectors to use.  More vectors will result in faster convergence, but a greater use of memory.  The optimal value of 'p' is problem dependent and should be in the range K to N.  The default value is '2 * K'.

     'v0'
          The starting vector for the algorithm.  An initial vector close to the final vector will speed up convergence.  The default is for ARPACK to randomly generate a starting vector.  If specified, 'v0' must be an N-by-1 vector where 'N = rows (A)'

     'disp'
          The level of diagnostic printout (0|1|2).  If 'disp' is 0 then diagnostics are disabled.  The default value is 0.

     'cholB'
          Flag if 'chol (B)' is passed rather than B.  The default is false.

     'permB'
          The permutation vector of the Cholesky factorization of B if 'cholB' is true.  That is 'chol (B(permB, permB))'.  The default is '1:N'.

     It is also possible to represent A by a function denoted AF.  AF must be followed by a scalar argument N defining the length of the vector argument accepted by AF.  AF can be a function handle, an inline function, or a string.  When AF is a string it holds the name of the function to use.

     AF is a function of the form 'y = af (x)' where the required return value of AF is determined by the value of SIGMA.  The four possible forms are

     'A * x'
          if SIGMA is not given or is a string other than "sm".

     'A \ x'
          if SIGMA is 0 or "sm".

     '(A - sigma * I) \ x'
          for the standard eigenvalue problem, where 'I' is the identity matrix of the same size as A.

     '(A - sigma * B) \ x'
          for the general eigenvalue problem.

     The return arguments of 'eigs' depend on the number of return arguments requested.  With a single return argument, a vector D of length K is returned containing the K eigenvalues that have been found.  With two return arguments, V is a N-by-K matrix whose columns are the K eigenvectors corresponding to the returned eigenvalues.  The eigenvalues themselves are returned in D in the form of a N-by-K matrix, where the elements on the diagonal are the eigenvalues.

     Given a third return argument FLAG, 'eigs' returns the status of the convergence.  If FLAG is 0 then all eigenvalues have converged.  Any other value indicates a failure to converge.

     This function is based on the ARPACK package, written by R. Lehoucq, K. Maschhoff, D. Sorensen, and C. Yang.  For more information see <http://www.caam.rice.edu/software/ARPACK/>.

     See also: eig, svds.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Calculate a limited number of eigenvalues and eigenvectors of A, based on a selection criteria.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
etreeplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 285
 -- Function File: etreeplot (A)
 -- Function File: etreeplot (A, NODE_STYLE, EDGE_STYLE)
     Plot the elimination tree of the matrix A or A+A' if A in not symmetric.

     The optional parameters NODE_STYLE and EDGE_STYLE define the output style.

     See also: treeplot, gplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Plot the elimination tree of the matrix A or A+A' if A in not symmetric.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gmres


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1678
 -- Function File: X = gmres (A, B, M, RTOL, MAXIT, M1, M2, X0)
 -- Function File: X = gmres (A, B, M, RTOL, MAXIT, P)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = gmres (...)
     Solve 'A x = b' using the Preconditioned GMRES iterative method with restart, a.k.a.  PGMRES(m).

        - RTOL is the relative tolerance, if not given or set to [] the default value 1e-6 is used.

        - MAXIT is the maximum number of outer iterations, if not given or set to [] the default value 'min (10, numel (b) / restart)' is used.

        - X0 is the initial guess, if not given or set to [] the default value 'zeros (size (b))' is used.

        - M is the restart parameter, if not given or set to [] the default value 'numel (b)' is used.

     Argument A can be passed as a matrix, function handle, or inline function 'f' such that 'f(x) = A*x'.

     The preconditioner P is given as 'P = M1 * M2'.  Both M1 and M2 can be passed as a matrix, function handle, or inline function 'g' such that 'g(x) = M1\x' or 'g(x) = M2\x'.

     Besides the vector X, additional outputs are:

        - FLAG indicates the exit status:

          0 : iteration converged to within the specified tolerance

          1 : maximum number of iterations exceeded

          2 : unused, but skipped for compatibility

          3 : algorithm reached stagnation (no change between iterations)

        - RELRES is the final value of the relative residual.

        - ITER is a vector containing the number of outer iterations and total iterations performed.

        - RESVEC is a vector containing the relative residual at each iteration.

     See also: bicg, bicgstab, cgs, pcg, pcr, qmr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Solve 'A x = b' using the Preconditioned GMRES iterative method with restart, a.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
gplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 572
 -- Function File: gplot (A, XY)
 -- Function File: gplot (A, XY, LINE_STYLE)
 -- Function File: [X, Y] = gplot (A, XY)
     Plot a graph defined by A and XY in the graph theory sense.

     A is the adjacency matrix of the array to be plotted and XY is an N-by-2 matrix containing the coordinates of the nodes of the graph.

     The optional parameter LINE_STYLE defines the output style for the plot.  Called with no output arguments the graph is plotted directly.  Otherwise, return the coordinates of the plot in X and Y.

     See also: treeplot, etreeplot, spy.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Plot a graph defined by A and XY in the graph theory sense.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ichol


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3987
 -- Function File: L = ichol (A)
 -- Function File: L = ichol (A, OPTS)

     Compute the incomplete Cholesky factorization of the sparse square matrix A.

     By default, 'ichol' uses only the lower triangle of A and produces a lower triangular factor L such that L*L' approximates A.

     The factor given by this routine may be useful as a preconditioner for a system of linear equations being solved by iterative methods such as PCG (Preconditioned Conjugate Gradient).

     The factorization may be modified by passing options in a structure OPTS.  The option name is a field of the structure and the setting is the value of field.  Names and specifiers are case sensitive.

     type
          Type of factorization.

          "nofill" (default)
               Incomplete Cholesky factorization with no fill-in (IC(0)).

          "ict"
               Incomplete Cholesky factorization with threshold dropping (ICT).

     diagcomp
          A non-negative scalar ALPHA for incomplete Cholesky factorization of 'A + ALPHA * diag (diag (A))' instead of A.  This can be useful when A is not positive definite.  The default value is 0.

     droptol
          A non-negative scalar specifying the drop tolerance for factorization if performing ICT.  The default value is 0 which produces the complete Cholesky factorization.

          Non-diagonal entries of L are set to 0 unless

          'abs (L(i,j)) >= droptol * norm (A(j:end, j), 1)'.

     michol
          Modified incomplete Cholesky factorization:

          "off" (default)
               Row and column sums are not necessarily preserved.

          "on"
               The diagonal of L is modified so that row (and column) sums are preserved even when elements have been dropped during the factorization.  The relationship preserved is: 'A * e = L * L' * e', where e is a vector of ones.

     shape

          "lower" (default)
               Use only the lower triangle of A and return a lower triangular factor L such that L*L' approximates A.

          "upper"
               Use only the upper triangle of A and return an upper triangular factor U such that 'U'*U' approximates A.

     EXAMPLES

     The following problem demonstrates how to factorize a sample symmetric positive definite matrix with the full Cholesky decomposition and with the incomplete one.

          A = [ 0.37, -0.05,  -0.05,  -0.07;
               -0.05,  0.116,  0.0,   -0.05;
               -0.05,  0.0,    0.116, -0.05;
               -0.07, -0.05,  -0.05,   0.202];
          A = sparse (A);
          nnz (tril (A))
          ans =  9
          L = chol (A, "lower");
          nnz (L)
          ans =  10
          norm (A - L * L', "fro") / norm (A, "fro")
          ans =  1.1993e-16
          opts.type = "nofill";
          L = ichol (A, opts);
          nnz (L)
          ans =  9
          norm (A - L * L', "fro") / norm (A, "fro")
          ans =  0.019736

     Another example for decomposition is a finite difference matrix used to solve a boundary value problem on the unit square.

          nx = 400; ny = 200;
          hx = 1 / (nx + 1); hy = 1 / (ny + 1);
          Dxx = spdiags ([ones(nx, 1), -2*ones(nx, 1), ones(nx, 1)],
                         [-1 0 1 ], nx, nx) / (hx ^ 2);
          Dyy = spdiags ([ones(ny, 1), -2*ones(ny, 1), ones(ny, 1)],
                         [-1 0 1 ], ny, ny) / (hy ^ 2);
          A = -kron (Dxx, speye (ny)) - kron (speye (nx), Dyy);
          nnz (tril (A))
          ans =  239400
          opts.type = "nofill";
          L = ichol (A, opts);
          nnz (tril (A))
          ans =  239400
          norm (A - L * L', "fro") / norm (A, "fro")
          ans =  0.062327

     References for implemented algorithms:

     [1] Y. Saad.  "Preconditioning Techniques."  'Iterative Methods for Sparse Linear Systems', PWS Publishing Company, 1996.

     [2] M. Jones, P. Plassmann: 'An Improved Incomplete Cholesky Factorization', 1992.

     See also: chol, ilu, pcg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
Compute the incomplete Cholesky factorization of the sparse square matrix A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
ilu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4241
 -- Function File: ilu (A)
 -- Function File: ilu (A, OPTS)
 -- Function File: [L, U] = ilu (...)
 -- Function File: [L, U, P] = ilu (...)

     Compute the incomplete LU factorization of the sparse square matrix A.

     'ilu' returns a unit lower triangular matrix L, an upper triangular matrix U, and optionally a permutation matrix P, such that 'L*U' approximates 'P*A'.

     The factors given by this routine may be useful as preconditioners for a system of linear equations being solved by iterative methods such as BICG (BiConjugate Gradients) or GMRES (Generalized Minimum Residual Method).

     The factorization may be modified by passing options in a structure OPTS.  The option name is a field of the structure and the setting is the value of field.  Names and specifiers are case sensitive.

     'type'
          Type of factorization.

          "nofill"
               ILU factorization with no fill-in (ILU(0)).

               Additional supported options: 'milu'.

          "crout"
               Crout version of ILU factorization (ILUC).

               Additional supported options: 'milu', 'droptol'.

          "ilutp" (default)
               ILU factorization with threshold and pivoting.

               Additional supported options: 'milu', 'droptol', 'udiag', 'thresh'.

     'droptol'
          A non-negative scalar specifying the drop tolerance for factorization.  The default value is 0 which produces the complete LU factorization.

          Non-diagonal entries of U are set to 0 unless

          'abs (U(i,j)) >= droptol * norm (A(:,j))'.

          Non-diagonal entries of L are set to 0 unless

          'abs (L(i,j)) >= droptol * norm (A(:,j))/U(j,j)'.

     'milu'
          Modified incomplete LU factorization:

          "row"
               Row-sum modified incomplete LU factorization.  The factorization preserves row sums: 'A * e = L * U * e', where e is a vector of ones.

          "col"
               Column-sum modified incomplete LU factorization.  The factorization preserves column sums: 'e' * A = e' * L * U'.

          "off" (default)
               Row and column sums are not necessarily preserved.

     'udiag'
          If true, any zeros on the diagonal of the upper triangular factor are replaced by the local drop tolerance 'droptol * norm (A(:,j))/U(j,j)'.  The default is false.

     'thresh'
          Pivot threshold for factorization.  It can range between 0 (diagonal pivoting) and 1 (default), where the maximum magnitude entry in the column is chosen to be the pivot.

     If 'ilu' is called with just one output, the returned matrix is 'L + U - speye (size (A))', where L is unit lower triangular and U is upper triangular.

     With two outputs, 'ilu' returns a unit lower triangular matrix L and an upper triangular matrix U.  For OPTS.type == "ilutp", one of the factors is permuted based on the value of OPTS.milu.  When OPTS.milu == "row", U is a column permuted upper triangular factor.  Otherwise, L is a row-permuted unit lower triangular factor.

     If there are three named outputs and OPTS.milu != "row", P is returned such that L and U are incomplete factors of 'P*A'.  When OPTS.milu == "row", P is returned such that L and U are incomplete factors of 'A*P'.

     EXAMPLES

          A = gallery ("neumann", 1600) + speye (1600);
          opts.type = "nofill";
          nnz (A)
          ans = 7840

          nnz (lu (A))
          ans = 126478

          nnz (ilu (A, opts))
          ans = 7840

     This shows that A has 7,840 nonzeros, the complete LU factorization has 126,478 nonzeros, and the incomplete LU factorization, with 0 level of fill-in, has 7,840 nonzeros, the same amount as A.  Taken from: http://www.mathworks.com/help/matlab/ref/ilu.html

          A = gallery ("wathen", 10, 10);
          b = sum (A, 2);
          tol = 1e-8;
          maxit = 50;
          opts.type = "crout";
          opts.droptol = 1e-4;
          [L, U] = ilu (A, opts);
          x = bicg (A, b, tol, maxit, L, U);
          norm (A * x - b, inf)

     This example uses ILU as preconditioner for a random FEM-Matrix, which has a large condition number.  Without L and U BICG would not converge.

     See also: lu, ichol, bicg, gmres.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
Compute the incomplete LU factorization of the sparse square matrix A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
nonzeros


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
 -- Function File: nonzeros (S)
     Return a vector of the nonzero values of the sparse matrix S.

     See also: find, nnz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Return a vector of the nonzero values of the sparse matrix S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
pcg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5539
 -- Function File: X = pcg (A, B, TOL, MAXIT, M1, M2, X0, ...)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC, EIGEST] = pcg (...)

     Solve the linear system of equations 'A * X = B' by means of the Preconditioned Conjugate Gradient iterative method.

     The input arguments are

        * A can be either a square (preferably sparse) matrix or a function handle, inline function or string containing the name of a function which computes 'A * X'.  In principle, A should be symmetric and positive definite; if 'pcg' finds A not to be positive definite, a warning is printed and the FLAG output will be set.

        * B is the right-hand side vector.

        * TOL is the required relative tolerance for the residual error, 'B - A * X'.  The iteration stops if 'norm (B - A * X)' <= TOL * norm (B).  If TOL is omitted or empty then a tolerance of 1e-6 is used.

        * MAXIT is the maximum allowable number of iterations; if MAXIT is omitted or empty then a value of 20 is used.

        * M = M1 * M2 is the (left) preconditioning matrix, so that the iteration is (theoretically) equivalent to solving by 'pcg' 'P * X = M \ B', with 'P = M \ A'.  Note that a proper choice of the preconditioner may dramatically improve the overall performance of the method.  Instead of matrices M1 and M2, the user may pass two functions which return the results of applying the inverse of M1 and M2 to a vector (usually this is the preferred way of using the preconditioner).  If M1 is omitted or empty '[]' then no preconditioning is applied.  If M2 is omitted, M = M1 will be used as a preconditioner.

        * X0 is the initial guess.  If X0 is omitted or empty then the function sets X0 to a zero vector by default.

     The arguments which follow X0 are treated as parameters, and passed in a proper way to any of the functions (A or M) which are passed to 'pcg'.  See the examples below for further details.  The output arguments are

        * X is the computed approximation to the solution of 'A * X = B'.

        * FLAG reports on the convergence.  A value of 0 means the solution converged and the tolerance criterion given by TOL is satisfied.  A value of 1 means that the MAXIT limit for the iteration count was reached.  A value of 3 indicates that the (preconditioned) matrix was found not to be positive definite.

        * RELRES is the ratio of the final residual to its initial value, measured in the Euclidean norm.

        * ITER is the actual number of iterations performed.

        * RESVEC describes the convergence history of the method.  'RESVEC(i,1)' is the Euclidean norm of the residual, and 'RESVEC(i,2)' is the preconditioned residual norm, after the (I-1)-th iteration, 'I = 1, 2, ..., ITER+1'.  The preconditioned residual norm is defined as 'norm (R) ^ 2 = R' * (M \ R)' where 'R = B - A * X', see also the description of M.  If EIGEST is not required, only 'RESVEC(:,1)' is returned.

        * EIGEST returns the estimate for the smallest 'EIGEST(1)' and largest 'EIGEST(2)' eigenvalues of the preconditioned matrix 'P = M \ A'.  In particular, if no preconditioning is used, the estimates for the extreme eigenvalues of A are returned.  'EIGEST(1)' is an overestimate and 'EIGEST(2)' is an underestimate, so that 'EIGEST(2) / EIGEST(1)' is a lower bound for 'cond (P, 2)', which nevertheless in the limit should theoretically be equal to the actual value of the condition number.  The method which computes EIGEST works only for symmetric positive definite A and M, and the user is responsible for verifying this assumption.

     Let us consider a trivial problem with a diagonal matrix (we exploit the sparsity of A)

          n = 10;
          A = diag (sparse (1:n));
          b = rand (n, 1);
          [l, u, p] = ilu (A, struct ("droptol", 1.e-3));

     EXAMPLE 1: Simplest use of 'pcg'

          x = pcg (A, b)

     EXAMPLE 2: 'pcg' with a function which computes 'A * X'

          function y = apply_a (x)
            y = [1:N]' .* x;
          endfunction

          x = pcg ("apply_a", b)

     EXAMPLE 3: 'pcg' with a preconditioner: L * U

          x = pcg (A, b, 1.e-6, 500, l*u)

     EXAMPLE 4: 'pcg' with a preconditioner: L * U.  Faster than EXAMPLE 3 since lower and upper triangular matrices are easier to invert

          x = pcg (A, b, 1.e-6, 500, l, u)

     EXAMPLE 5: Preconditioned iteration, with full diagnostics.  The preconditioner (quite strange, because even the original matrix A is trivial) is defined as a function

          function y = apply_m (x)
            k = floor (length (x) - 2);
            y = x;
            y(1:k) = x(1:k) ./ [1:k]';
          endfunction

          [x, flag, relres, iter, resvec, eigest] = ...
                             pcg (A, b, [], [], "apply_m");
          semilogy (1:iter+1, resvec);

     EXAMPLE 6: Finally, a preconditioner which depends on a parameter K.

          function y = apply_M (x, varargin)
            K = varargin{1};
            y = x;
            y(1:K) = x(1:K) ./ [1:K]';
          endfunction

          [x, flag, relres, iter, resvec, eigest] = ...
               pcg (A, b, [], [], "apply_m", [], [], 3)

     References:

       1. C.T. Kelley, 'Iterative Methods for Linear and Nonlinear Equations', SIAM, 1995.  (the base PCG algorithm)

       2. Y. Saad, 'Iterative Methods for Sparse Linear Systems', PWS 1996.  (condition number estimate from PCG) Revised version of this book is available online at <http://www-users.cs.umn.edu/~saad/books.html>

     See also: sparse, pcr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
Solve the linear system of equations 'A * X = B' by means of the Preconditioned Conjugate Gradient iterative method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
pcr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4047
 -- Function File: X = pcr (A, B, TOL, MAXIT, M, X0, ...)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = pcr (...)

     Solve the linear system of equations 'A * X = B' by means of the Preconditioned Conjugate Residuals iterative method.

     The input arguments are

        * A can be either a square (preferably sparse) matrix or a function handle, inline function or string containing the name of a function which computes 'A * X'.  In principle A should be symmetric and non-singular; if 'pcr' finds A to be numerically singular, you will get a warning message and the FLAG output parameter will be set.

        * B is the right hand side vector.

        * TOL is the required relative tolerance for the residual error, 'B - A * X'.  The iteration stops if 'norm (B - A * X) <= TOL * norm (B - A * X0)'.  If TOL is empty or is omitted, the function sets 'TOL = 1e-6' by default.

        * MAXIT is the maximum allowable number of iterations; if '[]' is supplied for 'maxit', or 'pcr' has less arguments, a default value equal to 20 is used.

        * M is the (left) preconditioning matrix, so that the iteration is (theoretically) equivalent to solving by 'pcr' 'P * X = M \ B', with 'P = M \ A'.  Note that a proper choice of the preconditioner may dramatically improve the overall performance of the method.  Instead of matrix M, the user may pass a function which returns the results of applying the inverse of M to a vector (usually this is the preferred way of using the preconditioner).  If '[]' is supplied for M, or M is omitted, no preconditioning is applied.

        * X0 is the initial guess.  If X0 is empty or omitted, the function sets X0 to a zero vector by default.

     The arguments which follow X0 are treated as parameters, and passed in a proper way to any of the functions (A or M) which are passed to 'pcr'.  See the examples below for further details.

     The output arguments are

        * X is the computed approximation to the solution of 'A * X = B'.

        * FLAG reports on the convergence.  'FLAG = 0' means the solution converged and the tolerance criterion given by TOL is satisfied.  'FLAG = 1' means that the MAXIT limit for the iteration count was reached.  'FLAG = 3' reports a 'pcr' breakdown, see [1] for details.

        * RELRES is the ratio of the final residual to its initial value, measured in the Euclidean norm.

        * ITER is the actual number of iterations performed.

        * RESVEC describes the convergence history of the method, so that 'RESVEC (i)' contains the Euclidean norms of the residual after the (I-1)-th iteration, 'I = 1,2, ..., ITER+1'.

     Let us consider a trivial problem with a diagonal matrix (we exploit the sparsity of A)

          n = 10;
          A = sparse (diag (1:n));
          b = rand (N, 1);

     EXAMPLE 1: Simplest use of 'pcr'

          x = pcr (A, b)

     EXAMPLE 2: 'pcr' with a function which computes 'A * X'.

          function y = apply_a (x)
            y = [1:10]' .* x;
          endfunction

          x = pcr ("apply_a", b)

     EXAMPLE 3: Preconditioned iteration, with full diagnostics.  The preconditioner (quite strange, because even the original matrix A is trivial) is defined as a function

          function y = apply_m (x)
            k = floor (length (x) - 2);
            y = x;
            y(1:k) = x(1:k) ./ [1:k]';
          endfunction

          [x, flag, relres, iter, resvec] = ...
                             pcr (A, b, [], [], "apply_m")
          semilogy ([1:iter+1], resvec);

     EXAMPLE 4: Finally, a preconditioner which depends on a parameter K.

          function y = apply_m (x, varargin)
            k = varargin{1};
            y = x;
            y(1:k) = x(1:k) ./ [1:k]';
          endfunction

          [x, flag, relres, iter, resvec] = ...
                             pcr (A, b, [], [], "apply_m"', [], 3)

     References:

     [1] W. Hackbusch, 'Iterative Solution of Large Sparse Systems of Equations', section 9.5.4; Springer, 1994

     See also: sparse, pcg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 117
Solve the linear system of equations 'A * X = B' by means of the Preconditioned Conjugate Residuals iterative method.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
qmr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2064
 -- Function File: X = qmr (A, B, RTOL, MAXIT, M1, M2, X0)
 -- Function File: X = qmr (A, B, RTOL, MAXIT, P)
 -- Function File: [X, FLAG, RELRES, ITER, RESVEC] = qmr (A, B, ...)
     Solve 'A x = b' using the Quasi-Minimal Residual iterative method (without look-ahead).

        - RTOL is the relative tolerance, if not given or set to [] the default value 1e-6 is used.

        - MAXIT the maximum number of outer iterations, if not given or set to [] the default value 'min (20, numel (b))' is used.

        - X0 the initial guess, if not given or set to [] the default value 'zeros (size (b))' is used.

     A can be passed as a matrix or as a function handle or inline function 'f' such that 'f(x, "notransp") = A*x' and 'f(x, "transp") = A'*x'.

     The preconditioner P is given as 'P = M1 * M2'.  Both M1 and M2 can be passed as a matrix or as a function handle or inline function 'g' such that 'g(x, "notransp") = M1 \ x' or 'g(x, "notransp") = M2 \ x' and 'g(x, "transp") = M1' \ x' or 'g(x, "transp") = M2' \ x'.

     If called with more than one output parameter

        - FLAG indicates the exit status:

             - 0: iteration converged to the within the chosen tolerance

             - 1: the maximum number of iterations was reached before convergence

             - 3: the algorithm reached stagnation

          (the value 2 is unused but skipped for compatibility).

        - RELRES is the final value of the relative residual.

        - ITER is the number of iterations performed.

        - RESVEC is a vector containing the residual norms at each iteration.

     References:

       1. R. Freund and N. Nachtigal, 'QMR: a quasi-minimal residual method for non-Hermitian linear systems', Numerische Mathematik, 1991, 60, pp.  315-339.

       2. R. Barrett, M. Berry, T. Chan, J. Demmel, J. Donato, J. Dongarra, V. Eijkhour, R. Pozo, C. Romine, and H. van der Vorst, 'Templates for the solution of linear systems: Building blocks for iterative methods', SIAM, 2nd ed., 1994.

     See also: bicg, bicgstab, cgs, gmres, pcg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 87
Solve 'A x = b' using the Quasi-Minimal Residual iterative method (without look-ahead).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
spaugment


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1299
 -- Function File: S = spaugment (A, C)
     Create the augmented matrix of A.

     This is given by

          [C * eye(M, M), A;
                      A', zeros(N, N)]

     This is related to the least squares solution of 'A \ B', by

          S * [ R / C; x] = [ B, zeros(N, columns(B)) ]

     where R is the residual error

          R = B - A * X

     As the matrix S is symmetric indefinite it can be factorized with 'lu', and the minimum norm solution can therefore be found without the need for a 'qr' factorization.  As the residual error will be 'zeros (M, M)' for underdetermined problems, and example can be

          m = 11; n = 10; mn = max (m, n);
          A = spdiags ([ones(mn,1), 10*ones(mn,1), -ones(mn,1)],
                       [-1, 0, 1], m, n);
          x0 = A \ ones (m,1);
          s = spaugment (A);
          [L, U, P, Q] = lu (s);
          x1 = Q * (U \ (L \ (P  * [ones(m,1); zeros(n,1)])));
          x1 = x1(end - n + 1 : end);

     To find the solution of an overdetermined problem needs an estimate of the residual error R and so it is more complex to formulate a minimum norm solution using the 'spaugment' function.

     In general the left division operator is more stable and faster than using the 'spaugment' function.

     See also: mldivide.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Create the augmented matrix of A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
spconvert


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 424
 -- Function File: X = spconvert (M)
     Convert a simple sparse matrix format easily generated by other programs into Octave's internal sparse format.

     The input M is either a 3 or 4 column real matrix, containing the row, column, real, and imaginary parts of the elements of the sparse matrix.  An element with a zero real and imaginary part can be used to force a particular matrix size.

     See also: sparse.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 110
Convert a simple sparse matrix format easily generated by other programs into Octave's internal sparse format.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
spdiags


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1119
 -- Function File: B = spdiags (A)
 -- Function File: [B, D] = spdiags (A)
 -- Function File: B = spdiags (A, D)
 -- Function File: A = spdiags (V, D, A)
 -- Function File: A = spdiags (V, D, M, N)
     A generalization of the function 'diag'.

     Called with a single input argument, the nonzero diagonals D of A are extracted.

     With two arguments the diagonals to extract are given by the vector D.

     The other two forms of 'spdiags' modify the input matrix by replacing the diagonals.  They use the columns of V to replace the diagonals represented by the vector D.  If the sparse matrix A is defined then the diagonals of this matrix are replaced.  Otherwise a matrix of M by N is created with the diagonals given by the columns of V.

     Negative values of D represent diagonals below the main diagonal, and positive values of D diagonals above the main diagonal.

     For example:

          spdiags (reshape (1:12, 4, 3), [-1 0 1], 5, 4)
             => 5 10  0  0
                1  6 11  0
                0  2  7 12
                0  0  3  8
                0  0  0  4

     See also: diag.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
A generalization of the function 'diag'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
speye


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 501
 -- Function File: S = speye (M, N)
 -- Function File: S = speye (M)
 -- Function File: S = speye (SZ)
     Return a sparse identity matrix of size MxN.

     The implementation is significantly more efficient than 'sparse (eye (M))' as the full matrix is not constructed.

     Called with a single argument a square matrix of size M-by-M is created.  If called with a single vector argument SZ, this argument is taken to be the size of the matrix to create.

     See also: sparse, spdiags, eye.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Return a sparse identity matrix of size MxN.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
spfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 287
 -- Function File: Y = spfun (F, S)
     Compute 'f(S)' for the nonzero values of S.

     This results in a sparse matrix with the same structure as S.  The function F can be passed as a string, a function handle, or an inline function.

     See also: arrayfun, cellfun, structfun.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Compute 'f(S)' for the nonzero values of S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
spones


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 215
 -- Function File: R = spones (S)
     Replace the nonzero entries of S with ones.

     This creates a sparse matrix with the same structure as S.

     See also: sparse, sprand, sprandn, sprandsym, spfun, spy.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Replace the nonzero entries of S with ones.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
sprand


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 748
 -- Function File: sprand (M, N, D)
 -- Function File: sprand (M, N, D, RC)
 -- Function File: sprand (S)
     Generate a sparse matrix with uniformly distributed random values.

     The size of the matrix is MxN with a density of values D.  D must be between 0 and 1.  Values will be uniformly distributed on the interval (0, 1).

     If called with a single matrix argument, a sparse matrix is generated with random values wherever the matrix S is nonzero.

     If called with a scalar fourth argument RC, a random sparse matrix with reciprocal condition number RC is generated.  If RC is a vector, then it specifies the first singular values of the generated matrix ('length (RC) <= min (M, N)').

     See also: sprandn, sprandsym, rand.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
Generate a sparse matrix with uniformly distributed random values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
sprandn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 763
 -- Function File: sprandn (M, N, D)
 -- Function File: sprandn (M, N, D, RC)
 -- Function File: sprandn (S)
     Generate a sparse matrix with normally distributed random values.

     The size of the matrix is MxN with a density of values D.  D must be between 0 and 1.  Values will be normally distributed with a mean of 0 and a variance of 1.

     If called with a single matrix argument, a sparse matrix is generated with random values wherever the matrix S is nonzero.

     If called with a scalar fourth argument RC, a random sparse matrix with reciprocal condition number RC is generated.  If RC is a vector, then it specifies the first singular values of the generated matrix ('length (RC) <= min (M, N)').

     See also: sprand, sprandsym, randn.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Generate a sparse matrix with normally distributed random values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
sprandsym


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 510
 -- Function File: sprandsym (N, D)
 -- Function File: sprandsym (S)
     Generate a symmetric random sparse matrix.

     The size of the matrix will be NxN, with a density of values given by D.  D must be between 0 and 1 inclusive.  Values will be normally distributed with a mean of zero and a variance of 1.

     If called with a single matrix argument, a random sparse matrix is generated wherever the matrix S is nonzero in its lower triangular part.

     See also: sprand, sprandn, spones, sparse.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
Generate a symmetric random sparse matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
spstats


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 571
 -- Function File: [COUNT, MEAN, VAR] = spstats (S)
 -- Function File: [COUNT, MEAN, VAR] = spstats (S, J)
     Return the stats for the nonzero elements of the sparse matrix S.

     COUNT is the number of nonzeros in each column, MEAN is the mean of the nonzeros in each column, and VAR is the variance of the nonzeros in each column.

     Called with two input arguments, if S is the data and J is the bin number for the data, compute the stats for each bin.  In this case, bins can contain data values of zero, whereas with 'spstats (S)' the zeros may disappear.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Return the stats for the nonzero elements of the sparse matrix S.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
spy


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 413
 -- Function File: spy (X)
 -- Function File: spy (..., MARKERSIZE)
 -- Function File: spy (..., LINE_SPEC)
     Plot the sparsity pattern of the sparse matrix X.

     If the argument MARKERSIZE is given as a scalar value, it is used to determine the point size in the plot.

     If the string LINE_SPEC is given it is passed to 'plot' and determines the appearance of the plot.

     See also: plot, gplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Plot the sparsity pattern of the sparse matrix X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
svds


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2206
 -- Function File: S = svds (A)
 -- Function File: S = svds (A, K)
 -- Function File: S = svds (A, K, SIGMA)
 -- Function File: S = svds (A, K, SIGMA, OPTS)
 -- Function File: [U, S, V] = svds (...)
 -- Function File: [U, S, V, FLAG] = svds (...)

     Find a few singular values of the matrix A.

     The singular values are calculated using

          [M, N] = size (A);
          S = eigs ([sparse(M, M), A;
                               A', sparse(N, N)])

     The eigenvalues returned by 'eigs' correspond to the singular values of A.  The number of singular values to calculate is given by K and defaults to 6.

     The argument SIGMA specifies which singular values to find.  When SIGMA is the string 'L', the default, the largest singular values of A are found.  Otherwise, SIGMA must be a real scalar and the singular values closest to SIGMA are found.  As a corollary, 'SIGMA = 0' finds the smallest singular values.  Note that for relatively small values of SIGMA, there is a chance that the requested number of singular values will not be found.  In that case SIGMA should be increased.

     OPTS is a structure defining options that 'svds' will pass to 'eigs'.  The possible fields of this structure are documented in 'eigs'.  By default, 'svds' sets the following three fields:

     'tol'
          The required convergence tolerance for the singular values.  The default value is 1e-10.  'eigs' is passed 'TOL / sqrt(2)'.

     'maxit'
          The maximum number of iterations.  The default is 300.

     'disp'
          The level of diagnostic printout (0|1|2).  If 'disp' is 0 then diagnostics are disabled.  The default value is 0.

     If more than one output is requested then 'svds' will return an approximation of the singular value decomposition of A

          A_approx = U*S*V'

     where A_approx is a matrix of size A but only rank K.

     FLAG returns 0 if the algorithm has succesfully converged, and 1 otherwise.  The test for convergence is

          norm (A*V - U*S, 1) <= TOL * norm (A, 1)

     'svds' is best for finding only a few singular values from a large sparse matrix.  Otherwise, 'svd (full (A))' will likely be more efficient.

See also: svd, eigs. 


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Find a few singular values of the matrix A.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
treelayout


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 396
 -- Function File: treelayout (TREE)
 -- Function File: treelayout (TREE, PERMUTATION)
     treelayout lays out a tree or a forest.

     The first argument TREE is a vector of predecessors.

     The parameter PERMUTATION is an optional postorder permutation.

     The complexity of the algorithm is O(n) in terms of time and memory requirements.

     See also: etreeplot, gplot, treeplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
treelayout lays out a tree or a forest.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
treeplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 400
 -- Function File: treeplot (TREE)
 -- Function File: treeplot (TREE, NODE_STYLE, EDGE_STYLE)
     Produce a graph of tree or forest.

     The first argument is vector of predecessors.

     The optional parameters NODE_STYLE and EDGE_STYLE define the output plot style.

     The complexity of the algorithm is O(n) in terms of is time and memory requirements.

     See also: etreeplot, gplot.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Produce a graph of tree or forest.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
bessel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2031
 -- Loadable Function: [J, IERR] = besselj (ALPHA, X, OPT)
 -- Loadable Function: [Y, IERR] = bessely (ALPHA, X, OPT)
 -- Loadable Function: [I, IERR] = besseli (ALPHA, X, OPT)
 -- Loadable Function: [K, IERR] = besselk (ALPHA, X, OPT)
 -- Loadable Function: [H, IERR] = besselh (ALPHA, K, X, OPT)
     Compute Bessel or Hankel functions of various kinds:

     'besselj'
          Bessel functions of the first kind.  If the argument OPT is supplied, the result is multiplied by 'exp (-abs (imag (x)))'.

     'bessely'
          Bessel functions of the second kind.  If the argument OPT is supplied, the result is multiplied by 'exp (-abs (imag (x)))'.

     'besseli'
          Modified Bessel functions of the first kind.  If the argument OPT is supplied, the result is multiplied by 'exp (-abs (real (x)))'.

     'besselk'
          Modified Bessel functions of the second kind.  If the argument OPT is supplied, the result is multiplied by 'exp (x)'.

     'besselh'
          Compute Hankel functions of the first (K = 1) or second (K = 2) kind.  If the argument OPT is supplied, the result is multiplied by 'exp (-I*X)' for K = 1 or 'exp (I*X)' for K = 2.

     If ALPHA is a scalar, the result is the same size as X.  If X is a scalar, the result is the same size as ALPHA.  If ALPHA is a row vector and X is a column vector, the result is a matrix with 'length (X)' rows and 'length (ALPHA)' columns.  Otherwise, ALPHA and X must conform and the result will be the same size.

     The value of ALPHA must be real.  The value of X may be complex.

     If requested, IERR contains the following status information and is the same size as the result.

       0. Normal return.

       1. Input error, return 'NaN'.

       2. Overflow, return 'Inf'.

       3. Loss of significance by argument reduction results in less than half of machine accuracy.

       4. Complete loss of significance by argument reduction, return 'NaN'.

       5. Error--no computation, algorithm termination condition not met, return 'NaN'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compute Bessel or Hankel functions of various kinds: 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
beta


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 489
 -- Mapping Function: beta (A, B)
     Compute the Beta function for real inputs A and B.

     The Beta function definition is

          beta (a, b) = gamma (a) * gamma (b) / gamma (a + b).

     The Beta function can grow quite large and it is often more useful to work with the logarithm of the output rather than the function directly.  *Note betaln: XREFbetaln, for computing the logarithm of the Beta function in an efficient manner.

     See also: betaln, betainc, betaincinv.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Compute the Beta function for real inputs A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
betaln


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 467
 -- Mapping Function: betaln (A, B)
     Compute the natural logarithm of the Beta function for real inputs A and B.

     'betaln' is defined as

          betaln (a, b) = log (beta (a, b))

     and is calculated in a way to reduce the occurrence of underflow.

     The Beta function can grow quite large and it is often more useful to work with the logarithm of the output rather than the function directly.

     See also: beta, betainc, betaincinv, gammaln.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Compute the natural logarithm of the Beta function for real inputs A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ellipke


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1167
 -- Function File: K = ellipke (M)
 -- Function File: K = ellipke (M, TOL)
 -- Function File: [K, E] = ellipke (...)
     Compute complete elliptic integrals of the first K(M) and second E(M) kind.

     M must be a scalar or real array with -Inf <= M <= 1.

     The optional input TOL controls the stopping tolerance of the algorithm and defaults to 'eps (class (M))'.  The tolerance can be increased to compute a faster, less accurate approximation.

     When called with one output only elliptic integrals of the first kind are returned.

     Mathematical Note:

     Elliptic integrals of the first kind are defined as

                   1
                  /               dt
          K (m) = | ------------------------------
                  / sqrt ((1 - t^2)*(1 - m*t^2))
                 0

     Elliptic integrals of the second kind are defined as

                   1
                  /  sqrt (1 - m*t^2)
          E (m) = |  ------------------ dt
                  /  sqrt (1 - t^2)
                 0

     Reference: Milton Abramowitz and Irene A. Stegun, 'Handbook of Mathematical Functions', Chapter 17, Dover, 1965.

     See also: ellipj.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Compute complete elliptic integrals of the first K(M) and second E(M) kind.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
expint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 640
 -- Function File: expint (X)
     Compute the exponential integral:

                     infinity
                    /
          E_1 (x) = | exp (-t)/t dt
                    /
                   x

     Note: For compatibility, this functions uses the MATLAB definition of the exponential integral.  Most other sources refer to this particular value as E_1 (x), and the exponential integral as

                      infinity
                     /
          Ei (x) = - | exp (-t)/t dt
                     /
                   -x

     The two definitions are related, for positive real values of X, by 'E_1 (-x) = -Ei (x) - i*pi'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Compute the exponential integral: 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
factor


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 529
 -- Function File: PF = factor (Q)
 -- Function File: [PF, N] = factor (Q)
     Return the prime factorization of Q.

     The prime factorization is defined as 'prod (PF) == Q' where every element of PF is a prime number.  If 'Q == 1', return 1.

     With two output arguments, return the unique prime factors PF and their multiplicities.  That is, 'prod (PF .^ N) == Q'.

     Implementation Note: The input Q must be less than 'bitmax' (9.0072e+15) in order to factor correctly.

     See also: gcd, lcm, isprime, primes.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Return the prime factorization of Q.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
factorial


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 527
 -- Function File: factorial (N)
     Return the factorial of N where N is a real non-negative integer.

     If N is a scalar, this is equivalent to 'prod (1:N)'.  For vector or matrix arguments, return the factorial of each element in the array.

     For non-integers see the generalized factorial function 'gamma'.  Note that the factorial function grows large quite quickly, and even with double precision values overflow will occur if N > 171.  For such cases consider 'gammaln'.

     See also: prod, gamma, gammaln.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Return the factorial of N where N is a real non-negative integer.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
isprime


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1426
 -- Function File: isprime (X)
     Return a logical array which is true where the elements of X are prime numbers and false where they are not.

     A prime number is conventionally defined as a positive integer greater than 1 (e.g., 2, 3, ...) which is divisible only by itself and 1.  Octave extends this definition to include both negative integers and complex values.  A negative integer is prime if its positive counterpart is prime.  This is equivalent to 'isprime (abs (x))'.

     If 'class (X)' is complex, then primality is tested in the domain of Gaussian integers (<http://en.wikipedia.org/wiki/Gaussian_integer>).  Some non-complex integers are prime in the ordinary sense, but not in the domain of Gaussian integers.  For example, 5 = (1+2i)*(1-2i) shows that 5 is not prime because it has a factor other than itself and 1.  Exercise caution when testing complex and real values together in the same matrix.

     Examples:

          isprime (1:6)
              => [0, 1, 1, 0, 1, 0]

          isprime ([i, 2, 3, 5])
              => [0, 0, 1, 0]

     Programming Note: 'isprime' is appropriate if the maximum value in X is not too large (< 1e15).  For larger values special purpose factorization code should be used.

     Compatibility Note: MATLAB does not extend the definition of prime numbers and will produce an error if given negative or complex inputs.

     See also: primes, factor, gcd, lcm.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
Return a logical array which is true where the elements of X are prime numbers and false where they are not.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
lcm


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 263
 -- Mapping Function: lcm (X, Y)
 -- Mapping Function: lcm (X, Y, ...)
     Compute the least common multiple of X and Y, or of the list of all arguments.

     All elements must be numeric and of the same size or scalar.

     See also: factor, gcd, isprime.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Compute the least common multiple of X and Y, or of the list of all arguments.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
legendre


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2306
 -- Function File: L = legendre (N, X)
 -- Function File: L = legendre (N, X, NORMALIZATION)
     Compute the Legendre function of degree N and order M = 0 ... N.

     The value N must be a real non-negative integer.

     X is a vector with real-valued elements in the range [-1, 1].

     The optional argument NORMALIZATION may be one of "unnorm", "sch", or "norm".  The default if no normalization is given is "unnorm".

     When the optional argument NORMALIZATION is "unnorm", compute the Legendre function of degree N and order M and return all values for M = 0 ... N.  The return value has one dimension more than X.

     The Legendre Function of degree N and order M:

           m         m      2  m/2   d^m
          P(x) = (-1) * (1-x  )    * ----  P(x)
           n                         dx^m   n

     with Legendre polynomial of degree N:

                    1    d^n   2    n
          P(x) = ------ [----(x - 1) ]
           n     2^n n!  dx^n

     'legendre (3, [-1.0, -0.9, -0.8])' returns the matrix:

           x  |   -1.0   |   -0.9   |   -0.8
          ------------------------------------
          m=0 | -1.00000 | -0.47250 | -0.08000
          m=1 |  0.00000 | -1.99420 | -1.98000
          m=2 |  0.00000 | -2.56500 | -4.32000
          m=3 |  0.00000 | -1.24229 | -3.24000

     When the optional argument 'normalization' is "sch", compute the Schmidt semi-normalized associated Legendre function.  The Schmidt semi-normalized associated Legendre function is related to the unnormalized Legendre functions by the following:

     For Legendre functions of degree N and order 0:

            0      0
          SP(x) = P(x)
            n      n

     For Legendre functions of degree n and order m:

            m      m         m    2(n-m)! 0.5
          SP(x) = P(x) * (-1)  * [-------]
            n      n              (n+m)!

     When the optional argument NORMALIZATION is "norm", compute the fully normalized associated Legendre function.  The fully normalized associated Legendre function is related to the unnormalized Legendre functions by the following:

     For Legendre functions of degree N and order M

            m      m         m    (n+0.5)(n-m)! 0.5
          NP(x) = P(x) * (-1)  * [-------------]
            n      n                  (n+m)!

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Compute the Legendre function of degree N and order M = 0 .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
nchoosek


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1338
 -- Function File: C = nchoosek (N, K)
 -- Function File: C = nchoosek (SET, K)

     Compute the binomial coefficient of N or list all possible combinations of a SET of items.

     If N is a scalar then calculate the binomial coefficient of N and K which is defined as

           /   \
           | n |    n (n-1) (n-2) ... (n-k+1)       n!
           |   |  = ------------------------- =  ---------
           | k |               k!                k! (n-k)!
           \   /

     This is the number of combinations of N items taken in groups of size K.

     If the first argument is a vector, SET, then generate all combinations of the elements of SET, taken K at a time, with one row per combination.  The result C has K columns and 'nchoosek (length (SET), K)' rows.

     For example:

     How many ways can three items be grouped into pairs?

          nchoosek (3, 2)
             => 3

     What are the possible pairs?

          nchoosek (1:3, 2)
             =>  1   2
                 1   3
                 2   3

     Programming Note: When calculating the binomial coefficient 'nchoosek' works only for non-negative, integer arguments.  Use 'bincoeff' for non-integer and negative scalar arguments, or for computing many binomial coefficients at once with vector inputs for N or K.

     See also: bincoeff, perms.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Compute the binomial coefficient of N or list all possible combinations of a SET of items.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nthroot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 397
 -- Function File: nthroot (X, N)

     Compute the real (non-complex) N-th root of X.

     X must have all real entries and N must be a scalar.  If N is an even integer and X has negative entries then 'nthroot' aborts and issues an error.

     Example:

          nthroot (-1, 3)
          => -1
          (-1) ^ (1 / 3)
          => 0.50000 - 0.86603i

     See also: realsqrt, sqrt, cbrt.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Compute the real (non-complex) N-th root of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
perms


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 518
 -- Function File: perms (V)
     Generate all permutations of V with one row per permutation.

     The result has size 'factorial (N) * N', where N is the length of V.

     Example

          perms ([1, 2, 3])
          =>
            1   2   3
            2   1   3
            1   3   2
            2   3   1
            3   1   2
            3   2   1

     Programming Note: The maximum length of V should be less than or equal to 10 to limit memory consumption.

     See also: permute, randperm, nchoosek.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
Generate all permutations of V with one row per permutation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
pow2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 223
 -- Function File: pow2 (X)
 -- Function File: pow2 (F, E)
     With one input argument, compute 2 .^ x for each element of X.

     With two input arguments, return f .* (2 .^ e).

     See also: log2, nextpow2, power.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
With one input argument, compute 2 .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
primes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 578
 -- Function File: primes (N)
     Return all primes up to N.

     The output data class (double, single, uint32, etc.)  is the same as the input class of N.  The algorithm used is the Sieve of Eratosthenes.

     Notes: If you need a specific number of primes you can use the fact that the distance from one prime to the next is, on average, proportional to the logarithm of the prime.  Integrating, one finds that there are about k primes less than k*log (5*k).

     See also 'list_primes' if you need a specific number N of primes.

     See also: list_primes, isprime.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Return all primes up to N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
reallog


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 235
 -- Function File: reallog (X)
     Return the real-valued natural logarithm of each element of X.

     If any element results in a complex return value 'reallog' aborts and issues an error.

     See also: log, realpow, realsqrt.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Return the real-valued natural logarithm of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
realpow


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 253
 -- Function File: realpow (X, Y)
     Compute the real-valued, element-by-element power operator.

     This is equivalent to 'X .^ Y', except that 'realpow' reports an error if any return value is complex.

     See also: power, reallog, realsqrt.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
Compute the real-valued, element-by-element power operator.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
realsqrt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 231
 -- Function File: realsqrt (X)
     Return the real-valued square root of each element of X.

     If any element results in a complex return value 'realsqrt' aborts and issues an error.

     See also: sqrt, realpow, reallog.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Return the real-valued square root of each element of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
gallery


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10741
 -- Function File: gallery (NAME)
 -- Function File: gallery (NAME, ARGS)
     Create interesting matrices for testing.

 -- Function File: C = gallery ("cauchy", X)
 -- Function File: C = gallery ("cauchy", X, Y)
     Create a Cauchy matrix.

 -- Function File: C = gallery ("chebspec", N)
 -- Function File: C = gallery ("chebspec", N, K)
     Create a Chebyshev spectral differentiation matrix.

 -- Function File: C = gallery ("chebvand", P)
 -- Function File: C = gallery ("chebvand", M, P)
     Create a Vandermonde-like matrix for the Chebyshev polynomials.

 -- Function File: A = gallery ("chow", N)
 -- Function File: A = gallery ("chow", N, ALPHA)
 -- Function File: A = gallery ("chow", N, ALPHA, DELTA)
     Create a Chow matrix - a singular Toeplitz lower Hessenberg matrix.

 -- Function File: C = gallery ("circul", V)
     Create a circulant matrix.

 -- Function File: A = gallery ("clement", N)
 -- Function File: A = gallery ("clement", N, K)
     Create a tridiagonal matrix with zero diagonal entries.

 -- Function File: C = gallery ("compar", A)
 -- Function File: C = gallery ("compar", A, K)
     Create a comparison matrix.

 -- Function File: A = gallery ("condex", N)
 -- Function File: A = gallery ("condex", N, K)
 -- Function File: A = gallery ("condex", N, K, THETA)
     Create a 'counterexample' matrix to a condition estimator.

 -- Function File: A = gallery ("cycol", [M N])
 -- Function File: A = gallery ("cycol", N)
 -- Function File: A = gallery (..., K)
     Create a matrix whose columns repeat cyclically.

 -- Function File: [C, D, E] = gallery ("dorr", N)
 -- Function File: [C, D, E] = gallery ("dorr", N, THETA)
 -- Function File: A = gallery ("dorr", ...)
     Create a diagonally dominant, ill-conditioned, tridiagonal matrix.

 -- Function File: A = gallery ("dramadah", N)
 -- Function File: A = gallery ("dramadah", N, K)
     Create a (0, 1) matrix whose inverse has large integer entries.

 -- Function File: A = gallery ("fiedler", C)
     Create a symmetric Fiedler matrix.

 -- Function File: A = gallery ("forsythe", N)
 -- Function File: A = gallery ("forsythe", N, ALPHA)
 -- Function File: A = gallery ("forsythe", N, ALPHA, LAMBDA)
     Create a Forsythe matrix (a perturbed Jordan block).

 -- Function File: F = gallery ("frank", N)
 -- Function File: F = gallery ("frank", N, K)
     Create a Frank matrix (ill-conditioned eigenvalues).

 -- Function File: C = gallery ("gcdmat", N)
     Create a greatest common divisor matrix.

     C is an N-by-N matrix whose values correspond to the greatest common divisor of its coordinate values, i.e., C(i,j) correspond 'gcd (i, j)'.

 -- Function File: A = gallery ("gearmat", N)
 -- Function File: A = gallery ("gearmat", N, I)
 -- Function File: A = gallery ("gearmat", N, I, J)
     Create a Gear matrix.

 -- Function File: G = gallery ("grcar", N)
 -- Function File: G = gallery ("grcar", N, K)
     Create a Toeplitz matrix with sensitive eigenvalues.

 -- Function File: A = gallery ("hanowa", N)
 -- Function File: A = gallery ("hanowa", N, D)
     Create a matrix whose eigenvalues lie on a vertical line in the complex plane.

 -- Function File: V = gallery ("house", X)
 -- Function File: [V, BETA] = gallery ("house", X)
     Create a householder matrix.

 -- Function File: A = gallery ("integerdata", IMAX, [M N ...], J)
 -- Function File: A = gallery ("integerdata", IMAX, M, N, ..., J)
 -- Function File: A = gallery ("integerdata", [IMIN, IMAX], [M N ...], J)
 -- Function File: A = gallery ("integerdata", [IMIN, IMAX], M, N, ..., J)
 -- Function File: A = gallery ("integerdata", ..., "CLASS")
     Create a matrix with random integers in the range [1, IMAX].  If IMIN is given then the integers are in the range [IMIN, IMAX].

     The second input is a matrix of dimensions describing the size of the output.  The dimensions can also be input as comma-separated arguments.

     The input J is an integer index in the range [0, 2^32-1].  The values of the output matrix are always exactly the same (reproducibility) for a given size input and J index.

     The final optional argument determines the class of the resulting matrix.  Possible values for CLASS: "uint8", "uint16", "uint32", "int8", "int16", int32", "single", "double".  The default is "double".

 -- Function File: A = gallery ("invhess", X)
 -- Function File: A = gallery ("invhess", X, Y)
     Create the inverse of an upper Hessenberg matrix.

 -- Function File: A = gallery ("invol", N)
     Create an involutory matrix.

 -- Function File: A = gallery ("ipjfact", N)
 -- Function File: A = gallery ("ipjfact", N, K)
     Create a Hankel matrix with factorial elements.

 -- Function File: A = gallery ("jordbloc", N)
 -- Function File: A = gallery ("jordbloc", N, LAMBDA)
     Create a Jordan block.

 -- Function File: U = gallery ("kahan", N)
 -- Function File: U = gallery ("kahan", N, THETA)
 -- Function File: U = gallery ("kahan", N, THETA, PERT)
     Create a Kahan matrix (upper trapezoidal).

 -- Function File: A = gallery ("kms", N)
 -- Function File: A = gallery ("kms", N, RHO)
     Create a Kac-Murdock-Szego Toeplitz matrix.

 -- Function File: B = gallery ("krylov", A)
 -- Function File: B = gallery ("krylov", A, X)
 -- Function File: B = gallery ("krylov", A, X, J)
     Create a Krylov matrix.

 -- Function File: A = gallery ("lauchli", N)
 -- Function File: A = gallery ("lauchli", N, MU)
     Create a Lauchli matrix (rectangular).

 -- Function File: A = gallery ("lehmer", N)
     Create a Lehmer matrix (symmetric positive definite).

 -- Function File: T = gallery ("lesp", N)
     Create a tridiagonal matrix with real, sensitive eigenvalues.

 -- Function File: A = gallery ("lotkin", N)
     Create a Lotkin matrix.

 -- Function File: A = gallery ("minij", N)
     Create a symmetric positive definite matrix MIN(i,j).

 -- Function File: A = gallery ("moler", N)
 -- Function File: A = gallery ("moler", N, ALPHA)
     Create a Moler matrix (symmetric positive definite).

 -- Function File: [A, T] = gallery ("neumann", N)
     Create a singular matrix from the discrete Neumann problem (sparse).

 -- Function File: A = gallery ("normaldata", [M N ...], J)
 -- Function File: A = gallery ("normaldata", M, N, ..., J)
 -- Function File: A = gallery ("normaldata", ..., "CLASS")
     Create a matrix with random samples from the standard normal distribution (mean = 0, std = 1).

     The first input is a matrix of dimensions describing the size of the output.  The dimensions can also be input as comma-separated arguments.

     The input J is an integer index in the range [0, 2^32-1].  The values of the output matrix are always exactly the same (reproducibility) for a given size input and J index.

     The final optional argument determines the class of the resulting matrix.  Possible values for CLASS: "single", "double".  The default is "double".

 -- Function File: Q = gallery ("orthog", N)
 -- Function File: Q = gallery ("orthog", N, K)
     Create orthogonal and nearly orthogonal matrices.

 -- Function File: A = gallery ("parter", N)
     Create a Parter matrix (a Toeplitz matrix with singular values near pi).

 -- Function File: P = gallery ("pei", N)
 -- Function File: P = gallery ("pei", N, ALPHA)
     Create a Pei matrix.

 -- Function File: A = gallery ("Poisson", N)
     Create a block tridiagonal matrix from Poisson's equation (sparse).

 -- Function File: A = gallery ("prolate", N)
 -- Function File: A = gallery ("prolate", N, W)
     Create a prolate matrix (symmetric, ill-conditioned Toeplitz matrix).

 -- Function File: H = gallery ("randhess", X)
     Create a random, orthogonal upper Hessenberg matrix.

 -- Function File: A = gallery ("rando", N)
 -- Function File: A = gallery ("rando", N, K)
     Create a random matrix with elements -1, 0 or 1.

 -- Function File: A = gallery ("randsvd", N)
 -- Function File: A = gallery ("randsvd", N, KAPPA)
 -- Function File: A = gallery ("randsvd", N, KAPPA, MODE)
 -- Function File: A = gallery ("randsvd", N, KAPPA, MODE, KL)
 -- Function File: A = gallery ("randsvd", N, KAPPA, MODE, KL, KU)
     Create a random matrix with pre-assigned singular values.

 -- Function File: A = gallery ("redheff", N)
     Create a zero and ones matrix of Redheffer associated with the Riemann hypothesis.

 -- Function File: A = gallery ("riemann", N)
     Create a matrix associated with the Riemann hypothesis.

 -- Function File: A = gallery ("ris", N)
     Create a symmetric Hankel matrix.

 -- Function File: A = gallery ("smoke", N)
 -- Function File: A = gallery ("smoke", N, K)
     Create a complex matrix, with a 'smoke ring' pseudospectrum.

 -- Function File: T = gallery ("toeppd", N)
 -- Function File: T = gallery ("toeppd", N, M)
 -- Function File: T = gallery ("toeppd", N, M, W)
 -- Function File: T = gallery ("toeppd", N, M, W, THETA)
     Create a symmetric positive definite Toeplitz matrix.

 -- Function File: P = gallery ("toeppen", N)
 -- Function File: P = gallery ("toeppen", N, A)
 -- Function File: P = gallery ("toeppen", N, A, B)
 -- Function File: P = gallery ("toeppen", N, A, B, C)
 -- Function File: P = gallery ("toeppen", N, A, B, C, D)
 -- Function File: P = gallery ("toeppen", N, A, B, C, D, E)
     Create a pentadiagonal Toeplitz matrix (sparse).

 -- Function File: A = gallery ("tridiag", X, Y, Z)
 -- Function File: A = gallery ("tridiag", N)
 -- Function File: A = gallery ("tridiag", N, C, D, E)
     Create a tridiagonal matrix (sparse).

 -- Function File: T = gallery ("triw", N)
 -- Function File: T = gallery ("triw", N, ALPHA)
 -- Function File: T = gallery ("triw", N, ALPHA, K)
     Create an upper triangular matrix discussed by Kahan, Golub, and Wilkinson.

 -- Function File: A = gallery ("uniformdata", [M N ...], J)
 -- Function File: A = gallery ("uniformdata", M, N, ..., J)
 -- Function File: A = gallery ("uniformdata", ..., "CLASS")
     Create a matrix with random samples from the standard uniform distribution (range [0,1]).

     The first input is a matrix of dimensions describing the size of the output.  The dimensions can also be input as comma-separated arguments.

     The input J is an integer index in the range [0, 2^32-1].  The values of the output matrix are always exactly the same (reproducibility) for a given size input and J index.

     The final optional argument determines the class of the resulting matrix.  Possible values for CLASS: "single", "double".  The default is "double".

 -- Function File: A = gallery ("wathen", NX, NY)
 -- Function File: A = gallery ("wathen", NX, NY, K)
     Create the Wathen matrix.

 -- Function File: [A, B] = gallery ("wilk", N)
     Create various specific matrices devised/discussed by Wilkinson.

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Create interesting matrices for testing.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
hadamard


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 660
 -- Function File: hadamard (N)
     Construct a Hadamard matrix (Hn) of size N-by-N.

     The size N must be of the form 2^k * p in which p is one of 1, 12, 20 or 28.  The returned matrix is normalized, meaning 'Hn(:,1) == 1' and 'Hn(1,:) == 1'.

     Some of the properties of Hadamard matrices are:

        * 'kron (Hm, Hn)' is a Hadamard matrix of size M-by-N.

        * 'Hn * Hn' = N * eye (N)'.

        * The rows of Hn are orthogonal.

        * 'det (A) <= abs (det (Hn))' for all A with 'abs (A(i, j)) <= 1'.

        * Multiplying any row or column by -1 and the matrix will remain a Hadamard matrix.

     See also: compan, hankel, toeplitz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Construct a Hadamard matrix (Hn) of size N-by-N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
hankel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 574
 -- Function File: hankel (C)
 -- Function File: hankel (C, R)
     Return the Hankel matrix constructed from the first column C, and (optionally) the last row R.

     If the last element of C is not the same as the first element of R, the last element of C is used.  If the second argument is omitted, it is assumed to be a vector of zeros with the same size as C.

     A Hankel matrix formed from an m-vector C, and an n-vector R, has the elements

          H(i,j) = c(i+j-1),  i+j-1 <= m;
          H(i,j) = r(i+j-m),  otherwise

     See also: hadamard, toeplitz.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Return the Hankel matrix constructed from the first column C, and (optionally) the last row R.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
hilb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 553
 -- Function File: hilb (N)
     Return the Hilbert matrix of order N.

     The i,j element of a Hilbert matrix is defined as

          H(i, j) = 1 / (i + j - 1)

     Hilbert matrices are close to being singular which make them difficult to invert with numerical routines.  Comparing the condition number of a random matrix 5x5 matrix with that of a Hilbert matrix of order 5 reveals just how difficult the problem is.

          cond (rand (5))
             => 14.392
          cond (hilb (5))
             => 4.7661e+05

     See also: invhilb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Return the Hilbert matrix of order N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
invhilb


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 977
 -- Function File: invhilb (N)
     Return the inverse of the Hilbert matrix of order N.

     This can be computed exactly using


                     (i+j)         /n+i-1\  /n+j-1\   /i+j-2\ 2
          A(i,j) = -1      (i+j-1)(       )(       ) (       )
                                   \ n-j /  \ n-i /   \ i-2 /

                 = p(i) p(j) / (i+j-1)


     where

                   k  /k+n-1\   /n\
          p(k) = -1  (       ) (   )
                      \ k-1 /   \k/

     The validity of this formula can easily be checked by expanding the binomial coefficients in both formulas as factorials.  It can be derived more directly via the theory of Cauchy matrices.  See J. W. Demmel, 'Applied Numerical Linear Algebra', p.  92.

     Compare this with the numerical calculation of 'inverse (hilb (n))', which suffers from the ill-conditioning of the Hilbert matrix, and the finite precision of your computer's floating point arithmetic.

     See also: hilb.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Return the inverse of the Hilbert matrix of order N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
magic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 288
 -- Function File: magic (N)

     Create an N-by-N magic square.

     A magic square is an arrangement of the integers '1:n^2' such that the row sums, column sums, and diagonal sums are all equal to the same value.

     Note: N must be greater than 2 for the magic square to exist.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Create an N-by-N magic square.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
pascal


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 651
 -- Function File: pascal (N)
 -- Function File: pascal (N, T)
     Return the Pascal matrix of order N if 'T = 0'.

     The default value of T is 0.

     When 'T = 1', return the pseudo-lower triangular Cholesky factor of the Pascal matrix (The sign of some columns may be negative).  This matrix is its own inverse, that is 'pascal (N, 1) ^ 2 == eye (N)'.

     If 'T = -1', return the true Cholesky factor with strictly positive values on the diagonal.

     If 'T = 2', return a transposed and permuted version of 'pascal (N, 1)', which is the cube root of the identity matrix.  That is, 'pascal (N, 2) ^ 3 == eye (N)'.

     See also: chol.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Return the Pascal matrix of order N if 'T = 0'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
rosser


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 171
 -- Function File: rosser ()
     Return the Rosser matrix.

     This is a difficult test case used to evaluate eigenvalue algorithms.

     See also: wilkinson, eig.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Return the Rosser matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
toeplitz


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 714
 -- Function File: toeplitz (C)
 -- Function File: toeplitz (C, R)
     Return the Toeplitz matrix constructed from the first column C, and (optionally) the first row R.

     If the first element of R is not the same as the first element of C, the first element of C is used.  If the second argument is omitted, the first row is taken to be the same as the first column.

     A square Toeplitz matrix has the form:

          c(0)  r(1)   r(2)  ...  r(n)
          c(1)  c(0)   r(1)  ... r(n-1)
          c(2)  c(1)   c(0)  ... r(n-2)
           .     .      .   .      .
           .     .      .     .    .
           .     .      .       .  .
          c(n) c(n-1) c(n-2) ...  c(0)

     See also: hankel.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Return the Toeplitz matrix constructed from the first column C, and (optionally) the first row R.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
vander


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 562
 -- Function File: vander (C)
 -- Function File: vander (C, N)
     Return the Vandermonde matrix whose next to last column is C.

     If N is specified, it determines the number of columns; otherwise, N is taken to be equal to the length of C.

     A Vandermonde matrix has the form:

          c(1)^(n-1) ... c(1)^2  c(1)  1
          c(2)^(n-1) ... c(2)^2  c(2)  1
              .     .      .      .    .
              .       .    .      .    .
              .         .  .      .    .
          c(n)^(n-1) ... c(n)^2  c(n)  1

     See also: polyfit.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
Return the Vandermonde matrix whose next to last column is C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
wilkinson


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 303
 -- Function File: wilkinson (N)
     Return the Wilkinson matrix of order N.

     Wilkinson matrices are symmetric and tridiagonal with pairs of nearly, but not exactly, equal eigenvalues.  They are useful in testing the behavior and performance of eigenvalue solvers.

     See also: rosser, eig.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Return the Wilkinson matrix of order N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
center


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 663
 -- Function File: center (X)
 -- Function File: center (X, DIM)
     Center data by subtracting its mean.

     If X is a vector, subtract its mean.

     If X is a matrix, do the above for each column.

     If the optional argument DIM is given, operate along this dimension.

     Programming Note: 'center' has obvious application for normalizing statistical data.  It is also useful for improving the precision of general numerical calculations.  Whenever there is a large value that is common to a batch of data, the mean can be subtracted off, the calculation performed, and then the mean added back to obtain the final answer.

     See also: zscore.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Center data by subtracting its mean.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
cloglog


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 186
 -- Function File: cloglog (X)
     Return the complementary log-log function of X.

     The complementary log-log function is defined as

          cloglog (x) = - log (- log (X))

   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Return the complementary log-log function of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
corr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 486
 -- Function File: corr (X)
 -- Function File: corr (X, Y)
     Compute matrix of correlation coefficients.

     If each row of X and Y is an observation and each column is a variable, then the (I, J)-th entry of 'corr (X, Y)' is the correlation between the I-th variable in X and the J-th variable in Y.

          corr (x,y) = cov (x,y) / (std (x) * std (y))

     If called with one argument, compute 'corr (X, X)', the correlation between the columns of X.

     See also: cov.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Compute matrix of correlation coefficients.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
cov


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1164
 -- Function File: cov (X)
 -- Function File: cov (X, OPT)
 -- Function File: cov (X, Y)
 -- Function File: cov (X, Y, OPT)
     Compute the covariance matrix.

     If each row of X and Y is an observation, and each column is a variable, then the (I, J)-th entry of 'cov (X, Y)' is the covariance between the I-th variable in X and the J-th variable in Y.

          cov (x) = 1/N-1 * SUM_i (x(i) - mean(x)) * (y(i) - mean(y))

     If called with one argument, compute 'cov (X, X)', the covariance between the columns of X.

     The argument OPT determines the type of normalization to use.  Valid values are

     0:
          normalize with N-1, provides the best unbiased estimator of the covariance [default]

     1:
          normalize with N, this provides the second moment around the mean

     Compatibility Note:: Octave always computes the covariance matrix.  For two inputs, however, MATLAB will calculate 'cov (X(:), Y(:))' whenever the number of elements in X and Y are equal.  This will result in a scalar rather than a matrix output.  Code relying on this odd definition will need to be changed when running in Octave.

     See also: corr.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
Compute the covariance matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
gls


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 657
 -- Function File: [BETA, V, R] = gls (Y, X, O)
     Generalized least squares model.

     Perform a generalized least squares estimation for the multivariate model y = x*b + e with mean (e) = 0 and cov (vec (e)) = (s^2) o, where y is a t by p matrix, x is a t by k matrix, b is a k by p matrix, e is a t by p matrix, and o is a t*p by t*p matrix.

     Each row of Y and X is an observation and each column a variable.  The return values BETA, V, and R are defined as follows.

     BETA
          The GLS estimator for b.

     V
          The GLS estimator for s^2.

     R
          The matrix of GLS residuals, r = y - x*beta.

     See also: ols.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 32
Generalized least squares model.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
histc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 998
 -- Function File: N = histc (X, EDGES)
 -- Function File: N = histc (X, EDGES, DIM)
 -- Function File: [N, IDX] = histc (...)
     Compute histogram counts.

     When X is a vector, the function counts the number of elements of X that fall in the histogram bins defined by EDGES.  This must be a vector of monotonically increasing values that define the edges of the histogram bins.  'N(k)' contains the number of elements in X for which 'EDGES(k) <= X < EDGES(k+1)'.  The final element of N contains the number of elements of X exactly equal to the last element of EDGES.

     When X is an N-dimensional array, the computation is carried out along dimension DIM.  If not specified DIM defaults to the first non-singleton dimension.

     When a second output argument is requested an index matrix is also returned.  The IDX matrix has the same size as X.  Each element of IDX contains the index of the histogram bin in which the corresponding element of X was counted.

     See also: hist.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Compute histogram counts.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
iqr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 473
 -- Function File: iqr (X)
 -- Function File: iqr (X, DIM)
     Return the interquartile range, i.e., the difference between the upper and lower quartile of the input data.

     If X is a matrix, do the above for first non-singleton dimension of X.

     If the optional argument DIM is given, operate along this dimension.

     As a measure of dispersion, the interquartile range is less affected by outliers than either 'range' or 'std'.

     See also: range, std.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Return the interquartile range, i.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
kendall


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 720
 -- Function File: kendall (X)
 -- Function File: kendall (X, Y)
     Compute Kendall's TAU.

     For two data vectors X, Y of common length N, Kendall's TAU is the correlation of the signs of all rank differences of X and Y; i.e., if both X and Y have distinct entries, then

                   1
          tau = -------   SUM sign (q(i) - q(j)) * sign (r(i) - r(j))
                n (n-1)   i,j

     in which the Q(I) and R(I) are the ranks of X and Y, respectively.

     If X and Y are drawn from independent distributions, Kendall's TAU is asymptotically normal with mean 0 and variance '(2 * (2N+5)) / (9 * N * (N-1))'.

     'kendall (X)' is equivalent to 'kendall (X, X)'.

     See also: ranks, spearman.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
Compute Kendall's TAU.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
kurtosis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1191
 -- Function File: kurtosis (X)
 -- Function File: kurtosis (X, FLAG)
 -- Function File: kurtosis (X, FLAG, DIM)
     Compute the sample kurtosis of the elements of X.

     The sample kurtosis is defined as

               mean ((X - mean (X)).^4)
          k1 = ------------------------
                      std (X).^4

     The optional argument FLAG controls which normalization is used.  If FLAG is equal to 1 (default value, used when FLAG is omitted or empty), return the sample kurtosis as defined above.  If FLAG is equal to 0, return the "bias-corrected" kurtosis coefficient instead:

                        N - 1
          k0 = 3 + -------------- * ((N + 1) * k1 - 3 * (N - 1))
                   (N - 2)(N - 3)

     The bias-corrected kurtosis coefficient is obtained by replacing the sample second and fourth central moments by their unbiased versions.  It is an unbiased estimate of the population kurtosis for normal populations.

     If X is a matrix, or more generally a multi-dimensional array, return the kurtosis along the first non-singleton dimension.  If the optional DIM argument is given, operate along this dimension.

     See also: var, skewness, moment.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Compute the sample kurtosis of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
logit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 182
 -- Function File: logit (P)
     Compute the logit for each value of P

     The logit is defined as

          logit (P) = log (P / (1-P))

     See also: probit, logistic_cdf.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Compute the logit for each value of P 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
lscov


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1272
 -- Function File: X = lscov (A, B)
 -- Function File: X = lscov (A, B, V)
 -- Function File: X = lscov (A, B, V, ALG)
 -- Function File: [X, STDX, MSE, S] = lscov (...)

     Compute a generalized linear least squares fit.

     Estimate X under the model B = AX + W, where the noise W is assumed to follow a normal distribution with covariance matrix {\sigma^2} V.

     If the size of the coefficient matrix A is n-by-p, the size of the vector/array of constant terms B must be n-by-k.

     The optional input argument V may be a n-by-1 vector of positive weights (inverse variances), or a n-by-n symmetric positive semidefinite matrix representing the covariance of B.  If V is not supplied, the ordinary least squares solution is returned.

     The ALG input argument, a guidance on solution method to use, is currently ignored.

     Besides the least-squares estimate matrix X (p-by-k), the function also returns STDX (p-by-k), the error standard deviation of estimated X; MSE (k-by-1), the estimated data error covariance scale factors (\sigma^2); and S (p-by-p, or p-by-p-by-k if k > 1), the error covariance of X.

     Reference: Golub and Van Loan (1996), 'Matrix Computations (3rd Ed.)', Johns Hopkins, Section 5.6.3

     See also: ols, gls, lsqnonneg.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Compute a generalized linear least squares fit.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
mahalanobis


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 260
 -- Function File: mahalanobis (X, Y)
     Return the Mahalanobis' D-square distance between the multivariate samples X and Y.

     The data X and Y must have the same number of components (columns), but may have a different number of observations (rows).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Return the Mahalanobis' D-square distance between the multivariate samples X and Y.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
mean


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 810
 -- Function File: mean (X)
 -- Function File: mean (X, DIM)
 -- Function File: mean (X, OPT)
 -- Function File: mean (X, DIM, OPT)
     Compute the mean of the elements of the vector X.

     The mean is defined as

          mean (x) = SUM_i x(i) / N

     If X is a matrix, compute the mean for each column and return them in a row vector.

     If the optional argument DIM is given, operate along this dimension.

     The optional argument OPT selects the type of mean to compute.  The following options are recognized:

     "a"
          Compute the (ordinary) arithmetic mean.  [default]

     "g"
          Compute the geometric mean.

     "h"
          Compute the harmonic mean.

     Both DIM and OPT are optional.  If both are supplied, either may appear first.

     See also: median, mode.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Compute the mean of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
meansq


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 407
 -- Function File: meansq (X)
 -- Function File: meansq (X, DIM)
     Compute the mean square of the elements of the vector X.

     The mean square is defined as

          meansq (x) = 1/N SUM_i x(i)^2

     For matrix arguments, return a row vector containing the mean square of each column.

     If the optional argument DIM is given, operate along this dimension.

     See also: var, std, moment.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
Compute the mean square of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
median


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 533
 -- Function File: median (X)
 -- Function File: median (X, DIM)
     Compute the median value of the elements of the vector X.

     When the elements of X are sorted, the median is defined as

                        x(ceil(N/2))             N odd
          median (x) =
                       (x(N/2) + x((N/2)+1))/2   N even

     If X is a matrix, compute the median value for each column and return them in a row vector.

     If the optional DIM argument is given, operate along this dimension.

     See also: mean, mode.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Compute the median value of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
mode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 662
 -- Function File: mode (X)
 -- Function File: mode (X, DIM)
 -- Function File: [M, F, C] = mode (...)
     Compute the most frequently occurring value in a dataset (mode).

     'mode' determines the frequency of values along the first non-singleton dimension and returns the value with the highest frequency.  If two, or more, values have the same frequency 'mode' returns the smallest.

     If the optional argument DIM is given, operate along this dimension.

     The return variable F is the number of occurrences of the mode in the dataset.

     The cell array C contains all of the elements with the maximum frequency.

     See also: mean, median.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Compute the most frequently occurring value in a dataset (mode).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
moment


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1120
 -- Function File: moment (X, P)
 -- Function File: moment (X, P, TYPE)
 -- Function File: moment (X, P, DIM)
 -- Function File: moment (X, P, TYPE, DIM)
 -- Function File: moment (X, P, DIM, TYPE)
     Compute the P-th central moment of the vector X.

          1/N SUM_i (x(i) - mean(x))^p

     If X is a matrix, return the row vector containing the P-th central moment of each column.

     If the optional argument DIM is given, operate along this dimension.

     The optional string TYPE specifies the type of moment to be computed.  Valid options are:

     "c"
          Central Moment (default).

     "a"
     "ac"
          Absolute Central Moment.  The moment about the mean ignoring sign defined as

               1/N SUM_i (abs (x(i) - mean(x)))^p

     "r"
          Raw Moment.  The moment about zero defined as

               moment (x) = 1/N SUM_i x(i)^p

     "ar"
          Absolute Raw Moment.  The moment about zero ignoring sign defined as

               1/N SUM_i ( abs (x(i)) )^p

     If both TYPE and DIM are given they may appear in any order.

     See also: var, skewness, kurtosis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Compute the P-th central moment of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
ols


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 905
 -- Function File: [BETA, SIGMA, R] = ols (Y, X)
     Ordinary least squares estimation.

     OLS applies to the multivariate model y = x*b + e with mean (e) = 0 and cov (vec (e)) = kron (s, I). where y is a t by p matrix, x is a t by k matrix, b is a k by p matrix, and e is a t by p matrix.

     Each row of Y and X is an observation and each column a variable.

     The return values BETA, SIGMA, and R are defined as follows.

     BETA
          The OLS estimator for b.  BETA is calculated directly via 'inv (x'*x) * x' * y' if the matrix 'x'*x' is of full rank.  Otherwise, 'BETA = pinv (X) * Y' where 'pinv (X)' denotes the pseudoinverse of X.

     SIGMA
          The OLS estimator for the matrix S,

               SIGMA = (Y-X*BETA)'
                 * (Y-X*BETA)
                 / (T-rank(X))

     R
          The matrix of OLS residuals, 'R = Y - X*BETA'.

     See also: gls, pinv.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Ordinary least squares estimation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
ppplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 837
 -- Function File: [P, Y] = ppplot (X, DIST, PARAMS)
     Perform a PP-plot (probability plot).

     If F is the CDF of the distribution DIST with parameters PARAMS and X a sample vector of length N, the PP-plot graphs ordinate Y(I) = F (I-th largest element of X) versus abscissa P(I) = (I - 0.5)/N.  If the sample comes from F, the pairs will approximately follow a straight line.

     The default for DIST is the standard normal distribution.

     The optional argument PARAMS contains a list of parameters of DIST.

     For example, for a probability plot of the uniform distribution on [2,4] and X, use

          ppplot (x, "uniform", 2, 4)

     DIST can be any string for which a function DIST_CDF that calculates the CDF of distribution DIST exists.

     If no output is requested then the data are plotted immediately.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
Perform a PP-plot (probability plot).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
prctile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 747
 -- Function File: Q = prctile (X)
 -- Function File: Q = prctile (X, P)
 -- Function File: Q = prctile (X, P, DIM)
     For a sample X, compute the quantiles, Q, corresponding to the cumulative probability values, P, in percent.

     If X is a matrix, compute the percentiles for each column and return them in a matrix, such that the i-th row of Y contains the P(i)th percentiles of each column of X.

     If P is unspecified, return the quantiles for '[0 25 50 75 100]'.

     The optional argument DIM determines the dimension along which the percentiles are calculated.  If DIM is omitted it defaults to the first non-singleton dimension.

     Programming Note: All non-numeric values (NaNs) of X are ignored.

     See also: quantile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
For a sample X, compute the quantiles, Q, corresponding to the cumulative probability values, P, in percent.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
probit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 153
 -- Function File: probit (P)
     Return the probit (the quantile of the standard normal distribution) for each element of P.

     See also: logit.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 91
Return the probit (the quantile of the standard normal distribution) for each element of P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
qqplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1150
 -- Function File: [Q, S] = qqplot (X)
 -- Function File: [Q, S] = qqplot (X, Y)
 -- Function File: [Q, S] = qqplot (X, DIST)
 -- Function File: [Q, S] = qqplot (X, Y, PARAMS)
 -- Function File: qqplot (...)
     Perform a QQ-plot (quantile plot).

     If F is the CDF of the distribution DIST with parameters PARAMS and G its inverse, and X a sample vector of length N, the QQ-plot graphs ordinate S(I) = I-th largest element of x versus abscissa Q(If) = G((I - 0.5)/N).

     If the sample comes from F, except for a transformation of location and scale, the pairs will approximately follow a straight line.

     If the second argument is a vector Y the empirical CDF of Y is used as DIST.

     The default for DIST is the standard normal distribution.  The optional argument PARAMS contains a list of parameters of DIST.  For example, for a quantile plot of the uniform distribution on [2,4] and X, use

          qqplot (x, "unif", 2, 4)

     DIST can be any string for which a function DISTINV or DIST_INV exists that calculates the inverse CDF of distribution DIST.

     If no output arguments are given, the data are plotted directly.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Perform a QQ-plot (quantile plot).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
quantile


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2809
 -- Function File: Q = quantile (X)
 -- Function File: Q = quantile (X, P)
 -- Function File: Q = quantile (X, P, DIM)
 -- Function File: Q = quantile (X, P, DIM, METHOD)
     For a sample, X, calculate the quantiles, Q, corresponding to the cumulative probability values in P.  All non-numeric values (NaNs) of X are ignored.

     If X is a matrix, compute the quantiles for each column and return them in a matrix, such that the i-th row of Q contains the P(i)th quantiles of each column of X.

     If P is unspecified, return the quantiles for '[0.00 0.25 0.50 0.75 1.00]'.  The optional argument DIM determines the dimension along which the quantiles are calculated.  If DIM is omitted it defaults to the first non-singleton dimension.

     The methods available to calculate sample quantiles are the nine methods used by R (<http://www.r-project.org/>).  The default value is METHOD = 5.

     Discontinuous sample quantile methods 1, 2, and 3

       1. Method 1: Inverse of empirical distribution function.

       2. Method 2: Similar to method 1 but with averaging at discontinuities.

       3. Method 3: SAS definition: nearest even order statistic.

     Continuous sample quantile methods 4 through 9, where p(k) is the linear interpolation function respecting each methods' representative cdf.

       4. Method 4: p(k) = k / n.  That is, linear interpolation of the empirical cdf.

       5. Method 5: p(k) = (k - 0.5) / n.  That is a piecewise linear function where the knots are the values midway through the steps of the empirical cdf.

       6. Method 6: p(k) = k / (n + 1).

       7. Method 7: p(k) = (k - 1) / (n - 1).

       8. Method 8: p(k) = (k - 1/3) / (n + 1/3).  The resulting quantile estimates are approximately median-unbiased regardless of the distribution of X.

       9. Method 9: p(k) = (k - 3/8) / (n + 1/4).  The resulting quantile estimates are approximately unbiased for the expected order statistics if X is normally distributed.

     Hyndman and Fan (1996) recommend method 8.  Maxima, S, and R (versions prior to 2.0.0) use 7 as their default.  Minitab and SPSS use method 6.  MATLAB uses method 5.

     References:

        * Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language.  Wadsworth & Brooks/Cole.

        * Hyndman, R. J. and Fan, Y. (1996) Sample quantiles in statistical packages, American Statistician, 50, 361-365.

        * R: A Language and Environment for Statistical Computing; <http://cran.r-project.org/doc/manuals/fullrefman.pdf>.

     Examples:

          x = randi (1000, [10, 1]);  # Create empirical data in range 1-1000
          q = quantile (x, [0, 1]);   # Return minimum, maximum of distribution
          q = quantile (x, [0.25 0.5 0.75]); # Return quartiles of distribution

     See also: prctile.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 101
For a sample, X, calculate the quantiles, Q, corresponding to the cumulative probability values in P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
range


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 550
 -- Function File: range (X)
 -- Function File: range (X, DIM)
     Return the range, i.e., the difference between the maximum and the minimum of the input data.

     If X is a vector, the range is calculated over the elements of X.  If X is a matrix, the range is calculated over each column of X.

     If the optional argument DIM is given, operate along this dimension.

     The range is a quickly computed measure of the dispersion of a data set, but is less accurate than 'iqr' if there are outlying data points.

     See also: iqr, std.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
Return the range, i.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
ranks


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 233
 -- Function File: ranks (X, DIM)
     Return the ranks of X along the first non-singleton dimension adjusted for ties.

     If the optional argument DIM is given, operate along this dimension.

     See also: spearman, kendall.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Return the ranks of X along the first non-singleton dimension adjusted for ties.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
run_count


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 315
 -- Function File: run_count (X, N)
 -- Function File: run_count (X, N, DIM)
     Count the upward runs along the first non-singleton dimension of X of length 1, 2, ..., N-1 and greater than or equal to N.

     If the optional argument DIM is given then operate along this dimension.

     See also: runlength.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 84
Count the upward runs along the first non-singleton dimension of X of length 1, 2, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
runlength


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 416
 -- Function File: count = runlength (X)
 -- Function File: [count, value] = runlength (X)
     Find the lengths of all sequences of common values.

     COUNT is a vector with the lengths of each repeated value.

     The optional output VALUE contains the value that was repeated in the sequence.

          runlength ([2, 2, 0, 4, 4, 4, 0, 1, 1, 1, 1])
          =>  [2, 1, 3, 1, 4]

     See also: run_count.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Find the lengths of all sequences of common values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
skewness


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1209
 -- Function File: skewness (X)
 -- Function File: skewness (X, FLAG)
 -- Function File: skewness (X, FLAG, DIM)
     Compute the sample skewness of the elements of X.

     The sample skewness is defined as

                         mean ((X - mean (X)).^3)
          skewness (X) = ------------------------.
                                std (X).^3

     The optional argument FLAG controls which normalization is used.  If FLAG is equal to 1 (default value, used when FLAG is omitted or empty), return the sample skewness as defined above.  If FLAG is equal to 0, return the adjusted skewness coefficient instead:

                            sqrt (N*(N-1))   mean ((X - mean (X)).^3)
          skewness (X, 0) = -------------- * ------------------------.
                                (N - 2)             std (X).^3

     The adjusted skewness coefficient is obtained by replacing the sample second and third central moments by their bias-corrected versions.

     If X is a matrix, or more generally a multi-dimensional array, return the skewness along the first non-singleton dimension.  If the optional DIM argument is given, operate along this dimension.

     See also: var, kurtosis, moment.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Compute the sample skewness of the elements of X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
spearman


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 473
 -- Function File: spearman (X)
 -- Function File: spearman (X, Y)
     Compute Spearman's rank correlation coefficient RHO.

     For two data vectors X and Y, Spearman's RHO is the correlation coefficient of the ranks of X and Y.

     If X and Y are drawn from independent distributions, RHO has zero mean and variance '1 / (n - 1)', and is asymptotically normally distributed.

     'spearman (X)' is equivalent to 'spearman (X, X)'.

     See also: ranks, kendall.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
Compute Spearman's rank correlation coefficient RHO.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
statistics


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 471
 -- Function File: statistics (X)
 -- Function File: statistics (X, DIM)
     Return a vector with the minimum, first quartile, median, third quartile, maximum, mean, standard deviation, skewness, and kurtosis of the elements of the vector X.

     If X is a matrix, calculate statistics over the first non-singleton dimension.

     If the optional argument DIM is given, operate along this dimension.

     See also: min, max, median, mean, std, skewness, kurtosis.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 164
Return a vector with the minimum, first quartile, median, third quartile, maximum, mean, standard deviation, skewness, and kurtosis of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
std


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 852
 -- Function File: std (X)
 -- Function File: std (X, OPT)
 -- Function File: std (X, OPT, DIM)
     Compute the standard deviation of the elements of the vector X.

     The standard deviation is defined as

          std (x) = sqrt ( 1/(N-1) SUM_i (x(i) - mean(x))^2 )

     where N is the number of elements.

     If X is a matrix, compute the standard deviation for each column and return them in a row vector.

     The argument OPT determines the type of normalization to use.  Valid values are

     0:
          normalize with N-1, provides the square root of the best unbiased estimator of the variance [default]

     1:
          normalize with N, this provides the square root of the second moment around the mean

     If the optional argument DIM is given, operate along this dimension.

     See also: var, range, iqr, mean, median.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
Compute the standard deviation of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
table


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 269
 -- Function File: [T, L_X] = table (X)
 -- Function File: [T, L_X, L_Y] = table (X, Y)
     Create a contingency table T from data vectors.

     The L_X and L_Y vectors are the corresponding levels.

     Currently, only 1- and 2-dimensional tables are supported.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Create a contingency table T from data vectors.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
var


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 816
 -- Function File: var (X)
 -- Function File: var (X, OPT)
 -- Function File: var (X, OPT, DIM)
     Compute the variance of the elements of the vector X.

     The variance is defined as

          var (x) = 1/(N-1) SUM_i (x(i) - mean(x))^2

     If X is a matrix, compute the variance for each column and return them in a row vector.

     The argument OPT determines the type of normalization to use.  Valid values are

     0:
          normalize with N-1, provides the best unbiased estimator of the variance [default]

     1:
          normalizes with N, this provides the second moment around the mean

     If N==1 the value of OPT is ignored and normalization by N is used.

     If the optional argument DIM is given, operate along this dimension.

     See also: cov, std, skewness, kurtosis, moment.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Compute the variance of the elements of the vector X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
zscore


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 780
 -- Function File: Z = zscore (X)
 -- Function File: Z = zscore (X, OPT)
 -- Function File: Z = zscore (X, OPT, DIM)
 -- Function File: [Z, MU, SIGMA] = zscore (...)
     Compute the Z score of X

     If X is a vector, subtract its mean and divide by its standard deviation.  If the standard deviation is zero, divide by 1 instead.

     The optional parameter OPT determines the normalization to use when computing the standard deviation and has the same definition as the corresponding parameter for 'std'.

     If X is a matrix, calculate along the first non-singleton dimension.  If the third optional argument DIM is given, operate along this dimension.

     The optional outputs MU and SIGMA contain the mean and standard deviation.

     See also: mean, std, center.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Compute the Z score of X 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betacdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 174
 -- Function File: betacdf (X, A, B)
     For each element of X, compute the cumulative distribution function (CDF) at X of the Beta distribution with parameters A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
For each element of X, compute the cumulative distribution function (CDF) at X of the Beta distribution with parameters A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betainv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 169
 -- Function File: betainv (X, A, B)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the Beta distribution with parameters A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
For each element of X, compute the quantile (the inverse of the CDF) at X of the Beta distribution with parameters A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betapdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 170
 -- Function File: betapdf (X, A, B)
     For each element of X, compute the probability density function (PDF) at X of the Beta distribution with parameters A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 124
For each element of X, compute the probability density function (PDF) at X of the Beta distribution with parameters A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
betarnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 685
 -- Function File: betarnd (A, B)
 -- Function File: betarnd (A, B, R)
 -- Function File: betarnd (A, B, R, C, ...)
 -- Function File: betarnd (A, B, [SZ])
     Return a matrix of random samples from the Beta distribution with parameters A and B.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Return a matrix of random samples from the Beta distribution with parameters A and B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binocdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 247
 -- Function File: binocdf (X, N, P)
     For each element of X, compute the cumulative distribution function (CDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 201
For each element of X, compute the cumulative distribution function (CDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binoinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 -- Function File: binoinv (X, N, P)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 196
For each element of X, compute the quantile (the inverse of the CDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binopdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 243
 -- Function File: binopdf (X, N, P)
     For each element of X, compute the probability density function (PDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 197
For each element of X, compute the probability density function (PDF) at X of the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
binornd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 758
 -- Function File: binornd (N, P)
 -- Function File: binornd (N, P, R)
 -- Function File: binornd (N, P, R, C, ...)
 -- Function File: binornd (N, P, [SZ])
     Return a matrix of random samples from the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of N and P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 158
Return a matrix of random samples from the binomial distribution with parameters N and P, where N is the number of trials and P is the probability of success.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
cauchy_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 309
 -- Function File: cauchy_cdf (X)
 -- Function File: cauchy_cdf (X, LOCATION, SCALE)
     For each element of X, compute the cumulative distribution function (CDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE.

     Default values are LOCATION = 0, SCALE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
For each element of X, compute the cumulative distribution function (CDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
cauchy_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 304
 -- Function File: cauchy_inv (X)
 -- Function File: cauchy_inv (X, LOCATION, SCALE)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE.

     Default values are LOCATION = 0, SCALE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 160
For each element of X, compute the quantile (the inverse of the CDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
cauchy_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 309
 -- Function File: cauchy_pdf (X)
 -- Function File: cauchy_pdf (X, LOCATION, SCALE)
     For each element of X, compute the probability density function (PDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE > 0.

     Default values are LOCATION = 0, SCALE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 165
For each element of X, compute the probability density function (PDF) at X of the Cauchy distribution with location parameter LOCATION and scale parameter SCALE > 0.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
cauchy_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 765
 -- Function File: cauchy_rnd (LOCATION, SCALE)
 -- Function File: cauchy_rnd (LOCATION, SCALE, R)
 -- Function File: cauchy_rnd (LOCATION, SCALE, R, C, ...)
 -- Function File: cauchy_rnd (LOCATION, SCALE, [SZ])
     Return a matrix of random samples from the Cauchy distribution with parameters LOCATION and SCALE.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of LOCATION and SCALE.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 98
Return a matrix of random samples from the Cauchy distribution with parameters LOCATION and SCALE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 179
 -- Function File: chi2cdf (X, N)
     For each element of X, compute the cumulative distribution function (CDF) at X of the chi-square distribution with N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 136
For each element of X, compute the cumulative distribution function (CDF) at X of the chi-square distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 174
 -- Function File: chi2inv (X, N)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the chi-square distribution with N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 131
For each element of X, compute the quantile (the inverse of the CDF) at X of the chi-square distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 175
 -- Function File: chi2pdf (X, N)
     For each element of X, compute the probability density function (PDF) at X of the chi-square distribution with N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
For each element of X, compute the probability density function (PDF) at X of the chi-square distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
chi2rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 668
 -- Function File: chi2rnd (N)
 -- Function File: chi2rnd (N, R)
 -- Function File: chi2rnd (N, R, C, ...)
 -- Function File: chi2rnd (N, [SZ])
     Return a matrix of random samples from the chi-square distribution with N degrees of freedom.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of N.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 93
Return a matrix of random samples from the chi-square distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
discrete_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 219
 -- Function File: discrete_cdf (X, V, P)
     For each element of X, compute the cumulative distribution function (CDF) at X of a univariate discrete distribution which assumes the values in V with probabilities P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 168
For each element of X, compute the cumulative distribution function (CDF) at X of a univariate discrete distribution which assumes the values in V with probabilities P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
discrete_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 207
 -- Function File: discrete_inv (X, V, P)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the univariate distribution which assumes the values in V with probabilities P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 156
For each element of X, compute the quantile (the inverse of the CDF) at X of the univariate distribution which assumes the values in V with probabilities P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
discrete_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 215
 -- Function File: discrete_pdf (X, V, P)
     For each element of X, compute the probability density function (PDF) at X of a univariate discrete distribution which assumes the values in V with probabilities P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 164
For each element of X, compute the probability density function (PDF) at X of a univariate discrete distribution which assumes the values in V with probabilities P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
discrete_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 738
 -- Function File: discrete_rnd (V, P)
 -- Function File: discrete_rnd (V, P, R)
 -- Function File: discrete_rnd (V, P, R, C, ...)
 -- Function File: discrete_rnd (V, P, [SZ])
     Return a matrix of random samples from the univariate distribution which assumes the values in V with probabilities P.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of V and P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 118
Return a matrix of random samples from the univariate distribution which assumes the values in V with probabilities P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
empirical_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 202
 -- Function File: empirical_cdf (X, DATA)
     For each element of X, compute the cumulative distribution function (CDF) at X of the empirical distribution obtained from the univariate sample DATA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
For each element of X, compute the cumulative distribution function (CDF) at X of the empirical distribution obtained from the univariate sample DATA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
empirical_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 197
 -- Function File: empirical_inv (X, DATA)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the empirical distribution obtained from the univariate sample DATA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
For each element of X, compute the quantile (the inverse of the CDF) at X of the empirical distribution obtained from the univariate sample DATA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
empirical_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 198
 -- Function File: empirical_pdf (X, DATA)
     For each element of X, compute the probability density function (PDF) at X of the empirical distribution obtained from the univariate sample DATA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
For each element of X, compute the probability density function (PDF) at X of the empirical distribution obtained from the univariate sample DATA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
empirical_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 741
 -- Function File: empirical_rnd (DATA)
 -- Function File: empirical_rnd (DATA, R)
 -- Function File: empirical_rnd (DATA, R, C, ...)
 -- Function File: empirical_rnd (DATA, [SZ])
     Return a matrix of random samples from the empirical distribution obtained from the univariate sample DATA.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is a random ordering of the sample DATA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 107
Return a matrix of random samples from the empirical distribution obtained from the univariate sample DATA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
expcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 229
 -- Function File: expcdf (X, LAMBDA)
     For each element of X, compute the cumulative distribution function (CDF) at X of the exponential distribution with mean LAMBDA.

     The arguments can be of common size or scalars.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
For each element of X, compute the cumulative distribution function (CDF) at X of the exponential distribution with mean LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
expinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 170
 -- Function File: expinv (X, LAMBDA)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the exponential distribution with mean LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 123
For each element of X, compute the quantile (the inverse of the CDF) at X of the exponential distribution with mean LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
exppdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 171
 -- Function File: exppdf (X, LAMBDA)
     For each element of X, compute the probability density function (PDF) at X of the exponential distribution with mean LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 124
For each element of X, compute the probability density function (PDF) at X of the exponential distribution with mean LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
exprnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 681
 -- Function File: exprnd (LAMBDA)
 -- Function File: exprnd (LAMBDA, R)
 -- Function File: exprnd (LAMBDA, R, C, ...)
 -- Function File: exprnd (LAMBDA, [SZ])
     Return a matrix of random samples from the exponential distribution with mean LAMBDA.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
Return a matrix of random samples from the exponential distribution with mean LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 176
 -- Function File: fcdf (X, M, N)
     For each element of X, compute the cumulative distribution function (CDF) at X of the F distribution with M and N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
For each element of X, compute the cumulative distribution function (CDF) at X of the F distribution with M and N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
finv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 171
 -- Function File: finv (X, M, N)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the F distribution with M and N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 128
For each element of X, compute the quantile (the inverse of the CDF) at X of the F distribution with M and N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
fpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 172
 -- Function File: fpdf (X, M, N)
     For each element of X, compute the probability density function (PDF) at X of the F distribution with M and N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
For each element of X, compute the probability density function (PDF) at X of the F distribution with M and N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
frnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 678
 -- Function File: frnd (M, N)
 -- Function File: frnd (M, N, R)
 -- Function File: frnd (M, N, R, C, ...)
 -- Function File: frnd (M, N, [SZ])
     Return a matrix of random samples from the F distribution with M and N degrees of freedom.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of M and N.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Return a matrix of random samples from the F distribution with M and N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gamcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 185
 -- Function File: gamcdf (X, A, B)
     For each element of X, compute the cumulative distribution function (CDF) at X of the Gamma distribution with shape parameter A and scale B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 140
For each element of X, compute the cumulative distribution function (CDF) at X of the Gamma distribution with shape parameter A and scale B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gaminv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- Function File: gaminv (X, A, B)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the Gamma distribution with shape parameter A and scale B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 135
For each element of X, compute the quantile (the inverse of the CDF) at X of the Gamma distribution with shape parameter A and scale B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gampdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 180
 -- Function File: gampdf (X, A, B)
     For each element of X, return the probability density function (PDF) at X of the Gamma distribution with shape parameter A and scale B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 135
For each element of X, return the probability density function (PDF) at X of the Gamma distribution with shape parameter A and scale B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
gamrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 693
 -- Function File: gamrnd (A, B)
 -- Function File: gamrnd (A, B, R)
 -- Function File: gamrnd (A, B, R, C, ...)
 -- Function File: gamrnd (A, B, [SZ])
     Return a matrix of random samples from the Gamma distribution with shape parameter A and scale B.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 97
Return a matrix of random samples from the Gamma distribution with shape parameter A and scale B.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geocdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 307
 -- Function File: geocdf (X, P)
     For each element of X, compute the cumulative distribution function (CDF) at X of the geometric distribution with parameter P.

     The geometric distribution models the number of failures (X-1) of a Bernoulli trial with probability P before the first success (X).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
For each element of X, compute the cumulative distribution function (CDF) at X of the geometric distribution with parameter P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geoinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 302
 -- Function File: geoinv (X, P)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the geometric distribution with parameter P.

     The geometric distribution models the number of failures (X-1) of a Bernoulli trial with probability P before the first success (X).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 121
For each element of X, compute the quantile (the inverse of the CDF) at X of the geometric distribution with parameter P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geopdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 303
 -- Function File: geopdf (X, P)
     For each element of X, compute the probability density function (PDF) at X of the geometric distribution with parameter P.

     The geometric distribution models the number of failures (X-1) of a Bernoulli trial with probability P before the first success (X).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 122
For each element of X, compute the probability density function (PDF) at X of the geometric distribution with parameter P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
geornd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 793
 -- Function File: geornd (P)
 -- Function File: geornd (P, R)
 -- Function File: geornd (P, R, C, ...)
 -- Function File: geornd (P, [SZ])
     Return a matrix of random samples from the geometric distribution with parameter P.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of P.

     The geometric distribution models the number of failures (X-1) of a Bernoulli trial with probability P before the first success (X).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 83
Return a matrix of random samples from the geometric distribution with parameter P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygecdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 454
 -- Function File: hygecdf (X, T, M, N)
     Compute the cumulative distribution function (CDF) at X of the hypergeometric distribution with parameters T, M, and N.

     This is the probability of obtaining not more than X marked items when randomly drawing a sample of size N without replacement from a population of total size T containing M marked items.

     The parameters T, M, and N must be positive integers with M and N not greater than T.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 119
Compute the cumulative distribution function (CDF) at X of the hypergeometric distribution with parameters T, M, and N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygeinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 458
 -- Function File: hygeinv (X, T, M, N)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the hypergeometric distribution with parameters T, M, and N.

     This is the probability of obtaining X marked items when randomly drawing a sample of size N without replacement from a population of total size T containing M marked items.

     The parameters T, M, and N must be positive integers with M and N not greater than T.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
For each element of X, compute the quantile (the inverse of the CDF) at X of the hypergeometric distribution with parameters T, M, and N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygepdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 436
 -- Function File: hygepdf (X, T, M, N)
     Compute the probability density function (PDF) at X of the hypergeometric distribution with parameters T, M, and N.

     This is the probability of obtaining X marked items when randomly drawing a sample of size N without replacement from a population of total size T containing M marked items.

     The parameters T, M, and N must be positive integers with M and N not greater than T.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 115
Compute the probability density function (PDF) at X of the hypergeometric distribution with parameters T, M, and N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hygernd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 807
 -- Function File: hygernd (T, M, N)
 -- Function File: hygernd (T, M, N, R)
 -- Function File: hygernd (T, M, N, R, C, ...)
 -- Function File: hygernd (T, M, N, [SZ])
     Return a matrix of random samples from the hypergeometric distribution with parameters T, M, and N.

     The parameters T, M, and N must be positive integers with M and N not greater than T.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of T, M, and N.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 99
Return a matrix of random samples from the hypergeometric distribution with parameters T, M, and N.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
kolmogorov_smirnov_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 425
 -- Function File: kolmogorov_smirnov_cdf (X, TOL)
     Return the cumulative distribution function (CDF) at X of the Kolmogorov-Smirnov distribution.

     This is defined as

                   Inf
          Q(x) =   SUM    (-1)^k exp (-2 k^2 x^2)
                 k = -Inf

     for X > 0.

     The optional parameter TOL specifies the precision up to which the series should be evaluated; the default is TOL = 'eps'.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Return the cumulative distribution function (CDF) at X of the Kolmogorov-Smirnov distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
laplace_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 151
 -- Function File: laplace_cdf (X)
     For each element of X, compute the cumulative distribution function (CDF) at X of the Laplace distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 107
For each element of X, compute the cumulative distribution function (CDF) at X of the Laplace distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
laplace_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
 -- Function File: laplace_inv (X)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the Laplace distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 102
For each element of X, compute the quantile (the inverse of the CDF) at X of the Laplace distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
laplace_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 147
 -- Function File: laplace_pdf (X)
     For each element of X, compute the probability density function (PDF) at X of the Laplace distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
For each element of X, compute the probability density function (PDF) at X of the Laplace distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
laplace_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 533
 -- Function File: laplace_rnd (R)
 -- Function File: laplace_rnd (R, C, ...)
 -- Function File: laplace_rnd ([SZ])
     Return a matrix of random samples from the Laplace distribution.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
Return a matrix of random samples from the Laplace distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
logistic_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 153
 -- Function File: logistic_cdf (X)
     For each element of X, compute the cumulative distribution function (CDF) at X of the logistic distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 108
For each element of X, compute the cumulative distribution function (CDF) at X of the logistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
logistic_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
 -- Function File: logistic_inv (X)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the logistic distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 103
For each element of X, compute the quantile (the inverse of the CDF) at X of the logistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
logistic_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 118
 -- Function File: logistic_pdf (X)
     For each element of X, compute the PDF at X of the logistic distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
For each element of X, compute the PDF at X of the logistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
logistic_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 537
 -- Function File: logistic_rnd (R)
 -- Function File: logistic_rnd (R, C, ...)
 -- Function File: logistic_rnd ([SZ])
     Return a matrix of random samples from the logistic distribution.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Return a matrix of random samples from the logistic distribution.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logncdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 399
 -- Function File: logncdf (X)
 -- Function File: logncdf (X, MU, SIGMA)
     For each element of X, compute the cumulative distribution function (CDF) at X of the lognormal distribution with parameters MU and SIGMA.

     If a random variable follows this distribution, its logarithm is normally distributed with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 138
For each element of X, compute the cumulative distribution function (CDF) at X of the lognormal distribution with parameters MU and SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
logninv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 394
 -- Function File: logninv (X)
 -- Function File: logninv (X, MU, SIGMA)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the lognormal distribution with parameters MU and SIGMA.

     If a random variable follows this distribution, its logarithm is normally distributed with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
For each element of X, compute the quantile (the inverse of the CDF) at X of the lognormal distribution with parameters MU and SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
lognpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 395
 -- Function File: lognpdf (X)
 -- Function File: lognpdf (X, MU, SIGMA)
     For each element of X, compute the probability density function (PDF) at X of the lognormal distribution with parameters MU and SIGMA.

     If a random variable follows this distribution, its logarithm is normally distributed with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 134
For each element of X, compute the probability density function (PDF) at X of the lognormal distribution with parameters MU and SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
lognrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 720
 -- Function File: lognrnd (MU, SIGMA)
 -- Function File: lognrnd (MU, SIGMA, R)
 -- Function File: lognrnd (MU, SIGMA, R, C, ...)
 -- Function File: lognrnd (MU, SIGMA, [SZ])
     Return a matrix of random samples from the lognormal distribution with parameters MU and SIGMA.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of MU and SIGMA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
Return a matrix of random samples from the lognormal distribution with parameters MU and SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbincdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 445
 -- Function File: nbincdf (X, N, P)
     For each element of X, compute the cumulative distribution function (CDF) at X of the negative binomial distribution with parameters N and P.

     When N is integer this is the Pascal distribution.  When N is extended to real numbers this is the Polya distribution.

     The number of failures in a Bernoulli experiment with success probability P before the N-th success follows this distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 141
For each element of X, compute the cumulative distribution function (CDF) at X of the negative binomial distribution with parameters N and P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbininv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 440
 -- Function File: nbininv (X, N, P)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the negative binomial distribution with parameters N and P.

     When N is integer this is the Pascal distribution.  When N is extended to real numbers this is the Polya distribution.

     The number of failures in a Bernoulli experiment with success probability P before the N-th success follows this distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 136
For each element of X, compute the quantile (the inverse of the CDF) at X of the negative binomial distribution with parameters N and P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbinpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 441
 -- Function File: nbinpdf (X, N, P)
     For each element of X, compute the probability density function (PDF) at X of the negative binomial distribution with parameters N and P.

     When N is integer this is the Pascal distribution.  When N is extended to real numbers this is the Polya distribution.

     The number of failures in a Bernoulli experiment with success probability P before the N-th success follows this distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
For each element of X, compute the probability density function (PDF) at X of the negative binomial distribution with parameters N and P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
nbinrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 698
 -- Function File: nbinrnd (N, P)
 -- Function File: nbinrnd (N, P, R)
 -- Function File: nbinrnd (N, P, R, C, ...)
 -- Function File: nbinrnd (N, P, [SZ])
     Return a matrix of random samples from the negative binomial distribution with parameters N and P.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of N and P.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 98
Return a matrix of random samples from the negative binomial distribution with parameters N and P.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 274
 -- Function File: normcdf (X)
 -- Function File: normcdf (X, MU, SIGMA)
     For each element of X, compute the cumulative distribution function (CDF) at X of the normal distribution with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 148
For each element of X, compute the cumulative distribution function (CDF) at X of the normal distribution with mean MU and standard deviation SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
norminv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 269
 -- Function File: norminv (X)
 -- Function File: norminv (X, MU, SIGMA)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the normal distribution with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
For each element of X, compute the quantile (the inverse of the CDF) at X of the normal distribution with mean MU and standard deviation SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 270
 -- Function File: normpdf (X)
 -- Function File: normpdf (X, MU, SIGMA)
     For each element of X, compute the probability density function (PDF) at X of the normal distribution with mean MU and standard deviation SIGMA.

     Default values are MU = 0, SIGMA = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 144
For each element of X, compute the probability density function (PDF) at X of the normal distribution with mean MU and standard deviation SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
normrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 741
 -- Function File: normrnd (MU, SIGMA)
 -- Function File: normrnd (MU, SIGMA, R)
 -- Function File: normrnd (MU, SIGMA, R, C, ...)
 -- Function File: normrnd (MU, SIGMA, [SZ])
     Return a matrix of random samples from the normal distribution with parameters mean MU and standard deviation SIGMA.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of MU and SIGMA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
Return a matrix of random samples from the normal distribution with parameters mean MU and standard deviation SIGMA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poisscdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 178
 -- Function File: poisscdf (X, LAMBDA)
     For each element of X, compute the cumulative distribution function (CDF) at X of the Poisson distribution with parameter LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 129
For each element of X, compute the cumulative distribution function (CDF) at X of the Poisson distribution with parameter LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poissinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 173
 -- Function File: poissinv (X, LAMBDA)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the Poisson distribution with parameter LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 124
For each element of X, compute the quantile (the inverse of the CDF) at X of the Poisson distribution with parameter LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poisspdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 174
 -- Function File: poisspdf (X, LAMBDA)
     For each element of X, compute the probability density function (PDF) at X of the Poisson distribution with parameter LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
For each element of X, compute the probability density function (PDF) at X of the Poisson distribution with parameter LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
poissrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 690
 -- Function File: poissrnd (LAMBDA)
 -- Function File: poissrnd (LAMBDA, R)
 -- Function File: poissrnd (LAMBDA, R, C, ...)
 -- Function File: poissrnd (LAMBDA, [SZ])
     Return a matrix of random samples from the Poisson distribution with parameter LAMBDA.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of LAMBDA.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Return a matrix of random samples from the Poisson distribution with parameter LAMBDA.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stdnormal_cdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 196
 -- Function File: stdnormal_cdf (X)
     For each element of X, compute the cumulative distribution function (CDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
For each element of X, compute the cumulative distribution function (CDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stdnormal_inv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 191
 -- Function File: stdnormal_inv (X)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
For each element of X, compute the quantile (the inverse of the CDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stdnormal_pdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 192
 -- Function File: stdnormal_pdf (X)
     For each element of X, compute the probability density function (PDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
For each element of X, compute the probability density function (PDF) at X of the standard normal distribution (mean = 0, standard deviation = 1).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stdnormal_rnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 582
 -- Function File: stdnormal_rnd (R)
 -- Function File: stdnormal_rnd (R, C, ...)
 -- Function File: stdnormal_rnd ([SZ])
     Return a matrix of random samples from the standard normal distribution (mean = 0, standard deviation = 1).

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 107
Return a matrix of random samples from the standard normal distribution (mean = 0, standard deviation = 1).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 177
 -- Function File: tcdf (X, N)
     For each element of X, compute the cumulative distribution function (CDF) at X of the t (Student) distribution with N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
For each element of X, compute the cumulative distribution function (CDF) at X of the t (Student) distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 276
 -- Function File: tinv (X, N)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the t (Student) distribution with N degrees of freedom.

     This function is analogous to looking in a table for the t-value of a single-tailed distribution.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
For each element of X, compute the quantile (the inverse of the CDF) at X of the t (Student) distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
tpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 173
 -- Function File: tpdf (X, N)
     For each element of X, compute the probability density function (PDF) at X of the T (Student) distribution with N degrees of freedom.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
For each element of X, compute the probability density function (PDF) at X of the T (Student) distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
trnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 657
 -- Function File: trnd (N)
 -- Function File: trnd (N, R)
 -- Function File: trnd (N, R, C, ...)
 -- Function File: trnd (N, [SZ])
     Return a matrix of random samples from the t (Student) distribution with N degrees of freedom.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of N.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 94
Return a matrix of random samples from the t (Student) distribution with N degrees of freedom.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 762
 -- Function File: unidrnd (N)
 -- Function File: unidrnd (N, R)
 -- Function File: unidrnd (N, R, C, ...)
 -- Function File: unidrnd (N, [SZ])
     Return a matrix of random samples from the discrete uniform distribution which assumes the integer values 1-N with equal probability.

     N may be a scalar or a multi-dimensional array.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the size of N.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
Return a matrix of random samples from the discrete uniform distribution which assumes the integer values 1-N with equal probability.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 217
 -- Function File: unidcdf (X, N)
     For each element of X, compute the cumulative distribution function (CDF) at X of a discrete uniform distribution which assumes the integer values 1-N with equal probability.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 174
For each element of X, compute the cumulative distribution function (CDF) at X of a discrete uniform distribution which assumes the integer values 1-N with equal probability.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 214
 -- Function File: unidinv (X, N)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the discrete uniform distribution which assumes the integer values 1-N with equal probability.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 171
For each element of X, compute the quantile (the inverse of the CDF) at X of the discrete uniform distribution which assumes the integer values 1-N with equal probability.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unidpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 369
 -- Function File: unidpdf (X, N)
     For each element of X, compute the probability density function (PDF) at X of a discrete uniform distribution which assumes the integer values 1-N with equal probability.

     Warning: The underlying implementation uses the double class and will only be accurate for N <= 'bitmax' (2^{53} - 1 on IEEE 754 compatible systems).
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 170
For each element of X, compute the probability density function (PDF) at X of a discrete uniform distribution which assumes the integer values 1-N with equal probability.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 674
 -- Function File: unifrnd (A, B)
 -- Function File: unifrnd (A, B, R)
 -- Function File: unifrnd (A, B, R, C, ...)
 -- Function File: unifrnd (A, B, [SZ])
     Return a matrix of random samples from the uniform distribution on [A, B].

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of A and B.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Return a matrix of random samples from the uniform distribution on [A, B].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 246
 -- Function File: unifcdf (X)
 -- Function File: unifcdf (X, A, B)
     For each element of X, compute the cumulative distribution function (CDF) at X of the uniform distribution on the interval [A, B].

     Default values are A = 0, B = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 130
For each element of X, compute the cumulative distribution function (CDF) at X of the uniform distribution on the interval [A, B].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 241
 -- Function File: unifinv (X)
 -- Function File: unifinv (X, A, B)
     For each element of X, compute the quantile (the inverse of the CDF) at X of the uniform distribution on the interval [A, B].

     Default values are A = 0, B = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 125
For each element of X, compute the quantile (the inverse of the CDF) at X of the uniform distribution on the interval [A, B].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
unifpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 242
 -- Function File: unifpdf (X)
 -- Function File: unifpdf (X, A, B)
     For each element of X, compute the probability density function (PDF) at X of the uniform distribution on the interval [A, B].

     Default values are A = 0, B = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 126
For each element of X, compute the probability density function (PDF) at X of the uniform distribution on the interval [A, B].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblcdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 385
 -- Function File: wblcdf (X)
 -- Function File: wblcdf (X, SCALE)
 -- Function File: wblcdf (X, SCALE, SHAPE)
     Compute the cumulative distribution function (CDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.

     This is defined as

          1 - exp (-(x/scale)^shape)

     for X >= 0.

     Default values are SCALE = 1, SHAPE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 137
Compute the cumulative distribution function (CDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 299
 -- Function File: wblinv (X)
 -- Function File: wblinv (X, SCALE)
 -- Function File: wblinv (X, SCALE, SHAPE)
     Compute the quantile (the inverse of the CDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.

     Default values are SCALE = 1, SHAPE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 132
Compute the quantile (the inverse of the CDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblpdf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 414
 -- Function File: wblpdf (X)
 -- Function File: wblpdf (X, SCALE)
 -- Function File: wblpdf (X, SCALE, SHAPE)
     Compute the probability density function (PDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.

     This is given by

          shape * scale^(-shape) * x^(shape-1) * exp (-(x/scale)^shape)

     for X >= 0.

     Default values are SCALE = 1, SHAPE = 1.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 133
Compute the probability density function (PDF) at X of the Weibull distribution with scale parameter SCALE and shape parameter SHAPE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
wblrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 732
 -- Function File: wblrnd (SCALE, SHAPE)
 -- Function File: wblrnd (SCALE, SHAPE, R)
 -- Function File: wblrnd (SCALE, SHAPE, R, C, ...)
 -- Function File: wblrnd (SCALE, SHAPE, [SZ])
     Return a matrix of random samples from the Weibull distribution with parameters SCALE and SHAPE.

     When called with a single size argument, return a square matrix with the dimension specified.  When called with more than one scalar argument the first two arguments are taken as the number of rows and columns and any further arguments specify additional matrix dimensions.  The size may also be specified with a vector of dimensions SZ.

     If no size arguments are given then the result matrix is the common size of SCALE and SHAPE.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 96
Return a matrix of random samples from the Weibull distribution with parameters SCALE and SHAPE.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
wienrnd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 438
 -- Function File: wienrnd (T, D, N)
     Return a simulated realization of the D-dimensional Wiener Process on the interval [0, T].

     If D is omitted, D = 1 is used.  The first column of the return matrix contains time, the remaining columns contain the Wiener process.

     The optional parameter N defines the number of summands used for simulating the process over an interval of length 1.  If N is omitted, N = 1000 is used.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 90
Return a simulated realization of the D-dimensional Wiener Process on the interval [0, T].



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
logistic_regression


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1609
 -- Function File: [THETA, BETA, DEV, DL, D2L, P] = logistic_regression (Y, X, PRINT, THETA, BETA)
     Perform ordinal logistic regression.

     Suppose Y takes values in K ordered categories, and let 'gamma_i (X)' be the cumulative probability that Y falls in one of the first I categories given the covariate X.  Then

          [theta, beta] = logistic_regression (y, x)

     fits the model

          logit (gamma_i (x)) = theta_i - beta' * x,   i = 1 ... k-1

     The number of ordinal categories, K, is taken to be the number of distinct values of 'round (Y)'.  If K equals 2, Y is binary and the model is ordinary logistic regression.  The matrix X is assumed to have full column rank.

     Given Y only, 'theta = logistic_regression (y)' fits the model with baseline logit odds only.

     The full form is

          [theta, beta, dev, dl, d2l, gamma]
             = logistic_regression (y, x, print, theta, beta)

     in which all output arguments and all input arguments except Y are optional.

     Setting PRINT to 1 requests summary information about the fitted model to be displayed.  Setting PRINT to 2 requests information about convergence at each iteration.  Other values request no information to be displayed.  The input arguments THETA and BETA give initial estimates for THETA and BETA.

     The returned value DEV holds minus twice the log-likelihood.

     The returned values DL and D2L are the vector of first and the matrix of second derivatives of the log-likelihood with respect to THETA and BETA.

     P holds estimates for the conditional distribution of Y given X.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Perform ordinal logistic regression.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
anova


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 986
 -- Function File: [PVAL, F, DF_B, DF_W] = anova (Y, G)
     Perform a one-way analysis of variance (ANOVA).

     The goal is to test whether the population means of data taken from K different groups are all equal.

     Data may be given in a single vector Y with groups specified by a corresponding vector of group labels G (e.g., numbers from 1 to K).  This is the general form which does not impose any restriction on the number of data in each group or the group labels.

     If Y is a matrix and G is omitted, each column of Y is treated as a group.  This form is only appropriate for balanced ANOVA in which the numbers of samples from each group are all equal.

     Under the null of constant means, the statistic F follows an F distribution with DF_B and DF_W degrees of freedom.

     The p-value (1 minus the CDF of this distribution at F) is returned in PVAL.

     If no output argument is given, the standard one-way ANOVA table is printed.

     See also: manova.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Perform a one-way analysis of variance (ANOVA).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
bartlett_test


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 471
 -- Function File: [PVAL, CHISQ, DF] = bartlett_test (X1, ...)
     Perform a Bartlett test for the homogeneity of variances in the data vectors X1, X2, ..., XK, where K > 1.

     Under the null of equal variances, the test statistic CHISQ approximately follows a chi-square distribution with DF degrees of freedom.

     The p-value (1 minus the CDF of this distribution at CHISQ) is returned in PVAL.

     If no output argument is given, the p-value is displayed.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 86
Perform a Bartlett test for the homogeneity of variances in the data vectors X1, X2, .



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
chisquare_test_homogeneity


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 586
 -- Function File: [PVAL, CHISQ, DF] = chisquare_test_homogeneity (X, Y, C)
     Given two samples X and Y, perform a chisquare test for homogeneity of the null hypothesis that X and Y come from the same distribution, based on the partition induced by the (strictly increasing) entries of C.

     For large samples, the test statistic CHISQ approximately follows a chisquare distribution with DF = 'length (C)' degrees of freedom.

     The p-value (1 minus the CDF of this distribution at CHISQ) is returned in PVAL.

     If no output argument is given, the p-value is displayed.
   


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 210
Given two samples X and Y, perform a chisquare test for homogeneity of the null hypothesis that X and Y come from the same distribution, based on the partition induced by the (strictly increasing) entries of C.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 27
chisquare_                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               