     [file conf.texi not included]

c Octave C++ Classes

Copyright (C) 1993, 1994, 1995 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.

This manual documents how to use, install and port Octave's C++ class library, and how to report bugs.  It corresponds to Octave version VERSION.

Acknowledgements
****************

Contributors to Octave
======================

In addition to John W. Eaton, several people have written parts of liboctave.

  * A. Scottedward Hodel (scotte@eng.auburn.edu) contributed a number of functions including expm, qzval, qzhess, syl, lyap, and balance.

  * R. Bruce Tenison (Bruce.Tenison@eng.auburn.edu) wrote the hess and schur functions.

Special thanks to the following people and organizations for supporting the development of Octave:

  * Digital Equipment Corporation, for an equipment grant as part of their External Research Program.

  * Sun Microsystems, Inc., for an Academic Equipment grant.

  * The University of Texas College of Engineering, for providing a Challenge for Excellence Research Supplement, and for providing an Academic Development Funds grant.

  * Texaco Chemical Company, for providing funding to continue the development of this software.

  * Noel Bell, Senior Engineer, Texaco Chemical Company, Austin Texas.

  * James B. Rawlings, Associate Professor, Department of Chemical Engineering, The University of Texas at Austin.

Portions of this document have been adapted from the gawk, readline, gcc, and C library manuals, published by the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

This project would not have been possible without the GNU software used in and used to produce Octave.

A Brief Introduction to Octave
******************************

This manual documents how to run, install and port Octave's C++ classes, and how to report bugs.

Arrays
******

Constructors and Assignment
===========================

 -- Array: (void)
 -- Array: (int N)
 -- Array: (int N, const T &VAL)
 -- Array: (const Array<T> &A)

 -- Array<T>&: operator = (const Array<T> &A)

 -- int: capacity (void) const
 -- int: length (void) const

 -- T&: elem (int N)
 -- T&: checkelem (int N)
 -- T&: operator () (int N)

 -- void: resize (int N)
 -- void: resize (int N, const T &VAL)

 -- const: T *data (void) const

 -- Array2: (void)
 -- Array2: (int N, int M)
 -- Array2: (int N, int M, const T &VAL)
 -- Array2: (const Array2<T> &A)
 -- Array2: (const DiagArray<T> &A)

 -- Array2<T>&: operator = (const Array2<T> &A)

 -- int: dim1 (void) const
 -- int: rows (void) const

 -- int: dim2 (void) const
 -- int: cols (void) const
 -- int: columns (void) const

 -- T&: elem (int I, int J)
 -- T&: checkelem (int I, int J)
 -- T&: operator () (int I, int J)

 -- void: resize (int N, int M)
 -- void: resize (int N, int M, const T &VAL)

 -- Array3: (void)
 -- Array3: (int N, int M, int K)
 -- Array3: (int N, int M, int K, const T &VAL)
 -- Array3: (const Array3<T> &A)

 -- Array3<T>&: operator = (const Array3<T> &A)

 -- int: dim1 (void) const
 -- int: dim2 (void) const
 -- int: dim3 (void) const

 -- T&: elem (int I, int J, int K)
 -- T&: checkelem (int I, int J, int K)
 -- T&: operator () (int I, int J, int K)

 -- void: resize (int N, int M, int K)
 -- void: resize (int N, int M, int K, const T &VAL)

 -- DiagArray: (void)
 -- DiagArray: (int N)
 -- DiagArray: (int N, const T &VAL)
 -- DiagArray: (int R, int C)
 -- DiagArray: (int R, int C, const T &VAL)
 -- DiagArray: (const Array<T> &A)
 -- DiagArray: (const DiagArray<T> &A)

 -- DiagArray<T>&: operator = (const DiagArray<T> &A)

 -- int: dim1 (void) const
 -- int: rows (void) const

 -- int: dim2 (void) const
 -- int: cols (void) const
 -- int: columns (void) const

 -- T&: elem (int R, int C)
 -- T&: checkelem (int R, int C)
 -- T&: operator () (int R, int C)

 -- void: resize (int N, int M)
 -- void: resize (int N, int M, const T &VAL)

The real and complex ColumnVector and RowVector classes all have the following functions.  These will eventually be part of an MArray<T> class, derived from the Array<T> class.  Then the ColumnVector and RowVector classes will be derived from the MArray<T> class.

Element by element vector by scalar ops.

 -- friend RowVector: operator + (const RowVector &A, const double &S)
 -- friend RowVector: operator - (const RowVector &A, const double &S)
 -- friend RowVector: operator * (const RowVector &A, const double &S)
 -- friend RowVector: operator / (const RowVector &A, const double &S)

Element by element scalar by vector ops.

 -- friend RowVector: operator + (const double &S, const RowVector &A)
 -- friend RowVector: operator - (const double &S, const RowVector &A)
 -- friend RowVector: operator * (const double &S, const RowVector &A)
 -- friend RowVector: operator / (const double &S, const RowVector &A)

Element by element vector by vector ops.

 -- friend RowVector: operator + (const RowVector &A, const RowVector &B)
 -- friend RowVector: operator - (const RowVector &A, const RowVector &B)

 -- friend RowVector: product (const RowVector &A, const RowVector &B)
 -- friend RowVector: quotient (const RowVector &A, const RowVector &B)

Unary MArray ops.

 -- friend RowVector: operator - (const RowVector &A)

The Matrix classes share the following functions.  These will eventually be part of an MArray2<T> class, derived from the Array2<T> class.  Then the Matrix class will be derived from the MArray<T> class.

Element by element matrix by scalar ops.

 -- friend Matrix: operator + (const Matrix &A, const double &S)
 -- friend Matrix: operator - (const Matrix &A, const double &S)
 -- friend Matrix: operator * (const Matrix &A, const double &S)
 -- friend Matrix: operator / (const Matrix &A, const double &S)

Element by element scalar by matrix ops.

 -- friend Matrix: operator + (const double &S, const Matrix &A)
 -- friend Matrix: operator - (const double &S, const Matrix &A)
 -- friend Matrix: operator * (const double &S, const Matrix &A)
 -- friend Matrix: operator / (const double &S, const Matrix &A)

Element by element matrix by matrix ops.

 -- friend Matrix: operator + (const Matrix &A, const Matrix &B)
 -- friend Matrix: operator - (const Matrix &A, const Matrix &B)

 -- friend Matrix: product (const Matrix &A, const Matrix &B)
 -- friend Matrix: quotient (const Matrix &A, const Matrix &B)

Unary matrix ops.

 -- friend Matrix: operator - (const Matrix &A)

The DiagMatrix classes share the following functions.  These will eventually be part of an MDiagArray<T> class, derived from the DiagArray<T> class.  Then the DiagMatrix class will be derived from the MDiagArray<T> class.

Element by element MDiagArray by scalar ops.

 -- friend DiagMatrix: operator * (const DiagMatrix &A, const double &S)
 -- friend DiagMatrix: operator / (const DiagMatrix &A, const double &S)

Element by element scalar by MDiagArray ops.

 -- friend DiagMatrix: operator * (const double &S, const DiagMatrix &A)

Element by element MDiagArray by MDiagArray ops.

 -- friend DiagMatrix: operator + (const DiagMatrix &A, const DiagMatrix &B)
 -- friend DiagMatrix: operator - (const DiagMatrix &A, const DiagMatrix &B)

 -- friend DiagMatrix: product (const DiagMatrix &A, const DiagMatrix &B)

Unary MDiagArray ops.

 -- friend DiagMatrix: operator - (const DiagMatrix &A)

