This is Info file octave, produced by Makeinfo-1.64 from the input file
octave.tex.

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

   Copyright (C) 1996 John W. Eaton.

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

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions.


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

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

* Menu:

* -braindead:                           Command Line Options.
* -debug:                               Command Line Options.
* -echo-commands:                       Command Line Options.
* -exec-path PATH:                      Command Line Options.
* -help:                                Command Line Options.
* -info-file FILENAME:                  Command Line Options.
* -info-program PROGRAM:                Command Line Options.
* -interactive:                         Command Line Options.
* -no-init-file:                        Command Line Options.
* -no-line-editing:                     Command Line Options.
* -no-site-file:                        Command Line Options.
* -norc:                                Command Line Options.
* -path PATH:                           Command Line Options.
* -quiet:                               Command Line Options.
* -silent:                              Command Line Options.
* -traditional:                         Command Line Options.
* -verbose:                             Command Line Options.
* -version:                             Command Line Options.
* -?:                                   Command Line Options.
* -d:                                   Command Line Options.
* -f:                                   Command Line Options.
* -h:                                   Command Line Options.
* -i:                                   Command Line Options.
* -p PATH:                              Command Line Options.
* -q:                                   Command Line Options.
* -v:                                   Command Line Options.
* -x:                                   Command Line Options.
* ... <1>:                              Variable-length Return Lists.
* ...:                                  Variable-length Argument Lists.
* ... continuation marker:              The try Statement.
* .octaverc:                            Startup Files.
* break statement:                      The break Statement.
* catch:                                The try Statement.
* continue statement:                   The continue Statement.
* elseif statement:                     The if Statement.
* else statement:                       The if Statement.
* endfor statement:                     The for Statement.
* endfunction statement:                Defining Functions.
* endif statement:                      The if Statement.
* endwhile statement:                   The while Statement.
* end_try_catch:                        The try Statement.
* end_unwind_protect:                   The unwind_protect Statement.
* end statement:                        Statements.
* for statement:                        The for Statement.
* function statement:                   Defining Functions.
* global statement:                     Recursion.
* if statement:                         The if Statement.
* try statement:                        The try Statement.
* unwind_protect_cleanup:               The unwind_protect Statement.
* unwind_protect statement:             The unwind_protect Statement.
* while statement:                      The while Statement.
* \ continuation marker:                The try Statement.
* ~/.octaverc:                          Startup Files.
* #!:                                   Executable Octave Programs.
* #:                                    Comments.
* %:                                    Comments.
* acknowledgements:                     Preface.
* addition:                             Arithmetic Ops.
* amusements:                           Miscellaneous Utilities.
* and operator:                         Boolean Expressions.
* answers, incorrect <1>:               Bug Reporting.
* answers, incorrect:                   Bug Criteria.
* arguments in function call:           Calling Functions.
* arithmetic operators:                 Arithmetic Ops.
* assignment expressions:               Assignment Ops.
* assignment operators:                 Assignment Ops.
* body of a loop:                       The while Statement.
* boolean expressions:                  Boolean Expressions.
* boolean operators:                    Boolean Expressions.
* bug criteria:                         Bug Criteria.
* bug report mailing lists:             Bug Lists.
* bugs:                                 Reporting Bugs.
* bugs, investigating:                  Bug Reporting.
* bugs, known:                          Trouble.
* bugs, reporting <1>:                  Bug Reporting.
* bugs, reporting:                      Bug Lists.
* built-in variables:                   Built-in Variables.
* character strings:                    String Constants.
* command options:                      Command Line Options.
* comments:                             Comments.
* comparison expressions:               Comparison Ops.
* complex-conjugate transpose:          Arithmetic Ops.
* continuation lines:                   The try Statement.
* contributors:                         Preface.
* conversion specifications (printf):   Formatted Output.
* conversion specifications (scanf):    Formatted Input.
* core dump:                            Bug Criteria.
* DAE:                                  Differential Equations.
* data structures:                      Data Structures.
* decrement operator:                   Assignment Ops.
* defining functions:                   Functions and Scripts.
* Differential Equations:               Differential Equations.
* diffs, submitting:                    Sending Patches.
* division:                             Arithmetic Ops.
* documenting Octave programs:          Comments.
* element-by-element evaluation:        Element-by-element Boolean Operators.
* equality operator:                    Comparison Ops.
* equality, tests for:                  Comparison Ops.
* equations, nonlinear:                 Nonlinear Equations.
* erroneous messages:                   Bug Criteria.
* erroneous results <1>:                Bug Reporting.
* erroneous results:                    Bug Criteria.
* error messages, incorrect:            Bug Criteria.
* escape sequence notation:             String Constants.
* executable scripts:                   Executable Octave Programs.
* exiting octave:                       Running Octave.
* exponentiation:                       Arithmetic Ops.
* expression, range:                    Ranges.
* expressions:                          Expressions.
* expressions, assignment:              Assignment Ops.
* expressions, boolean:                 Boolean Expressions.
* expressions, comparison:              Comparison Ops.
* expressions, logical:                 Boolean Expressions.
* factorial function:                   Recursion.
* fatal signal:                         Bug Criteria.
* flag character (printf):              Output Conversion Syntax.
* flag character (scanf):               Input Conversion Syntax.
* flying high and fast:                 Variables.
* Fordyce, A. P.:                       Evaluating Strings as Commands.
* function file:                        Function Files.
* functions, user-defined:              Functions and Scripts.
* getting a good job:                   Variables.
* global variables:                     Recursion.
* graphics:                             Two-Dimensional Plotting.
* greater than operator:                Comparison Ops.
* help, where to find:                  Service.
* Hermitian operator:                   Arithmetic Ops.
* history:                              Preface.
* improving Octave <1>:                 Bug Criteria.
* improving Octave:                     Sending Patches.
* incorrect error messages:             Bug Criteria.
* incorrect output <1>:                 Bug Criteria.
* incorrect output:                     Bug Reporting.
* incorrect results <1>:                Bug Criteria.
* incorrect results:                    Bug Reporting.
* increment operator:                   Assignment Ops.
* initialization:                       Startup Files.
* input conversions, for scanf:         Table of Input Conversions.
* installation trouble:                 Trouble.
* installing Octave:                    Installation.
* introduction:                         Introduction.
* invalid input:                        Bug Criteria.
* job hunting:                          Variables.
* keywords:                             Keywords.
* known causes of trouble:              Trouble.
* less than operator:                   Comparison Ops.
* logical expressions:                  Boolean Expressions.
* logical operators:                    Boolean Expressions.
* loop:                                 The while Statement.
* looping over structure elements:      Looping Over Structure Elements.
* lottery numbers:                      Amusements.
* LP:                                   Optimization.
* lvalue:                               Assignment Ops.
* matching failure, in scanf:           Formatted Input.
* matrices:                             Matrices.
* matrix multiplication:                Arithmetic Ops.
* maximum field width (scanf):          Input Conversion Syntax.
* minimum field width (printf):         Output Conversion Syntax.
* multiplication:                       Arithmetic Ops.
* negation:                             Arithmetic Ops.
* NLP:                                  Optimization.
* nonlinear equations:                  Nonlinear Equations.
* nonlinear programming:                Optimization.
* not operator:                         Boolean Expressions.
* numbers, lottery:                     Amusements.
* numbers, prime:                       Amusements.
* numeric constant:                     Numeric Constants.
* numeric value:                        Numeric Constants.
* Octave command options:               Command Line Options.
* ODE:                                  Differential Equations.
* operator precedence:                  Increment Ops.
* operators, arithmetic:                Arithmetic Ops.
* operators, assignment:                Assignment Ops.
* operators, boolean:                   Boolean Expressions.
* operators, decrement:                 Assignment Ops.
* operators, increment:                 Assignment Ops.
* operators, logical:                   Boolean Expressions.
* operators, relational:                Comparison Ops.
* optimization:                         Optimization.
* options, Octave command:              Command Line Options.
* or operator:                          Boolean Expressions.
* output conversions, for printf:       Table of Output Conversions.
* patches, submitting:                  Sending Patches.
* plotting:                             Two-Dimensional Plotting.
* precision (printf):                   Output Conversion Syntax.
* prime numbers:                        Amusements.
* program, self contained:              Executable Octave Programs.
* programs, documenting:                Comments.
* QP:                                   Optimization.
* quadratic programming:                Optimization.
* quitting octave:                      Running Octave.
* quotient:                             Arithmetic Ops.
* range expressions:                    Ranges.
* relational operators:                 Comparison Ops.
* reporting bugs <1>:                   Reporting Bugs.
* reporting bugs:                       Bug Lists.
* results, incorrect <1>:               Bug Criteria.
* results, incorrect:                   Bug Reporting.
* script files:                         Functions and Scripts.
* scripts, executable:                  Executable Octave Programs.
* self contained programs:              Executable Octave Programs.
* short-circuit evaluation:             Short-circuit Boolean Operators.
* side effect:                          Assignment Ops.
* startup:                              Startup Files.
* startup files:                        Startup Files.
* statements:                           Statements.
* strings <1>:                          String Constants.
* strings:                              Rearranging Matrices.
* structure elements, looping over:     Looping Over Structure Elements.
* structures:                           Data Structures.
* submitting diffs:                     Sending Patches.
* submitting patches:                   Sending Patches.
* subtraction:                          Arithmetic Ops.
* suggestions:                          Bug Criteria.
* tests for equality:                   Comparison Ops.
* transpose:                            Arithmetic Ops.
* transpose, complex-conjugate:         Arithmetic Ops.
* troubleshooting:                      Trouble.
* unary minus:                          Arithmetic Ops.
* undefined behavior:                   Bug Criteria.
* undefined function value:             Bug Criteria.
* use of comments:                      Comments.
* user-defined functions:               Functions and Scripts.
* user-defined variables:               Variables.
* Variable-length argument lists:       Variable-length Argument Lists.
* Variable-length return lists:         Variable-length Return Lists.
* variables:                            Built-in Variables.
* variables, built-in:                  Built-in Variables.
* variables, global:                    Recursion.
* variables, user-defined:              Variables.
* wrong answers <1>:                    Bug Criteria.
* wrong answers:                        Bug Reporting.


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

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