Matrix and Vector Operations
****************************

 -- Matrix: (void)
 -- Matrix: (int R, int C)
 -- Matrix: (int R, int C, double VAL)
 -- Matrix: (const Array2<double> &A)
 -- Matrix: (const Matrix &A)
 -- Matrix: (const DiagArray<double> &A)
 -- Matrix: (const DiagMatrix &A)

 -- Matrix&: operator = (const Matrix &A)

 -- int: operator == (const Matrix &A) const
 -- int: operator != (const Matrix &A) const

 -- Matrix&: insert (const Matrix &A, int R, int C)
 -- Matrix&: insert (const RowVector &A, int R, int C)
 -- Matrix&: insert (const ColumnVector &A, int R, int C)
 -- Matrix&: insert (const DiagMatrix &A, int R, int C)

 -- Matrix&: fill (double VAL)
 -- Matrix&: fill (double VAL, int r1, int c1, int r2, int c2)

 -- Matrix: append (const Matrix &A) const
 -- Matrix: append (const RowVector &A) const
 -- Matrix: append (const ColumnVector &A) const
 -- Matrix: append (const DiagMatrix &A) const

 -- Matrix: stack (const Matrix &A) const
 -- Matrix: stack (const RowVector &A) const
 -- Matrix: stack (const ColumnVector &A) const
 -- Matrix: stack (const DiagMatrix &A) const

 -- Matrix: transpose (void) const

 -- Matrix: extract (int r1, int c1, int r2, int c2) const

 -- RowVector: row (int I) const
 -- RowVector: row (char *s) const

 -- ColumnVector: column (int I) const
 -- ColumnVector: column (char *s) const

 -- Matrix: inverse (void) const
 -- Matrix: inverse (int &INFO) const
 -- Matrix: inverse (int &INFO, double &RCOND) const

 -- ComplexMatrix: fourier (void) const
 -- ComplexMatrix: ifourier (void) const

 -- DET: determinant (void) const
 -- DET: determinant (int &INFO) const
 -- DET: determinant (int &INFO, double &RCOND) const

 -- Matrix: solve (const Matrix &B) const
 -- Matrix: solve (const Matrix &B, int &INFO) const
 -- Matrix: solve (const Matrix &B, int &INFO, double &RCOND) const

 -- ComplexMatrix: solve (const ComplexMatrix &B) const
 -- ComplexMatrix: solve (const ComplexMatrix &B, int &INFO) const
 -- ComplexMatrix: solve (const ComplexMatrix &B, int &INFO, double &RCOND) const

 -- ColumnVector: solve (const ColumnVector &B) const
 -- ColumnVector: solve (const ColumnVector &B, int &INFO) const
 -- ColumnVector: solve (const ColumnVector &B, int &INFO, double &RCOND) const

 -- ComplexColumnVector: solve (const ComplexColumnVector &B) const
 -- ComplexColumnVector: solve (const ComplexColumnVector &B, int &INFO) const
 -- ComplexColumnVector: solve (const ComplexColumnVector &B, int &INFO, double &RCOND) const

 -- Matrix: lssolve (const Matrix &B) const
 -- Matrix: lssolve (const Matrix &B, int &INFO) const
 -- Matrix: lssolve (const Matrix &B, int &INFO, int &RANK) const

 -- ComplexMatrix: lssolve (const ComplexMatrix &B) const
 -- ComplexMatrix: lssolve (const ComplexMatrix &B, int &INFO) const
 -- ComplexMatrix: lssolve (const ComplexMatrix &B, int &INFO, int &RANK) const

 -- ColumnVector: lssolve (const ColumnVector &B) const
 -- ColumnVector: lssolve (const ColumnVector &B, int &INFO) const
 -- ColumnVector: lssolve (const ColumnVector &B, int &INFO, int &RANK) const

 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B) const
 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B, int &INFO) const
 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B, int &INFO, int &RANK) const

 -- Matrix&: operator += (const Matrix &A)
 -- Matrix&: operator -= (const Matrix &A)

 -- Matrix&: operator += (const DiagMatrix &A)
 -- Matrix&: operator -= (const DiagMatrix &A)

 -- Matrix: operator ! (void) const

 -- friend ComplexMatrix: operator + (const Matrix &A, const Complex &S)
 -- friend ComplexMatrix: operator - (const Matrix &A, const Complex &S)
 -- friend ComplexMatrix: operator * (const Matrix &A, const Complex &S)
 -- friend ComplexMatrix: operator / (const Matrix &A, const Complex &S)

 -- friend ComplexMatrix: operator + (const Complex &S, const Matrix &A)
 -- friend ComplexMatrix: operator - (const Complex &S, const Matrix &A)
 -- friend ComplexMatrix: operator * (const Complex &S, const Matrix &A)
 -- friend ComplexMatrix: operator / (const Complex &S, const Matrix &A)

 -- friend ColumnVector: operator * (const Matrix &A, const ColumnVector &B)
 -- friend ComplexColumnVector: operator * (const Matrix &A, const ComplexColumnVector &B)

 -- friend Matrix: operator + (const Matrix &A, const DiagMatrix &B)
 -- friend Matrix: operator - (const Matrix &A, const DiagMatrix &B)
 -- friend Matrix: operator * (const Matrix &A, const DiagMatrix &B)

 -- friend ComplexMatrix: operator + (const Matrix &A, const ComplexDiagMatrix &B)
 -- friend ComplexMatrix: operator - (const Matrix &A, const ComplexDiagMatrix &B)
 -- friend ComplexMatrix: operator * (const Matrix &A, const ComplexDiagMatrix &B)

 -- friend Matrix: operator * (const Matrix &A, const Matrix &B)
 -- friend ComplexMatrix: operator * (const Matrix &A, const ComplexMatrix &B)

 -- friend ComplexMatrix: operator + (const Matrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: operator - (const Matrix &A, const ComplexMatrix &B)

 -- friend ComplexMatrix: product (const Matrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: quotient (const Matrix &A, const ComplexMatrix &B)

 -- friend Matrix: map (d_d_Mapper F, const Matrix &A)
 -- void: map (d_d_Mapper F)

 -- Matrix: all (void) const
 -- Matrix: any (void) const

 -- Matrix: cumprod (void) const
 -- Matrix: cumsum (void) const
 -- Matrix: prod (void) const
 -- Matrix: sum (void) const
 -- Matrix: sumsq (void) const

 -- ColumnVector: diag (void) const
 -- ColumnVector: diag (int K) const

 -- ColumnVector: row_min (void) const
 -- ColumnVector: row_min_loc (void) const

 -- ColumnVector: row_max (void) const
 -- ColumnVector: row_max_loc (void) const

 -- RowVector: column_min (void) const
 -- RowVector: column_min_loc (void) const

 -- RowVector: column_max (void) const
 -- RowVector: column_max_loc (void) const

 -- friend ostream&: operator << (ostream &OS, const Matrix &A)
 -- friend istream&: operator >> (istream &IS, Matrix &A)

 -- ColumnVector: (void)
 -- ColumnVector: (int N)
 -- ColumnVector: (int N, double VAL)
 -- ColumnVector: (const Array<double> &A)
 -- ColumnVector: (const ColumnVector &A)

 -- ColumnVector&: operator = (const ColumnVector &A)

 -- int: operator == (const ColumnVector &A) const
 -- int: operator != (const ColumnVector &A) const

 -- ColumnVector&: insert (const ColumnVector &A, int R)

 -- ColumnVector&: fill (double VAL)
 -- ColumnVector&: fill (double VAL, int r1, int r2)

 -- ColumnVector: stack (const ColumnVector &A) const

 -- RowVector: transpose (void) const

 -- ColumnVector: extract (int r1, int r2) const

 -- ColumnVector&: operator += (const ColumnVector &A)
 -- ColumnVector&: operator -= (const ColumnVector &A)

 -- friend ComplexColumnVector: operator + (const ColumnVector &A, const Complex &S)
 -- friend ComplexColumnVector: operator - (const ColumnVector &A, const Complex &S)
 -- friend ComplexColumnVector: operator * (const ColumnVector &A, const Complex &S)
 -- friend ComplexColumnVector: operator / (const ColumnVector &A, const Complex &S)

 -- friend ComplexColumnVector: operator + (const Complex &S, const ColumnVector &A)
 -- friend ComplexColumnVector: operator - (const Complex &S, const ColumnVector &A)
 -- friend ComplexColumnVector: operator * (const Complex &S, const ColumnVector &A)
 -- friend ComplexColumnVector: operator / (const Complex &S, const ColumnVector &A)

 -- friend Matrix: operator * (const ColumnVector &A, const RowVector &A)

 -- friend ComplexMatrix: operator * (const ColumnVector &A, const ComplexRowVector &B)

 -- friend ComplexColumnVector: operator + (const ComplexColumnVector &A, const ComplexColumnVector &B)

 -- friend ComplexColumnVector: operator - (const ComplexColumnVector &A, const ComplexColumnVector &B)

 -- friend ComplexColumnVector: product (const ComplexColumnVector &A, const ComplexColumnVector &B)

 -- friend ComplexColumnVector: quotient (const ComplexColumnVector &A, const ComplexColumnVector &B)

 -- friend ColumnVector: map (d_d_Mapper F, const ColumnVector &A)
 -- void: map (d_d_Mapper F)

 -- double: min (void) const
 -- double: max (void) const

 -- friend ostream&: operator << (ostream &OS, const ColumnVector &A)

 -- RowVector: (void)
 -- RowVector: (int N)
 -- RowVector: (int N, double VAL)
 -- RowVector: (const Array<double> &A)
 -- RowVector: (const RowVector &A)

 -- RowVector&: operator = (const RowVector &A)

 -- int: operator == (const RowVector &A) const
 -- int: operator != (const RowVector &A) const

 -- RowVector&: insert (const RowVector &A, int C)

 -- RowVector&: fill (double VAL)
 -- RowVector&: fill (double VAL, int c1, int c2)

 -- RowVector: append (const RowVector &A) const

 -- ColumnVector: transpose (void) const

 -- RowVector: extract (int c1, int c2) const

 -- RowVector&: operator += (const RowVector &A)
 -- RowVector&: operator -= (const RowVector &A)

 -- friend ComplexRowVector: operator + (const RowVector &A, const Complex &S)
 -- friend ComplexRowVector: operator - (const RowVector &A, const Complex &S)
 -- friend ComplexRowVector: operator * (const RowVector &A, const Complex &S)
 -- friend ComplexRowVector: operator / (const RowVector &A, const Complex &S)

 -- friend ComplexRowVector: operator + (const Complex &S, const RowVector &A)
 -- friend ComplexRowVector: operator - (const Complex &S, const RowVector &A)
 -- friend ComplexRowVector: operator * (const Complex &S, const RowVector &A)
 -- friend ComplexRowVector: operator / (const Complex &S, const RowVector &A)

 -- friend double: operator * (const RowVector &A, ColumnVector &B)

 -- friend Complex: operator * (const RowVector &A, const ComplexColumnVector &B)

 -- friend RowVector: operator * (const RowVector &A, const Matrix &B)

 -- friend ComplexRowVector: operator * (const RowVector &A, const ComplexMatrix &B)

 -- friend ComplexRowVector: operator + (const RowVector &A, const ComplexRowVector &B)
 -- friend ComplexRowVector: operator - (const RowVector &A, const ComplexRowVector &B)

 -- friend ComplexRowVector: product (const RowVector &A, const ComplexRowVector &B)
 -- friend ComplexRowVector: quotient (const RowVector &A, const ComplexRowVector &B)

 -- friend RowVector: map (d_d_Mapper F, const RowVector &A)
 -- void: map (d_d_Mapper F)

 -- double: min (void) const
 -- double: max (void) const

 -- friend ostream&: operator << (ostream &OS, const RowVector &A)

 -- DiagMatrix: (void)
 -- DiagMatrix: (int N)
 -- DiagMatrix: (int N, double VAL)
 -- DiagMatrix: (int R, int C)
 -- DiagMatrix: (int R, int C, double VAL)
 -- DiagMatrix: (const RowVector &A)
 -- DiagMatrix: (const ColumnVector &A)
 -- DiagMatrix: (const DiagArray<double> &A)
 -- DiagMatrix: (const DiagMatrix &A)

 -- DiagMatrix&: operator = (const DiagMatrix &A)

 -- int: operator == (const DiagMatrix &A) const
 -- int: operator != (const DiagMatrix &A) const

 -- DiagMatrix&: fill (double VAL)
 -- DiagMatrix&: fill (double VAL, int BEG, int END)
 -- DiagMatrix&: fill (const ColumnVector &A)
 -- DiagMatrix&: fill (const RowVector &A)
 -- DiagMatrix&: fill (const ColumnVector &A, int BEG)
 -- DiagMatrix&: fill (const RowVector &A, int BEG)

 -- DiagMatrix: transpose (void) const

 -- Matrix: extract (int r1, int c1, int r2, int c2) const

 -- RowVector: row (int I) const
 -- RowVector: row (char *s) const

 -- ColumnVector: column (int I) const
 -- ColumnVector: column (char *s) const

 -- DiagMatrix: inverse (void) const
 -- DiagMatrix: inverse (int &INFO) const

 -- DiagMatrix&: operator += (const DiagMatrix &A)
 -- DiagMatrix&: operator -= (const DiagMatrix &A)

 -- friend Matrix: operator + (const DiagMatrix &A, double S)
 -- friend Matrix: operator - (const DiagMatrix &A, double S)

 -- friend ComplexMatrix: operator + (const DiagMatrix &A, const Complex &S)
 -- friend ComplexMatrix: operator - (const DiagMatrix &A, const Complex &S)

 -- friend ComplexDiagMatrix: operator * (const DiagMatrix &A, const Complex &S)
 -- friend ComplexDiagMatrix: operator / (const DiagMatrix &A, const Complex &S)

 -- friend Matrix: operator + (double S, const DiagMatrix &A)
 -- friend Matrix: operator - (double S, const DiagMatrix &A)

 -- friend ComplexMatrix: operator + (const Complex &S, const DiagMatrix &A)
 -- friend ComplexMatrix: operator - (const Complex &S, const DiagMatrix &A)

 -- friend ComplexDiagMatrix: operator * (const Complex &S, const DiagMatrix &A)

 -- friend ColumnVector: operator * (const DiagMatrix &A, const ColumnVector &B)

 -- friend ComplexColumnVector: operator * (const DiagMatrix &A, const ComplexColumnVector &B)

 -- friend ComplexDiagMatrix: operator + (const DiagMatrix &A, const ComplexDiagMatrix &B)
 -- friend ComplexDiagMatrix: operator - (const DiagMatrix &A, const ComplexDiagMatrix &B)

 -- friend ComplexDiagMatrix: product (const DiagMatrix &A, const ComplexDiagMatrix &B)

 -- friend Matrix: operator + (const DiagMatrix &A, const Matrix &B)
 -- friend Matrix: operator - (const DiagMatrix &A, const Matrix &B)
 -- friend Matrix: operator * (const DiagMatrix &A, const Matrix &B)

 -- friend ComplexMatrix: operator + (const DiagMatrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: operator - (const DiagMatrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: operator * (const DiagMatrix &A, const ComplexMatrix &B)

 -- ColumnVector: diag (void) const
 -- ColumnVector: diag (int K) const

 -- friend ostream&: operator << (ostream &OS, const DiagMatrix &A)

 -- ComplexMatrix: (void)
 -- ComplexMatrix: (int R, int C)
 -- ComplexMatrix: (int R, int C, const Complex &VAL)
 -- ComplexMatrix: (const Matrix &A)
 -- ComplexMatrix: (const Array2<Complex> &A)
 -- ComplexMatrix: (const ComplexMatrix &A)
 -- ComplexMatrix: (const DiagMatrix &A)
 -- ComplexMatrix: (const DiagArray<Complex> &A)
 -- ComplexMatrix: (const ComplexDiagMatrix &A)

 -- ComplexMatrix&: operator = (const ComplexMatrix &A)

 -- int: operator == (const ComplexMatrix &A) const
 -- int: operator != (const ComplexMatrix &A) const

 -- ComplexMatrix&: insert (const Matrix &A, int R, int C)
 -- ComplexMatrix&: insert (const RowVector &A, int R, int C)
 -- ComplexMatrix&: insert (const ColumnVector &A, int R, int C)
 -- ComplexMatrix&: insert (const DiagMatrix &A, int R, int C)

 -- ComplexMatrix&: insert (const ComplexMatrix &A, int R, int C)
 -- ComplexMatrix&: insert (const ComplexRowVector &A, int R, int C)
 -- ComplexMatrix&: insert (const ComplexColumnVector &A, int R, int C)
 -- ComplexMatrix&: insert (const ComplexDiagMatrix &A, int R, int C)

 -- ComplexMatrix&: fill (double VAL)
 -- ComplexMatrix&: fill (const Complex &VAL)
 -- ComplexMatrix&: fill (double VAL, int r1, int c1, int r2, int c2)
 -- ComplexMatrix&: fill (const Complex &VAL, int r1, int c1, int r2, int c2)

 -- ComplexMatrix: append (const Matrix &A) const
 -- ComplexMatrix: append (const RowVector &A) const
 -- ComplexMatrix: append (const ColumnVector &A) const
 -- ComplexMatrix: append (const DiagMatrix &A) const

 -- ComplexMatrix: append (const ComplexMatrix &A) const
 -- ComplexMatrix: append (const ComplexRowVector &A) const
 -- ComplexMatrix: append (const ComplexColumnVector &A) const
 -- ComplexMatrix: append (const ComplexDiagMatrix &A) const

 -- ComplexMatrix: stack (const Matrix &A) const
 -- ComplexMatrix: stack (const RowVector &A) const
 -- ComplexMatrix: stack (const ColumnVector &A) const
 -- ComplexMatrix: stack (const DiagMatrix &A) const

 -- ComplexMatrix: stack (const ComplexMatrix &A) const
 -- ComplexMatrix: stack (const ComplexRowVector &A) const
 -- ComplexMatrix: stack (const ComplexColumnVector &A) const
 -- ComplexMatrix: stack (const ComplexDiagMatrix &A) const

 -- ComplexMatrix: transpose (void) const

 -- friend Matrix: real (const ComplexMatrix &A)
 -- friend Matrix: imag (const ComplexMatrix &A)
 -- friend ComplexMatrix: conj (const ComplexMatrix &A)

 -- ComplexMatrix: extract (int r1, int c1, int r2, int c2) const

 -- ComplexRowVector: row (int I) const
 -- ComplexRowVector: row (char *s) const

 -- ComplexColumnVector: column (int I) const
 -- ComplexColumnVector: column (char *s) const

 -- ComplexMatrix: inverse (void) const
 -- ComplexMatrix: inverse (int &INFO) const
 -- ComplexMatrix: inverse (int &INFO, double &RCOND) const

 -- ComplexMatrix: fourier (void) const
 -- ComplexMatrix: ifourier (void) const

 -- ComplexDET: determinant (void) const
 -- ComplexDET: determinant (int &INFO) const
 -- ComplexDET: determinant (int &INFO, double &RCOND) const

 -- ComplexMatrix: solve (const Matrix &B) const
 -- ComplexMatrix: solve (const Matrix &B, int &INFO) const
 -- ComplexMatrix: solve (const Matrix &B, int &INFO, double &RCOND) const

 -- ComplexMatrix: solve (const ComplexMatrix &B) const
 -- ComplexMatrix: solve (const ComplexMatrix &B, int &INFO) const
 -- ComplexMatrix: solve (const ComplexMatrix &B, int &INFO, double &RCOND) const

 -- ComplexColumnVector: solve (const ComplexColumnVector &B) const
 -- ComplexColumnVector: solve (const ComplexColumnVector &B, int &INFO) const
 -- ComplexColumnVector: solve (const ComplexColumnVector &B, int &INFO, double &RCOND) const

 -- ComplexMatrix: lssolve (const ComplexMatrix &B) const
 -- ComplexMatrix: lssolve (const ComplexMatrix &B, int &INFO) const
 -- ComplexMatrix: lssolve (const ComplexMatrix &B, int &INFO, int &RANK) const

 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B) const
 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B, int &INFO) const
 -- ComplexColumnVector: lssolve (const ComplexColumnVector &B, int &INFO, int &RANK) const

 -- ComplexMatrix&: operator += (const DiagMatrix &A)
 -- ComplexMatrix&: operator -= (const DiagMatrix &A)

 -- ComplexMatrix&: operator += (const ComplexDiagMatrix &A)
 -- ComplexMatrix&: operator -= (const ComplexDiagMatrix &A)

 -- ComplexMatrix&: operator += (const Matrix &A)
 -- ComplexMatrix&: operator -= (const Matrix &A)

 -- ComplexMatrix&: operator += (const ComplexMatrix &A)
 -- ComplexMatrix&: operator -= (const ComplexMatrix &A)

 -- Matrix: operator ! (void) const

 -- friend ComplexMatrix: operator + (const ComplexMatrix &A, double S)
 -- friend ComplexMatrix: operator - (const ComplexMatrix &A, double S)
 -- friend ComplexMatrix: operator * (const ComplexMatrix &A, double S)
 -- friend ComplexMatrix: operator / (const ComplexMatrix &A, double S)

 -- friend ComplexMatrix: operator + (double S, const ComplexMatrix &A)
 -- friend ComplexMatrix: operator - (double S, const ComplexMatrix &A)
 -- friend ComplexMatrix: operator * (double S, const ComplexMatrix &A)
 -- friend ComplexMatrix: operator / (double S, const ComplexMatrix &A)

 -- friend ComplexColumnVector: operator * (const ComplexMatrix &A, const ColumnVector &B)

 -- friend ComplexColumnVector: operator * (const ComplexMatrix &A, const ComplexColumnVector &B)

 -- friend ComplexMatrix: operator + (const ComplexMatrix &A, const DiagMatrix &B)
 -- friend ComplexMatrix: operator - (const ComplexMatrix &A, const DiagMatrix &B)
 -- friend ComplexMatrix: operator * (const ComplexMatrix &A, const DiagMatrix &B)

 -- friend ComplexMatrix: operator + (const ComplexMatrix &A, const ComplexDiagMatrix &B)
 -- friend ComplexMatrix: operator - (const ComplexMatrix &A, const ComplexDiagMatrix &B)
 -- friend ComplexMatrix: operator * (const ComplexMatrix &A, const ComplexDiagMatrix &B)

 -- friend ComplexMatrix: operator + (const ComplexMatrix &A, const Matrix &B)
 -- friend ComplexMatrix: operator - (const ComplexMatrix &A, const Matrix &B)

 -- friend ComplexMatrix: operator * (const ComplexMatrix &A, const Matrix &B)
 -- friend ComplexMatrix: operator * (const ComplexMatrix &A, const ComplexMatrix &B)

 -- friend ComplexMatrix: product (const ComplexMatrix &A, const Matrix &B)
 -- friend ComplexMatrix: quotient (const ComplexMatrix &A, const Matrix &B)

 -- friend ComplexMatrix: map (c_c_Mapper F, const ComplexMatrix &A)
 -- friend Matrix: map (d_c_Mapper F, const ComplexMatrix &A)
 -- void: map (c_c_Mapper F)

 -- Matrix: all (void) const
 -- Matrix: any (void) const

 -- ComplexMatrix: cumprod (void) const
 -- ComplexMatrix: cumsum (void) const
 -- ComplexMatrix: prod (void) const
 -- ComplexMatrix: sum (void) const
 -- ComplexMatrix: sumsq (void) const

 -- ComplexColumnVector: diag (void) const
 -- ComplexColumnVector: diag (int K) const

 -- ComplexColumnVector: row_min (void) const
 -- ComplexColumnVector: row_min_loc (void) const

 -- ComplexColumnVector: row_max (void) const
 -- ComplexColumnVector: row_max_loc (void) const

 -- ComplexRowVector: column_min (void) const
 -- ComplexRowVector: column_min_loc (void) const

 -- ComplexRowVector: column_max (void) const
 -- ComplexRowVector: column_max_loc (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexMatrix &A)
 -- friend istream&: operator >> (istream &IS, ComplexMatrix &A)

 -- ComplexColumnVector: (void)
 -- ComplexColumnVector: (int N)
 -- ComplexColumnVector: (int N, const Complex &VAL)
 -- ComplexColumnVector: (const ColumnVector &A)
 -- ComplexColumnVector: (const Array<Complex> &A)
 -- ComplexColumnVector: (const ComplexColumnVector &A)

 -- ComplexColumnVector&: operator = (const ComplexColumnVector &A)

 -- int: operator == (const ComplexColumnVector &A) const
 -- int: operator != (const ComplexColumnVector &A) const

 -- ComplexColumnVector&: insert (const ColumnVector &A, int R)
 -- ComplexColumnVector&: insert (const ComplexColumnVector &A, int R)

 -- ComplexColumnVector&: fill (double VAL)
 -- ComplexColumnVector&: fill (const Complex &VAL)
 -- ComplexColumnVector&: fill (double VAL, int r1, int r2)
 -- ComplexColumnVector&: fill (const Complex &VAL, int r1, int r2)

 -- ComplexColumnVector: stack (const ColumnVector &A) const
 -- ComplexColumnVector: stack (const ComplexColumnVector &A) const

 -- ComplexRowVector: transpose (void) const

 -- friend ColumnVector: real (const ComplexColumnVector &A)
 -- friend ColumnVector: imag (const ComplexColumnVector &A)
 -- friend ComplexColumnVector: conj (const ComplexColumnVector &A)

 -- ComplexColumnVector: extract (int r1, int r2) const

 -- ComplexColumnVector&: operator += (const ColumnVector &A)
 -- ComplexColumnVector&: operator -= (const ColumnVector &A)

 -- ComplexColumnVector&: operator += (const ComplexColumnVector &A)
 -- ComplexColumnVector&: operator -= (const ComplexColumnVector &A)

 -- friend ComplexColumnVector: operator + (const ComplexColumnVector &A, double S)
 -- friend ComplexColumnVector: operator - (const ComplexColumnVector &A, double S)
 -- friend ComplexColumnVector: operator * (const ComplexColumnVector &A, double S)
 -- friend ComplexColumnVector: operator / (const ComplexColumnVector &A, double S)

 -- friend ComplexColumnVector: operator + (double S, const ComplexColumnVector &A)
 -- friend ComplexColumnVector: operator - (double S, const ComplexColumnVector &A)
 -- friend ComplexColumnVector: operator * (double S, const ComplexColumnVector &A)
 -- friend ComplexColumnVector: operator / (double S, const ComplexColumnVector &A)

 -- friend ComplexMatrix: operator * (const ComplexColumnVector &A, const ComplexRowVector &B)

 -- friend ComplexColumnVector: operator + (const ComplexColumnVector &A, const ColumnVector &B)
 -- friend ComplexColumnVector: operator - (const ComplexColumnVector &A, const ColumnVector &B)

 -- friend ComplexColumnVector: product (const ComplexColumnVector &A, const ColumnVector &B)
 -- friend ComplexColumnVector: quotient (const ComplexColumnVector &A, const ColumnVector &B)

 -- friend ComplexColumnVector: map (c_c_Mapper F, const ComplexColumnVector &A)
 -- friend ColumnVector: map (d_c_Mapper F, const ComplexColumnVector &A)
 -- void: map (c_c_Mapper F)

 -- Complex: min (void) const
 -- Complex: max (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexColumnVector &A)

 -- ComplexRowVector: (void)
 -- ComplexRowVector: (int N)
 -- ComplexRowVector: (int N, const Complex &VAL)
 -- ComplexRowVector: (const RowVector &A)
 -- ComplexRowVector: (const Array<Complex> &A)
 -- ComplexRowVector: (const ComplexRowVector &A)

 -- ComplexRowVector&: operator = (const ComplexRowVector &A)

 -- int: operator == (const ComplexRowVector &A) const
 -- int: operator != (const ComplexRowVector &A) const

 -- ComplexRowVector&: insert (const RowVector &A, int C)
 -- ComplexRowVector&: insert (const ComplexRowVector &A, int C)

 -- ComplexRowVector&: fill (double VAL)
 -- ComplexRowVector&: fill (const Complex &VAL)
 -- ComplexRowVector&: fill (double VAL, int c1, int c2)
 -- ComplexRowVector&: fill (const Complex &VAL, int c1, int c2)

 -- ComplexRowVector: append (const RowVector &A) const
 -- ComplexRowVector: append (const ComplexRowVector &A) const

 -- ComplexColumnVector: transpose (void) const

 -- friend RowVector: real (const ComplexRowVector &A)
 -- friend RowVector: imag (const ComplexRowVector &A)
 -- friend ComplexRowVector: conj (const ComplexRowVector &A)

 -- ComplexRowVector: extract (int c1, int c2) const

 -- ComplexRowVector&: operator += (const RowVector &A)
 -- ComplexRowVector&: operator -= (const RowVector &A)

 -- ComplexRowVector&: operator += (const ComplexRowVector &A)
 -- ComplexRowVector&: operator -= (const ComplexRowVector &A)

 -- friend ComplexRowVector: operator + (const ComplexRowVector &A, double S)
 -- friend ComplexRowVector: operator - (const ComplexRowVector &A, double S)
 -- friend ComplexRowVector: operator * (const ComplexRowVector &A, double S)
 -- friend ComplexRowVector: operator / (const ComplexRowVector &A, double S)

 -- friend ComplexRowVector: operator + (double S, const ComplexRowVector &A)
 -- friend ComplexRowVector: operator - (double S, const ComplexRowVector &A)
 -- friend ComplexRowVector: operator * (double S, const ComplexRowVector &A)
 -- friend ComplexRowVector: operator / (double S, const ComplexRowVector &A)

 -- friend Complex: operator * (const ComplexRowVector &A, const ColumnVector &B)

 -- friend Complex: operator * (const ComplexRowVector &A, const ComplexColumnVector &B)

 -- friend ComplexRowVector: operator * (const ComplexRowVector &A, const ComplexMatrix &B)

 -- friend ComplexRowVector: operator + (const ComplexRowVector &A, const RowVector &B)
 -- friend ComplexRowVector: operator - (const ComplexRowVector &A, const RowVector &B)

 -- friend ComplexRowVector: product (const ComplexRowVector &A, const RowVector &B)
 -- friend ComplexRowVector: quotient (const ComplexRowVector &A, const RowVector &B)

 -- friend ComplexRowVector: map (c_c_Mapper F, const ComplexRowVector &A)
 -- friend RowVector: map (d_c_Mapper F, const ComplexRowVector &A)
 -- void: map (c_c_Mapper F)

 -- Complex: min (void) const
 -- Complex: max (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexRowVector &A)

 -- ComplexDiagMatrix: (void)
 -- ComplexDiagMatrix: (int N)
 -- ComplexDiagMatrix: (int N, const Complex &VAL)
 -- ComplexDiagMatrix: (int R, int C)
 -- ComplexDiagMatrix: (int R, int C, const Complex &VAL)
 -- ComplexDiagMatrix: (const RowVector &A)
 -- ComplexDiagMatrix: (const ComplexRowVector &A)
 -- ComplexDiagMatrix: (const ColumnVector &A)
 -- ComplexDiagMatrix: (const ComplexColumnVector &A)
 -- ComplexDiagMatrix: (const DiagMatrix &A)
 -- ComplexDiagMatrix: (const DiagArray<Complex> &A)
 -- ComplexDiagMatrix: (const ComplexDiagMatrix &A)

 -- ComplexDiagMatrix&: operator = (const ComplexDiagMatrix &A)

 -- int: operator == (const ComplexDiagMatrix &A) const
 -- int: operator != (const ComplexDiagMatrix &A) const

 -- ComplexDiagMatrix&: fill (double VAL)
 -- ComplexDiagMatrix&: fill (const Complex &VAL)
 -- ComplexDiagMatrix&: fill (double VAL, int BEG, int END)
 -- ComplexDiagMatrix&: fill (const Complex &VAL, int BEG, int END)
 -- ComplexDiagMatrix&: fill (const ColumnVector &A)
 -- ComplexDiagMatrix&: fill (const ComplexColumnVector &A)
 -- ComplexDiagMatrix&: fill (const RowVector &A)
 -- ComplexDiagMatrix&: fill (const ComplexRowVector &A)
 -- ComplexDiagMatrix&: fill (const ColumnVector &A, int BEG)
 -- ComplexDiagMatrix&: fill (const ComplexColumnVector &A, int BEG)
 -- ComplexDiagMatrix&: fill (const RowVector &A, int BEG)
 -- ComplexDiagMatrix&: fill (const ComplexRowVector &A, int BEG)

 -- ComplexDiagMatrix: transpose (void) const

 -- friend DiagMatrix: real (const ComplexDiagMatrix &A)
 -- friend DiagMatrix: imag (const ComplexDiagMatrix &A)
 -- friend ComplexDiagMatrix: conj (const ComplexDiagMatrix &A)

 -- ComplexMatrix: extract (int r1, int c1, int r2, int c2) const

 -- ComplexRowVector: row (int I) const
 -- ComplexRowVector: row (char *s) const

 -- ComplexColumnVector: column (int I) const
 -- ComplexColumnVector: column (char *s) const

 -- ComplexDiagMatrix: inverse (int &INFO) const
 -- ComplexDiagMatrix: inverse (void) const

 -- ComplexDiagMatrix&: operator += (const DiagMatrix &A)
 -- ComplexDiagMatrix&: operator -= (const DiagMatrix &A)

 -- ComplexDiagMatrix&: operator += (const ComplexDiagMatrix &A)
 -- ComplexDiagMatrix&: operator -= (const ComplexDiagMatrix &A)

 -- friend ComplexMatrix: operator + (const ComplexDiagMatrix &A, double S)
 -- friend ComplexMatrix: operator - (const ComplexDiagMatrix &A, double S)

 -- friend ComplexMatrix: operator + (const ComplexDiagMatrix &A, const Complex &S)
 -- friend ComplexMatrix: operator - (const ComplexDiagMatrix &A, const Complex &S)

 -- friend ComplexDiagMatrix: operator * (const ComplexDiagMatrix &A, double S)
 -- friend ComplexDiagMatrix: operator / (const ComplexDiagMatrix &A, double S)

 -- friend ComplexMatrix: operator + (double S, const ComplexDiagMatrix &A)
 -- friend ComplexMatrix: operator - (double S, const ComplexDiagMatrix &A)

 -- friend ComplexMatrix: operator + (const Complex &S, const ComplexDiagMatrix &A)
 -- friend ComplexMatrix: operator - (const Complex &S, const ComplexDiagMatrix &A)

 -- friend ComplexDiagMatrix: operator * (double S, const ComplexDiagMatrix &A)

 -- friend ComplexColumnVector: operator * (const ComplexDiagMatrix &A, const ColumnVector &B)

 -- friend ComplexColumnVector: operator * (const ComplexDiagMatrix &A, const ComplexColumnVector &B)

 -- friend ComplexDiagMatrix: operator + (const ComplexDiagMatrix &A, const DiagMatrix &B)
 -- friend ComplexDiagMatrix: operator - (const ComplexDiagMatrix &A, const DiagMatrix &B)

 -- friend ComplexDiagMatrix: product (const ComplexDiagMatrix &A, const DiagMatrix &B)

 -- friend ComplexMatrix: operator + (const ComplexDiagMatrix &A, const Matrix &B)
 -- friend ComplexMatrix: operator - (const ComplexDiagMatrix &A, const Matrix &B)
 -- friend ComplexMatrix: operator * (const ComplexDiagMatrix &A, const Matrix &B)

 -- friend ComplexMatrix: operator + (const ComplexDiagMatrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: operator - (const ComplexDiagMatrix &A, const ComplexMatrix &B)
 -- friend ComplexMatrix: operator * (const ComplexDiagMatrix &A, const ComplexMatrix &B)

 -- ComplexColumnVector: diag (void) const
 -- ComplexColumnVector: diag (int K) const

 -- friend ostream&: operator << (ostream &OS, const ComplexDiagMatrix &A)

Matrix Factorizations
*********************

 -- AEPBALANCE: (void)
 -- AEPBALANCE: (const Matrix &A, const char *BALANCE_JOB)
 -- AEPBALANCE: (const AEPBALANCE &A)

 -- AEPBALANCE&: operator = (const AEPBALANCE &A)

 -- Matrix: balanced_matrix (void) const
 -- Matrix: balancing_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const AEPBALANCE &A)

 -- ComplexAEPBALANCE: (void)
 -- ComplexAEPBALANCE: (const ComplexMatrix &A, const char *BALANCE_JOB)
 -- ComplexAEPBALANCE: (const ComplexAEPBALANCE &A)

 -- ComplexAEPBALANCE&: operator = (const ComplexAEPBALANCE &A)

 -- ComplexMatrix: balanced_matrix (void) const
 -- ComplexMatrix: balancing_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexAEPBALANCE &A)

 -- DET: (void)
 -- DET: (const DET &A)

 -- DET&: operator = (const DET &A)

 -- int: value_will_overflow (void) const
 -- int: value_will_underflow (void) const

 -- double: coefficient (void) const
 -- int: exponent (void) const
 -- double: value (void) const

 -- friend ostream&: operator << (ostream &OS, const DET &A)

 -- ComplexDET: (void)
 -- ComplexDET: (const ComplexDET &A)

 -- ComplexDET&: operator = (const ComplexDET &A)

 -- int: value_will_overflow (void) const
 -- int: value_will_underflow (void) const

 -- Complex: coefficient (void) const
 -- int: exponent (void) const
 -- Complex: value (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexDET &A)

 -- GEPBALANCE: (void)
 -- GEPBALANCE: (const Matrix &A, const Matrix &, const char *BALANCE_JOB)
 -- GEPBALANCE: (const GEPBALANCE &A)

 -- GEPBALANCE&: operator = (const GEPBALANCE &A)

 -- Matrix: balanced_a_matrix (void) const
 -- Matrix: balanced_b_matrix (void) const
 -- Matrix: left_balancing_matrix (void) const
 -- Matrix: right_balancing_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const GEPBALANCE &A)

 -- CHOL: (void)
 -- CHOL: (const Matrix &A)
 -- CHOL: (const Matrix &A, int &INFO)
 -- CHOL: (const CHOL &A)

 -- CHOL&: operator = (const CHOL &A)

 -- Matrix: chol_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const CHOL &A)

 -- ComplexCHOL: (void)
 -- ComplexCHOL: (const ComplexMatrix &A)
 -- ComplexCHOL: (const ComplexMatrix &A, int &INFO)
 -- ComplexCHOL: (const ComplexCHOL &A)

 -- ComplexCHOL&: operator = (const ComplexCHOL &A)

 -- ComplexMatrix: chol_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexCHOL &A)

 -- HESS: (void)
 -- HESS: (const Matrix &A)
 -- HESS: (const Matrix&a, int &INFO)
 -- HESS: (const HESS &A)

 -- HESS&: operator = (const HESS &A)

 -- Matrix: hess_matrix (void) const
 -- Matrix: unitary_hess_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const HESS &A)

 -- ComplexHESS: (void)
 -- ComplexHESS: (const ComplexMatrix &A)
 -- ComplexHESS: (const ComplexMatrix &A, int &INFO)
 -- ComplexHESS: (const ComplexHESS &A)

 -- ComplexHESS&: operator = (const ComplexHESS &A)

 -- ComplexMatrix: hess_matrix (void) const
 -- ComplexMatrix: unitary_hess_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexHESS &A)

 -- SCHUR: (void)
 -- SCHUR: (const Matrix &A, const char *ORD)
 -- SCHUR: (const Matrix &A, const char *ORD, int &INFO)
 -- SCHUR: (const SCHUR &A, const char *ORD)

 -- SCHUR&: operator = (const SCHUR &A)

 -- Matrix: schur_matrix (void) const
 -- Matrix: unitary_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const SCHUR &A)

 -- ComplexSCHUR: (void)
 -- ComplexSCHUR: (const ComplexMatrix &A, const char *ORD)
 -- ComplexSCHUR: (const ComplexMatrix &A, const char *ORD, int &INFO)
 -- ComplexSCHUR: (const ComplexSCHUR &A, const char *ORD)

 -- ComplexSCHUR&: operator = (const ComplexSCHUR &A)

 -- ComplexMatrix: schur_matrix (void) const
 -- ComplexMatrix: unitary_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexSCHUR &A)

 -- SVD: (void)
 -- SVD: (const Matrix &A)
 -- SVD: (const Matrix &A, int &INFO)
 -- SVD: (const SVD &A)

 -- SVD&: operator = (const SVD &A)

 -- DiagMatrix: singular_values (void) const
 -- Matrix: left_singular_matrix (void) const
 -- Matrix: right_singular_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const SVD &A)

 -- ComplexSVD: (void)
 -- ComplexSVD: (const ComplexMatrix &A)
 -- ComplexSVD: (const ComplexMatrix &A, int &INFO)
 -- ComplexSVD: (const ComplexSVD &A)

 -- ComplexSVD&: operator = (const ComplexSVD &A)

 -- DiagMatrix: singular_values (void) const
 -- ComplexMatrix: left_singular_matrix (void) const
 -- ComplexMatrix: right_singular_matrix (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexSVD &A)

 -- EIG: (void)
 -- EIG: (const Matrix &A)
 -- EIG: (const Matrix &A, int &INFO)
 -- EIG: (const ComplexMatrix &A)
 -- EIG: (const ComplexMatrix &A, int &INFO)
 -- EIG: (const EIG &A)

 -- EIG&: operator = (const EIG &A)

 -- ComplexColumnVector: eigenvalues (void) const

 -- ComplexMatrix: eigenvectors (void) const

 -- friend ostream&: operator << (ostream &OS, const EIG &A)

 -- LU: (void)
 -- LU: (const Matrix &A)
 -- LU: (const LU &A)

 -- LU&: operator = (const LU &A)

 -- Matrix: L (void) const
 -- Matrix: U (void) const
 -- Matrix: P (void) const

 -- friend ostream&: operator << (ostream &OS, const LU &A)

 -- ComplexLU: (void)
 -- ComplexLU: (const ComplexMatrix &A)
 -- ComplexLU: (const ComplexLU &A)

 -- ComplexLU&: operator = (const ComplexLU &A)

 -- ComplexMatrix: L (void) const
 -- ComplexMatrix: U (void) const
 -- Matrix: P (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexLU &A)

 -- QR: (void)
 -- QR: (const Matrix &A)
 -- QR: (const QR &A)

 -- QR&: operator = (const QR &A)

 -- Matrix: Q (void) const
 -- Matrix: R (void) const

 -- friend ostream&: operator << (ostream &OS, const QR &A)

 -- ComplexQR: (void)
 -- ComplexQR: (const ComplexMatrix &A)
 -- ComplexQR: (const ComplexQR &A)

 -- ComplexQR&: operator = (const ComplexQR &A)

 -- ComplexMatrix: Q (void) const
 -- ComplexMatrix: R (void) const

 -- friend ostream&: operator << (ostream &OS, const ComplexQR &A)

Nonlinear Functions
*******************

 -- NLFunc: (void)
 -- NLFunc: (const NONLINEAR_FCN)
 -- NLFunc: (const NONLINEAR_FCN, const JACOBIAN_FCN)
 -- NLFunc: (const NLFunc &A)

 -- NLFunc&: operator = (const NLFunc &A)

 -- nonlinear_fcn: function (void) const;

 -- NLFunc&: set_function (const nonlinear_fcn F)

 -- jacobian_fcn: jacobian_function (void) const;

 -- NLFunc&: set_jacobian_function (const jacobian_fcn J)

Objective Functions
*******************

 -- Objective: (void)
 -- Objective: (const OBJECTIVE_FCN)
 -- Objective: (const OBJECTIVE_FCN, const GRADIENT_FCN)
 -- Objective: (const Objective &A)

 -- Objective&: operator = (const Objective &A)

 -- objective_fcn: objective_function (void) const;

 -- Objective&: set_objective_function (const OBJECTIVE_FCN)

 -- gradient_fcn: gradient_function (void) const;

 -- Objective&: set_gradient_function (const GRADIENT_FCN)

Bounds
******

 -- Bounds: (void)
 -- Bounds: (int N)
 -- Bounds: (const ColumnVector LB, const ColumnVector UB)
 -- Bounds: (const Bounds &A)

 -- Bounds&: operator = (const Bounds &A)

 -- Bounds&: resize (int N)

 -- double: lower_bound (int INDEX) const;
 -- double: upper_bound (int INDEX) const;

 -- ColumnVector: lower_bounds (void) const;
 -- ColumnVector: upper_bounds (void) const;

 -- int: size (void) const;

 -- Bounds&: set_bound (int INDEX, double LOW, double HIGH)

 -- Bounds&: set_bounds (double LOW, double HIGH)
 -- Bounds&: set_bounds (const ColumnVector LB, const ColumnVector UB)

 -- Bounds&: set_lower_bound (int INDEX, double LOW)
 -- Bounds&: set_upper_bound (int INDEX, double HIGH)

 -- Bounds&: set_lower_bounds (double LOW)
 -- Bounds&: set_upper_bounds (double HIGH)

 -- Bounds&: set_lower_bounds (const ColumnVector LB)
 -- Bounds&: set_upper_bounds (const ColumnVector UB)

 -- friend ostream&: operator << (ostream &OS, const Bounds &B)