* Menu:

* all_va_args:                          Variable-length Argument Lists.
* ans:                                  Miscellaneous Built-in Variables.
* argv:                                 Command Line Options.
* automatic_replot:                     Two-Dimensional Plotting.
* beep_on_error:                        Miscellaneous Utilities.
* completion_append_char:               Miscellaneous Built-in Variables.
* default_return_value:                 Multiple Return Values.
* default_save_format:                  Simple File I/O.
* define_all_return_values:             Multiple Return Values.
* do_fortran_indexing:                  Index Expressions.
* e:                                    Mathematical Constants.
* echo_executing_commands:              Command History Functions.
* EDITOR:                               Command History Functions.
* empty_list_elements_ok:               Empty Matrices.
* eps:                                  Mathematical Constants.
* error_text:                           Miscellaneous Utilities.
* EXEC_PATH:                            Interacting with the OS.
* F_DUPFD:                              Interacting with the OS.
* F_GETFD:                              Interacting with the OS.
* F_GETFL:                              Interacting with the OS.
* F_SETFD:                              Interacting with the OS.
* F_SETFL:                              Interacting with the OS.
* gnuplot_binary:                       Three-Dimensional Plotting.
* gnuplot_has_frames:                   Three-Dimensional Plotting.
* gnuplot_has_multiplot:                Three-Dimensional Plotting.
* history_file:                         Command History Functions.
* history_size:                         Command History Functions.
* I:                                    Mathematical Constants.
* ignore_function_time_stamp:           Function Files.
* IMAGEPATH:                            Image Processing.
* implicit_str_to_num_ok:               String Functions.
* inf:                                  Mathematical Constants.
* INFO_FILE:                            Help.
* INFO_PROGRAM:                         Help.
* J:                                    Mathematical Constants.
* LOADPATH:                             Function Files.
* nan:                                  Mathematical Constants.
* nargin <1>:                           Defining Functions.
* nargin:                               Command Line Options.
* nargout:                              Defining Functions.
* OCTAVE_VERSION:                       Miscellaneous Built-in Variables.
* ok_to_lose_imaginary_part:            Miscellaneous Built-in Variables.
* output_max_field_width:               Matrices.
* output_precision:                     Matrices.
* O_APPEND:                             Interacting with the OS.
* O_CREAT:                              Interacting with the OS.
* O_EXCL:                               Interacting with the OS.
* O_NONBLOCK:                           Interacting with the OS.
* O_RDONLY:                             Interacting with the OS.
* O_RDWR:                               Interacting with the OS.
* O_TRUNC:                              Interacting with the OS.
* O_WRONLY:                             Interacting with the OS.
* PAGER:                                Input and Output.
* page_output_immediately:              Input and Output.
* page_screen_output:                   Input and Output.
* pi:                                   Mathematical Constants.
* prefer_column_vectors:                Index Expressions.
* prefer_zero_one_indexing:             Index Expressions.
* print_answer_id_name:                 Miscellaneous Built-in Variables.
* print_empty_dimensions:               Empty Matrices.
* program_invocation_name:              Command Line Options.
* program_name:                         Command Line Options.
* propagate_empty_matrices:             Miscellaneous Built-in Variables.
* PS1:                                  Miscellaneous Built-in Variables.
* PS2:                                  Miscellaneous Built-in Variables.
* PS4:                                  Miscellaneous Built-in Variables.
* PWD:                                  Interacting with the OS.
* realmax:                              Mathematical Constants.
* realmin:                              Mathematical Constants.
* resize_on_range_error:                Index Expressions.
* return:                               Returning From a Function.
* return_last_computed_value:           Returning From a Function.
* save_precision:                       Simple File I/O.
* saving_history:                       Command History Functions.
* SEEK_CUR:                             Other I/O Functions.
* SEEK_END:                             Other I/O Functions.
* SEEK_SET:                             Other I/O Functions.
* silent_functions:                     Defining Functions.
* split_long_rows:                      Matrices.
* stderr:                               C-Style I/O Functions.
* stdin:                                C-Style I/O Functions.
* stdout:                               C-Style I/O Functions.
* string_fill_char:                     String Functions.
* struct_levels_to_print:               Data Structures.
* suppress_verbose_help_message:        Help.
* treat_neg_dim_as_zero:                Miscellaneous Built-in Variables.
* warn_assign_as_truth_value:           The if Statement.
* warn_comma_in_global_decl:            Global Variables.
* warn_divide_by_zero:                  Arithmetic Ops.
* warn_function_name_clash:             Function Files.
* warn_missing_semicolon:               Defining Functions.
* whitespace_in_literal_matrix:         Matrices.


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

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