Linear Constraints
******************

 -- LinConst: (void)
 -- LinConst: (int NCLIN, int NX)
 -- LinConst: (int NCLIN_EQ, int NCLIN_INEQ, int NX)
 -- LinConst: (const ColumnVector &LB, const Matrix &A, const ColumnVector &UB)
 -- LinConst: (const Matrix &A_EQ, const ColumnVector &B_EQ, const Matrix &A_INEQ, const ColumnVector &B_INEQ)
 -- LinConst: (const LinConst &A)

 -- LinConst&: operator = (const LinConst &A)

 -- LinConst&: resize (int NCLIN, int N)

 -- Matrix: constraint_matrix (void) const;

 -- LinConst&: set_constraint_matrix (const Matrix &A)

 -- Matrix: eq_constraint_matrix (void) const;
 -- Matrix: ineq_constraint_matrix (void) const;

 -- ColumnVector: eq_constraint_vector (void) const;
 -- ColumnVector: ineq_constraint_vector (void) const;

 -- friend ostream&: operator << (ostream &OS, const LinConst &B)

Nonlinear Constraints
*********************

 -- NLConst: (void)
 -- NLConst: (int N)
 -- NLConst: (const ColumnVector LB, const NLFunc F, const ColumnVector UB)
 -- NLConst: (const NLConst &A)

 -- NLConst&: operator = (const NLConst &A)

Nonlinear Equations
*******************

 -- NLEqn_options: (void)
 -- NLEqn_options: (const NLEqn_options &OPT)

 -- NLEqn_options&: operator = (const NLEqn_options &OPT)

 -- void: init (void)

 -- void: copy (const NLEqn_options &OPT)

 -- void: set_default_options (void)

 -- void: set_tolerance (double VAL)

 -- double: tolerance (void)

 -- NLEqn: (void)
 -- NLEqn: (const ColumnVector&, const NLFUNC)
 -- NLEqn: (const NLEqn &A)

 -- NLEqn&: operator = (const NLEqn &A)

 -- void: resize (int N)

 -- void: set_states (const ColumnVector &X)

 -- ColumnVector: states (void) const

 -- int: size (void) const

 -- ColumnVector: solve (void)
 -- ColumnVector: solve (const ColumnVector &X)

 -- ColumnVector: solve (int &INFO)
     deftypefnx ColumnVector solve (const ColumnVector &X, int &INFO)

Ordinary Differential Equations
*******************************

 -- ODE_options: (void)
 -- ODE_options: (const ODE_options &OPT)

 -- ODE_options&: operator = (const ODE_options &OPT)

 -- void: init (void)

 -- void: copy (const ODE_options &OPT)

 -- void: set_default_options (void)

 -- void: set_absolute_tolerance (double VAL)

 -- void: set_initial_step_size (double VAL)

 -- void: set_maximum_step_size (double VAL)

 -- void: set_minimum_step_size (double VAL)

 -- void: set_relative_tolerance (double VAL)

 -- double: absolute_tolerance (void)
 -- double: initial_step_size (void)
 -- double: maximum_step_size (void)
 -- double: minimum_step_size (void)
 -- double: relative_tolerance (void)

 -- ODE: (void)
 -- ODE: (int N)
 -- ODE: (const ColumnVector &STATE, double TIME, const ODEFunc &F)

 -- virtual int: size (void) const

 -- virtual ColumnVector: state (void) const

 -- virtual double: time (void) const

 -- virtual void: force_restart (void)

 -- virtual void: initialize (const ColumnVector &X, double T)

 -- virtual void: set_stop_time (double T)

 -- virtual void: clear_stop_time (void)

 -- virtual ColumnVector: integrate (double T)

 -- void: integrate (int NSTEPS, double TSTEP, ostream &S)

 -- Matrix: integrate (const ColumnVector &TOUT)
 -- Matrix: integrate (const ColumnVector &TOUT, const ColumnVector &TCRIT)