* Menu:

* (:                                    Miscellaneous Utilities.
* abcddim:                              Control Theory.
* abs:                                  Complex Arithmetic.
* acos:                                 Trigonometry.
* acosh:                                Trigonometry.
* acot:                                 Trigonometry.
* acoth:                                Trigonometry.
* acsc:                                 Trigonometry.
* acsch:                                Trigonometry.
* all:                                  Finding Elements and Checking Conditions.
* angle:                                Complex Arithmetic.
* any:                                  Finding Elements and Checking Conditions.
* are:                                  Control Theory.
* arg:                                  Complex Arithmetic.
* asctime:                              Timing Utilities.
* asec:                                 Trigonometry.
* asech:                                Trigonometry.
* asin:                                 Trigonometry.
* asinh:                                Trigonometry.
* atan:                                 Trigonometry.
* atan2:                                Trigonometry.
* atanh:                                Trigonometry.
* atexit:                               Interacting with the OS.
* axis:                                 Miscellaneous Plotting Functions.
* balance:                              Basic Matrix Functions.
* bar:                                  Miscellaneous Plotting Functions.
* beta:                                 Special Functions.
* betai:                                Special Functions.
* bin2dec:                              String Functions.
* blanks:                               String Functions.
* bug_report <1>:                       Bug Lists.
* bug_report:                           Reporting Bugs.
* c2d:                                  Control Theory.
* casesen:                              Amusements.
* cd:                                   Interacting with the OS.
* ceil:                                 Utility Functions.
* chdir:                                Interacting with the OS.
* chol:                                 Matrix Factorizations.
* clc:                                  Interacting with the OS.
* clear:                                Miscellaneous Utilities.
* clearplot:                            Miscellaneous Plotting Functions.
* clg:                                  Miscellaneous Plotting Functions.
* clock:                                Timing Utilities.
* closeplot:                            Miscellaneous Plotting Functions.
* colloc:                               Orthogonal Collocation.
* colormap:                             Image Processing.
* columns:                              Miscellaneous Utilities.
* compan:                               Polynomial Manipulations.
* complement:                           Sets.
* computer:                             System Information.
* cond:                                 Basic Matrix Functions.
* conj:                                 Complex Arithmetic.
* contour:                              Two-Dimensional Plotting.
* conv:                                 Polynomial Manipulations.
* corrcoef:                             Statistics.
* cos:                                  Trigonometry.
* cosh:                                 Trigonometry.
* cot:                                  Trigonometry.
* coth:                                 Trigonometry.
* cov:                                  Statistics.
* cputime:                              Timing Utilities.
* create_set:                           Sets.
* csc:                                  Trigonometry.
* csch:                                 Trigonometry.
* cumprod:                              Sums and Products.
* cumsum:                               Sums and Products.
* dare:                                 Control Theory.
* dassl:                                Differential-Algebraic Equations.
* dassl_options:                        Differential-Algebraic Equations.
* date:                                 Timing Utilities.
* deblank:                              String Functions.
* dec2bin:                              String Functions.
* dec2hex:                              String Functions.
* deconv:                               Polynomial Manipulations.
* det:                                  Basic Matrix Functions.
* dgram:                                Control Theory.
* diag:                                 Special Utility Matrices.
* diary:                                Command History Functions.
* dir:                                  Interacting with the OS.
* disp:                                 Terminal Output.
* dlqe:                                 Control Theory.
* dlqr:                                 Control Theory.
* dlyap:                                Control Theory.
* document:                             Miscellaneous Utilities.
* dup2:                                 Interacting with the OS.
* echo:                                 Command History Functions.
* edit_history:                         Command History Functions.
* eig:                                  Basic Matrix Functions.
* endgrent:                             Group Database Functions.
* endpwent:                             Password Database Functions.
* erf:                                  Special Functions.
* erfc:                                 Special Functions.
* error:                                Miscellaneous Utilities.
* etime:                                Timing Utilities.
* eval:                                 Evaluating Strings as Commands.
* exec:                                 Interacting with the OS.
* exist:                                Miscellaneous Utilities.
* exit <1>:                             Running Octave.
* exit:                                 Amusements.
* exp:                                  Utility Functions.
* expm:                                 Functions of a Matrix.
* eye:                                  Special Utility Matrices.
* fclose:                               Opening and Closing Files.
* fcntl:                                Interacting with the OS.
* feof:                                 Other I/O Functions.
* ferror:                               Other I/O Functions.
* feval:                                Evaluating Strings as Commands.
* fflush:                               Other I/O Functions.
* fft:                                  Signal Processing.
* fft2:                                 Signal Processing.
* fftconv:                              Signal Processing.
* fftfilt:                              Signal Processing.
* fgetl:                                Other I/O Functions.
* fgets:                                Other I/O Functions.
* file_in_path:                         Miscellaneous Utilities.
* filter:                               Signal Processing.
* find:                                 Finding Elements and Checking Conditions.
* findstr:                              String Functions.
* finite:                               Finding Elements and Checking Conditions.
* fix:                                  Utility Functions.
* fliplr:                               Rearranging Matrices.
* flipud:                               Rearranging Matrices.
* floor:                                Utility Functions.
* flops:                                Amusements.
* fopen:                                Opening and Closing Files.
* fork:                                 Interacting with the OS.
* format:                               Terminal Output.
* fprintf:                              Formatted Output.
* fputs:                                Other I/O Functions.
* fread:                                Binary I/O.
* freport:                              Other I/O Functions.
* freqz:                                Signal Processing.
* frewind:                              Other I/O Functions.
* fscanf:                               Formatted Input.
* fseek:                                Other I/O Functions.
* fsolve:                               Nonlinear Equations.
* fsolve_options:                       Nonlinear Equations.
* ftell:                                Other I/O Functions.
* fwrite:                               Binary I/O.
* gamma:                                Special Functions.
* gammai:                               Special Functions.
* gcd:                                  Utility Functions.
* getegid:                              Interacting with the OS.
* getenv:                               Interacting with the OS.
* geteuid:                              Interacting with the OS.
* getgid:                               Interacting with the OS.
* getgrent:                             Group Database Functions.
* getgrgid:                             Group Database Functions.
* getgrnam:                             Group Database Functions.
* getpgrp:                              Interacting with the OS.
* getpid:                               Interacting with the OS.
* getppid:                              Interacting with the OS.
* getpwent:                             Password Database Functions.
* getpwnam:                             Password Database Functions.
* getpwuid:                             Password Database Functions.
* getrusage:                            System Information.
* getuid:                               Interacting with the OS.
* givens:                               Basic Matrix Functions.
* gls:                                  Linear Least Squares.
* gmtime:                               Timing Utilities.
* gplot:                                Two-Dimensional Plotting.
* gray:                                 Image Processing.
* gray2ind:                             Image Processing.
* grid:                                 Miscellaneous Plotting Functions.
* gsplot:                               Three-Dimensional Plotting.
* hadamard:                             Famous Matrices.
* hankel:                               Famous Matrices.
* help:                                 Help.
* hess:                                 Matrix Factorizations.
* hex2dec:                              String Functions.
* hilb:                                 Famous Matrices.
* hist:                                 Miscellaneous Plotting Functions.
* history:                              Command History Functions.
* hold:                                 Two-Dimensional Plotting.
* home:                                 Interacting with the OS.
* ifft:                                 Signal Processing.
* ifft2:                                Signal Processing.
* imag:                                 Complex Arithmetic.
* image:                                Image Processing.
* imagesc:                              Image Processing.
* imshow:                               Image Processing.
* ind2gray:                             Image Processing.
* ind2rgb:                              Image Processing.
* index:                                String Functions.
* input:                                Terminal Input.
* int2str:                              String Functions.
* intersection:                         Sets.
* inv:                                  Basic Matrix Functions.
* inverse:                              Basic Matrix Functions.
* invhilb:                              Famous Matrices.
* isalnum:                              String Functions.
* isalpha:                              String Functions.
* isascii:                              String Functions.
* iscntrl:                              String Functions.
* isdigit:                              String Functions.
* isempty:                              Miscellaneous Utilities.
* isgraph:                              String Functions.
* ishold:                               Two-Dimensional Plotting.
* isieee:                               System Information.
* isinf:                                Finding Elements and Checking Conditions.
* islower:                              String Functions.
* isnan:                                Finding Elements and Checking Conditions.
* isprint:                              String Functions.
* ispunct:                              String Functions.
* isspace:                              String Functions.
* isstr:                                Miscellaneous Utilities.
* isupper:                              String Functions.
* isxdigit:                             String Functions.
* is_controllable:                      Control Theory.
* is_global:                            Miscellaneous Utilities.
* is_leap_year:                         Timing Utilities.
* is_matrix:                            Miscellaneous Utilities.
* is_observable:                        Control Theory.
* is_scalar:                            Miscellaneous Utilities.
* is_square:                            Miscellaneous Utilities.
* is_struct:                            Data Structures.
* is_symmetric:                         Miscellaneous Utilities.
* is_vector:                            Miscellaneous Utilities.
* kbhit:                                Other I/O Functions.
* keyboard:                             Terminal Input.
* kron:                                 Functions of a Matrix.
* kurtosis:                             Statistics.
* lcm:                                  Utility Functions.
* length:                               Miscellaneous Utilities.
* lgamma:                               Special Functions.
* lin2mu:                               Audio Processing.
* linspace:                             Special Utility Matrices.
* list_primes:                          Amusements.
* load:                                 Simple File I/O.
* loadaudio:                            Audio Processing.
* loadimage:                            Image Processing.
* localtime:                            Timing Utilities.
* log:                                  Utility Functions.
* log10:                                Utility Functions.
* log2:                                 Utility Functions.
* loglog:                               Two-Dimensional Plotting.
* logm:                                 Functions of a Matrix.
* logspace:                             Special Utility Matrices.
* lqe:                                  Control Theory.
* lqr:                                  Control Theory.
* ls:                                   Interacting with the OS.
* lsode:                                Ordinary Differential Equations.
* lsode_options:                        Ordinary Differential Equations.
* lstat:                                Filesystem Utilities.
* lu:                                   Matrix Factorizations.
* lyap:                                 Control Theory.
* mahalanobis:                          Statistics.
* max:                                  Utility Functions.
* mean:                                 Statistics.
* median:                               Statistics.
* menu:                                 Miscellaneous Utilities.
* mesh:                                 Three-Dimensional Plotting.
* meshdom:                              Three-Dimensional Plotting.
* min:                                  Utility Functions.
* mkdir:                                Filesystem Utilities.
* mkfifo:                               Interacting with the OS.
* mktime:                               Timing Utilities.
* more:                                 Input and Output.
* mu2lin:                               Audio Processing.
* nargchk:                              Miscellaneous Utilities.
* newtroot:                             Evaluating Strings as Commands.
* norm:                                 Basic Matrix Functions.
* npsol:                                Nonlinear Programming.
* npsol_options:                        Nonlinear Programming.
* null:                                 Basic Matrix Functions.
* num2str:                              String Functions.
* ocean:                                Image Processing.
* octave_tmp_file_name:                 Miscellaneous Utilities.
* ols:                                  Linear Least Squares.
* ones:                                 Special Utility Matrices.
* orth:                                 Basic Matrix Functions.
* pause:                                Other Functions.
* pclose:                               Other I/O Functions.
* perror:                               Miscellaneous Utilities.
* pinv:                                 Basic Matrix Functions.
* pipe:                                 Interacting with the OS.
* playaudio:                            Audio Processing.
* plot:                                 Two-Dimensional Plotting.
* polar:                                Two-Dimensional Plotting.
* poly:                                 Polynomial Manipulations.
* polyderiv:                            Polynomial Manipulations.
* polyinteg:                            Polynomial Manipulations.
* polyreduce:                           Polynomial Manipulations.
* polyval:                              Polynomial Manipulations.
* polyvalm:                             Polynomial Manipulations.
* popen:                                Other I/O Functions.
* popen2:                               Other I/O Functions.
* printf:                               Formatted Output.
* prod:                                 Sums and Products.
* purge_tmp_files:                      Miscellaneous Plotting Functions.
* putenv:                               Interacting with the OS.
* puts:                                 Other I/O Functions.
* pwd:                                  Interacting with the OS.
* qpsol:                                Quadratic Programming.
* qpsol_options:                        Quadratic Programming.
* qr:                                   Matrix Factorizations.
* quad:                                 Functions of one Variable.
* quad_options:                         Functions of one Variable.
* quit <1>:                             Running Octave.
* quit:                                 Amusements.
* qzhess:                               Functions of a Matrix.
* qzval:                                Functions of a Matrix.
* rand:                                 Special Utility Matrices.
* randn:                                Special Utility Matrices.
* rank:                                 Basic Matrix Functions.
* readdir:                              Filesystem Utilities.
* real:                                 Complex Arithmetic.
* record:                               Audio Processing.
* rem:                                  Utility Functions.
* rename:                               Filesystem Utilities.
* replot:                               Two-Dimensional Plotting.
* reshape:                              Rearranging Matrices.
* residue:                              Polynomial Manipulations.
* rgb2ind:                              Image Processing.
* rindex:                               String Functions.
* rmdir:                                Filesystem Utilities.
* roots:                                Polynomial Manipulations.
* rot90:                                Rearranging Matrices.
* round:                                Utility Functions.
* rows:                                 Miscellaneous Utilities.
* run_history:                          Command History Functions.
* save:                                 Simple File I/O.
* saveaudio:                            Audio Processing.
* saveimage:                            Image Processing.
* scanf:                                Formatted Input.
* schur:                                Matrix Factorizations.
* sec:                                  Trigonometry.
* sech:                                 Trigonometry.
* semilogx:                             Two-Dimensional Plotting.
* semilogy:                             Two-Dimensional Plotting.
* set:                                  Two-Dimensional Plotting.
* setaudio:                             Audio Processing.
* setgrent:                             Group Database Functions.
* setpwent:                             Password Database Functions.
* setstr:                               String Functions.
* show:                                 Two-Dimensional Plotting.
* sign:                                 Utility Functions.
* sin:                                  Trigonometry.
* sinc:                                 Signal Processing.
* sinh:                                 Trigonometry.
* size:                                 Miscellaneous Utilities.
* skewness:                             Statistics.
* sombrero:                             Miscellaneous Plotting Functions.
* sort:                                 Rearranging Matrices.
* source:                               Script Files.
* split:                                String Functions.
* sprintf:                              Formatted Output.
* sqrt:                                 Utility Functions.
* sqrtm:                                Functions of a Matrix.
* sscanf:                               Formatted Input.
* stairs:                               Miscellaneous Plotting Functions.
* stat:                                 Filesystem Utilities.
* std:                                  Statistics.
* str2mat:                              String Functions.
* strcmp:                               String Functions.
* strftime:                             Timing Utilities.
* strrep:                               String Functions.
* struct_contains:                      Data Structures.
* struct_elements:                      Data Structures.
* substr:                               String Functions.
* sum:                                  Sums and Products.
* sumsq:                                Sums and Products.
* svd:                                  Matrix Factorizations.
* syl:                                  Functions of a Matrix.
* system:                               Interacting with the OS.
* tan:                                  Trigonometry.
* tanh:                                 Trigonometry.
* texas_lotto:                          Amusements.
* tic:                                  Timing Utilities.
* tilde_expand:                         Other Functions.
* time:                                 Timing Utilities.
* title:                                Miscellaneous Plotting Functions.
* toascii:                              String Functions.
* toc:                                  Timing Utilities.
* toeplitz:                             Famous Matrices.
* tolower:                              String Functions.
* toupper:                              String Functions.
* trace:                                Basic Matrix Functions.
* tril:                                 Rearranging Matrices.
* triu:                                 Rearranging Matrices.
* type:                                 Miscellaneous Utilities.
* tzero:                                Control Theory.
* umask:                                Filesystem Utilities.
* undo_string_escapes:                  String Functions.
* union:                                Sets.
* unlink:                               Filesystem Utilities.
* usage:                                Miscellaneous Utilities.
* vander:                               Famous Matrices.
* va_arg:                               Variable-length Argument Lists.
* va_start:                             Variable-length Argument Lists.
* version:                              System Information.
* vr_val:                               Variable-length Return Lists.
* waitpid:                              Interacting with the OS.
* warning:                              Miscellaneous Utilities.
* warranty:                             Amusements.
* which:                                Miscellaneous Utilities.
* who:                                  Miscellaneous Utilities.
* whos:                                 Miscellaneous Utilities.
* xlabel:                               Miscellaneous Plotting Functions.
* ylabel:                               Miscellaneous Plotting Functions.
* zeros:                                Special Utility Matrices.


File: octave,  Node: Operator Index,  Next: Readline Index,  Prev: Function Index,  Up: Top

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

* Menu:

* !:                                    Element-by-element Boolean Operators.
* !=:                                   Comparison Ops.
* ":                                    String Constants.
* &:                                    Element-by-element Boolean Operators.
* &&:                                   Short-circuit Boolean Operators.
* ' <1>:                                Arithmetic Ops.
* ':                                    String Constants.
* *:                                    Arithmetic Ops.
* **:                                   Arithmetic Ops.
* +:                                    Arithmetic Ops.
* ++:                                   Assignment Ops.
* ,:                                    Matrices.
* -:                                    Arithmetic Ops.
* -:                                    Assignment Ops.
* .':                                   Arithmetic Ops.
* .*:                                   Arithmetic Ops.
* .**:                                  Arithmetic Ops.
* .+:                                   Arithmetic Ops.
* .-:                                   Arithmetic Ops.
* ./:                                   Arithmetic Ops.
* .\:                                   Arithmetic Ops.
* .^:                                   Arithmetic Ops.
* /:                                    Arithmetic Ops.
* ::                                    Ranges.
* ;:                                    Matrices.
* <:                                    Comparison Ops.
* <=:                                   Comparison Ops.
* <>:                                   Comparison Ops.
* =:                                    Assignment Ops.
* ==:                                   Comparison Ops.
* >:                                    Comparison Ops.
* >=:                                   Comparison Ops.
* [:                                    Matrices.
* \:                                    Arithmetic Ops.
* ]:                                    Matrices.
* ^:                                    Arithmetic Ops.
* |:                                    Element-by-element Boolean Operators.
* ||:                                   Short-circuit Boolean Operators.
* ~:                                    Element-by-element Boolean Operators.
* ~=:                                   Comparison Ops.


File: octave,  Node: Command Line Editing,  Next: Using Info,  Prev: Trouble,  Up: Top

Command Line Editing
********************

   This text describes GNU's command line editing interface.  It is
relatively old and may not be entirely correct now.  Please send a
message to `bug-octave@bevo.che.wisc.edu' if you find any errors.
*Note Reporting Bugs::, for more information about how to report bugs.

* Menu:

* Introduction and Notation::   Notation used in this text.
* Readline Interaction::        The minimum set of commands for editing a line.
* Readline Bare Essentials::
* Readline Movement Commands::
* Readline Killing Commands::
* Readline Arguments::
* Readline Init File::          Customizing Readline from a user's view.
* Readline Init Syntax::
* Readline Vi Mode::


File: octave,  Node: Introduction and Notation,  Next: Readline Interaction,  Prev: Command Line Editing,  Up: Command Line Editing

Introduction to Line Editing
============================

   The following paragraphs describe the notation we use to represent
keystrokes.

   The text C-k is read as `Control-K' and describes the character
produced when the Control key is depressed and the k key is struck.

   The text M-k is read as `Meta-K' and describes the character
produced when the meta key (if you have one) is depressed, and the k
key is struck.  If you do not have a meta key, the identical keystroke
can be generated by typing ESC first, and then typing k.  Either
process is known as "metafying" the k key.

   The text M-C-k is read as `Meta-Control-k' and describes the
character produced by "metafying" C-k.

   In addition, several keys have their own names.  Specifically, DEL,
ESC, LFD, SPC, RET, and TAB all stand for themselves when seen in this
text, or in an init file (*note Readline Init File::., for more info).


File: octave,  Node: Readline Interaction,  Next: Readline Bare Essentials,  Prev: Introduction and Notation,  Up: Command Line Editing

Readline Interaction
====================

   Often during an interactive session you type in a long line of text,
only to notice that the first word on the line is misspelled.  The
Readline library gives you a set of commands for manipulating the text
as you type it in, allowing you to just fix your typo, and not forcing
you to retype the majority of the line.  Using these editing commands,
you move the cursor to the place that needs correction, and delete or
insert the text of the corrections.  Then, when you are satisfied with
the line, you simply press RETURN.  You do not have to be at the end of
the line to press RETURN; the entire line is accepted regardless of the
location of the cursor within the line.

* Menu:

* Readline Bare Essentials::    The least you need to know about Readline.
* Readline Movement Commands::  Moving about the input line.
* Readline Killing Commands::   How to delete text, and how to get it back!
* Readline Arguments::          Giving numeric arguments to commands.