Differential Algebraic Equations
********************************

 -- DAE: (void)
 -- DAE: (int N)
 -- DAE: (const ColumnVector &X, double TIME, DAEFunc &F)
 -- DAE: (const ColumnVector &X, ColumnVector &XDOT, double TIME, DAEFunc &F)

 -- ColumnVector: deriv (void)

 -- virtual void: initialize (const ColumnVector &X, double T)
 -- virtual void: initialize (const ColumnVector &X, ColumnVector &XDOT, double T)

 -- ColumnVector: integrate (double T)

 -- Matrix: integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT)
 -- Matrix: integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT, const ColumnVector &TCRIT)

Quadrature
**********

 -- Quad: (integrand_fcn FCN)
 -- Quad: (integrand_fcn FCN, double ABS, double REL)

 -- virtual double: integrate (void)
 -- virtual double: integrate (int &IER)
 -- virtual double: integrate (int &IER, int &NEVAL)
 -- virtual double: integrate (int &IER, int &NEVAL, double &ABSERR) = 0

 -- Quad_options: (void)
 -- Quad_options: (const Quad_options &OPT)

 -- Quad_options&: operator = (const Quad_options &OPT)

 -- void: init (void)

 -- void: copy (const Quad_options &OPT)

 -- void: set_default_options (void)

 -- void: set_absolute_tolerance (double VAL)

 -- void: set_relative_tolerance (double VAL)

 -- double: absolute_tolerance (void)
 -- double: relative_tolerance (void)

 -- DefQuad: (integrand_fcn FCN)
 -- DefQuad: (integrand_fcn FCN, double LL, double UL)
 -- DefQuad: (integrand_fcn FCN, double LL, double UL, double ABS, double REL)
 -- DefQuad: (integrand_fcn FCN, double LL, double UL, const ColumnVector &SING)
 -- DefQuad: (integrand_fcn FCN, const ColumnVector &SING, double ABS, double REL)
 -- DefQuad: (integrand_fcn FCN, const ColumnVector &SING)
 -- DefQuad: (integrand_fcn FCN, double LL, double UL, const ColumnVector &SING, double ABS, double REL)

 -- IndefQuad: (integrand_fcn FCN)
 -- IndefQuad: (integrand_fcn FCN, double B, IntegralType T)
 -- IndefQuad: (integrand_fcn FCN, double B, IntegralType T, double ABS, double REL)
 -- IndefQuad: (integrand_fcn FCN, double ABS, double REL)

Quadratic Programming
*********************

 -- QP: (void)
 -- QP: (const ColumnVector &X, const Matrix &H)
 -- QP: (const ColumnVector &X, const Matrix &H, const ColumnVector &C)
 -- QP: (const ColumnVector &X, const Matrix &H, const Bounds &B)
 -- QP: (const ColumnVector &X, const Matrix &H, const LinConst &LC)
 -- QP: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const Bounds &B)
 -- QP: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const LinConst &LC)
 -- QP: (const ColumnVector &X, const Matrix &H, const Bounds &B, const LinConst &LC)
 -- QP: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const Bounds &B, const LinConst &LC)

 -- virtual ColumnVector: minimize (void)
 -- virtual ColumnVector: minimize (double &OBJF)
 -- virtual ColumnVector: minimize (double &OBJF, int &INFORM)
 -- virtual ColumnVector: minimize (double &OBJF, int &INFORM, ColumnVector &LAMBDA) = 0;

 -- virtual ColumnVector: minimize (const ColumnVector &X)
 -- virtual ColumnVector: minimize (const ColumnVector &X, double &OBJF)
 -- virtual ColumnVector: minimize (const ColumnVector &X, double &OBJF, int &INFORM)
 -- virtual ColumnVector: minimize (const ColumnVector &X, double &OBJF, int &INFORM, ColumnVector &LAMBDA)

 -- QPSOL_options: (void)
 -- QPSOL_options: (const QPSOL_options &OPT)

 -- QPSOL_options&: operator = (const QPSOL_options &OPT)

 -- void: init (void)

 -- void: copy (const QPSOL_options &OPT)

 -- void: set_default_options (void)

 -- void: set_feasibility_tolerance (double VAL)

 -- void: set_infinite_bound (double VAL)

 -- void: set_iteration_limit (int VAL)

 -- void: set_print_level (int VAL)

 -- double: feasibility_tolerance (void)
 -- double: infinite_bound (void)
 -- int: iteration_limit (void)
 -- int: print_level (void)

 -- QPSOL: (void)
 -- QPSOL: (const ColumnVector &X, const Matrix &H)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const ColumnVector &C)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const Bounds &B)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const LinConst &LC)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const Bounds &B)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const LinConst &LC)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const Bounds &B, const LinConst &LC)
 -- QPSOL: (const ColumnVector &X, const Matrix &H, const ColumnVector &C, const Bounds &B, const LinConst &LC)
 -- QPSOL: (const QPSOL &A)

 -- QPSOL&: operator = (const QPSOL &A)

 -- ColumnVector: minimize (double &OBJF, int &INFORM, ColumnVector &LAMBDA)

Nonlinear Programming
*********************

 -- NLP: (void)
 -- NLP: (const ColumnVector &X, const Objective &PHI)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const Bounds &B)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const LinConst &LC)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const LinConst &LC, const NLConst &NLC)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const LinConst &LC)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const LinConst &LC, const NLConst &NLC)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const NLConst &NLC)
 -- NLP: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const NLConst &NLC)

 -- NLP&: operator = (const NLP &A)

 -- int: size (void) const

 -- NPSOL_options: (void)
 -- NPSOL_options: (const NPSOL_options &OPT)

 -- NPSOL_options&: operator = (const NPSOL_options &OPT)

 -- void: init (void)
 -- void: copy (const NPSOL_options &OPT)

 -- void: set_default_options (void)

 -- void: set_central_difference_interval (double VAL)

 -- void: set_crash_tolerance (double VAL)

 -- void: set_difference_interval (double VAL)

 -- void: set_function_precision (double VAL)

 -- void: set_infinite_bound (double VAL)

 -- void: set_infinite_step (double VAL)

 -- void: set_linear_feasibility_tolerance (double VAL)

 -- void: set_linesearch_tolerance (double VAL)

 -- void: set_nonlinear_feasibility_tolerance (double VAL)

 -- void: set_optimality_tolerance (double VAL)

 -- void: set_derivative_level (int VAL)

 -- void: set_major_iteration_limit (int VAL)

 -- void: set_minor_iteration_limit (int VAL)

 -- void: set_major_print_level (int VAL)

 -- void: set_minor_print_level (int VAL)

 -- void: set_start_objective_check (int VAL)

 -- void: set_start_constraint_check (int VAL)

 -- void: set_stop_objective_check (int VAL)

 -- void: set_stop_constraint_check (int VAL)

 -- void: set_verify_level (int VAL)

 -- double: central_difference_interval (void) const
 -- double: crash_tolerance (void) const
 -- double: difference_interval (void) const
 -- double: function_precision (void) const
 -- double: infinite_bound (void) const
 -- double: infinite_step (void) const
 -- double: linear_feasibility_tolerance (void) const
 -- double: linesearch_tolerance (void) const
 -- double: nonlinear_feasibility_tolerance (void) const
 -- double: optimality_tolerance (void) const
 -- int: derivative_level (void) const
 -- int: major_iteration_limit (void) const
 -- int: minor_iteration_limit (void) const
 -- int: major_print_level (void) const
 -- int: minor_print_level (void) const
 -- int: start_objective_check (void) const
 -- int: start_constraint_check (void) const
 -- int: stop_objective_check (void) const
 -- int: stop_constraint_check (void) const
 -- int: verify_level (void) const

 -- NPSOL: (void)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const Bounds &B)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const LinConst &LC)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const LinConst &LC, const NLConst &NLC)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const LinConst &LC)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const LinConst &LC, const NLConst &NLC)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const NLConst &NLC)
 -- NPSOL: (const ColumnVector &X, const Objective &PHI, const Bounds &B, const NLConst &NLC)
 -- NPSOL: (const NPSOL &A)

 -- ColumnVector: minimize (void)
 -- ColumnVector: minimize (double &OBJF)
 -- ColumnVector: minimize (double &OBJF, int &INFORM)
 -- ColumnVector: minimize (double &OBJF, int &INFORM, ColumnVector &LAMBDA)

 -- ColumnVector: minimize (const ColumnVector &X)
 -- ColumnVector: minimize (const ColumnVector &X, double &OBJF)
 -- ColumnVector: minimize (const ColumnVector &X, double &OBJF, int &INFORM)
 -- ColumnVector: minimize (const ColumnVector &X, double &OBJF, int &INFORM, ColumnVector &LAMBDA)

Collocation Weights
*******************

 -- CollocWt: (void)
 -- CollocWt: (int N, int INC_L, int INC_R)
 -- CollocWt: (int N, int INC_L, int INC_R, double L, double R)
 -- CollocWt: (int N, double A, double B, int INC_L, int INC_R)
 -- CollocWt: (int N, int INC_L, int INC_R, double L, double R)
 -- CollocWt: (const CollocWt&)

 -- CollocWt&: operator = (const CollocWt&)

 -- CollocWt&: resize (int NCOL)

 -- CollocWt&: add_left (void)
 -- CollocWt&: add_right (void)

 -- CollocWt&: delete_left (void)
 -- CollocWt&: delete_right (void)

 -- CollocWt&: set_left (double VAL)
 -- CollocWt&: set_right (double VAL)

 -- CollocWt&: set_alpha (double VAL)
 -- CollocWt&: set_beta (double VAL)

 -- int: ncol (void) const

 -- int: left_included (void) const
 -- int: right_included (void) const

 -- double: left (void) const
 -- double: right (void) const
 -- double: width (void) const

 -- double: alpha (void) const
 -- double: beta (void) const

 -- ColumnVector: roots (void)
 -- ColumnVector: quad (void)
 -- ColumnVector: quad_weights (void)

 -- Matrix: first (void)
 -- Matrix: second (void)

 -- friend ostream&: operator << (ostream &OS, const CollocWt &C)

Ranges
******

 -- Range: (void)
 -- Range: (const Range &R)
 -- Range: (double B, double L)
 -- Range: (double B, double L, double I)

 -- double: base (void) const
 -- double: limit (void) const
 -- double: inc (void) const

 -- void: set_base (double B)
 -- void: set_limit (double L)
 -- void: set_inc (double I)

 -- int: nelem (void) const

 -- double: min (void) const
 -- double: max (void) const

 -- void: sort (void)

 -- friend ostream&: operator << (ostream &OS, const Range &R)
 -- friend istream&: operator >> (istream &IS, Range &R)

 -- void: print_range (void)

Installation
************

Bugs
****