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

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

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

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

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


File: liboct,  Node: Matrix and Vector Operations,  Next: Matrix Factorizations,  Prev: Arrays,  Up: Top

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

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

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

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

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

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

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

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

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

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

 - : ostream& operator << (ostream &OS, const Matrix &A)
 - : 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)

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

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

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

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

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

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

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

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

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

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

 - : 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)

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

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

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

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

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

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

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

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

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

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

 - : 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 - : Matrix real (const ComplexMatrix &A)
 - : Matrix imag (const ComplexMatrix &A)
 - : 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

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

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

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

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

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

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

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

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

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

 - : ComplexMatrix map (c_c_Mapper F, const ComplexMatrix &A)
 - : 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

 - : ostream& operator << (ostream &OS, const ComplexMatrix &A)
 - : 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

 - : ColumnVector real (const ComplexColumnVector &A)
 - : ColumnVector imag (const ComplexColumnVector &A)
 - : 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)

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

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

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

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

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

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

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

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

 - : RowVector real (const ComplexRowVector &A)
 - : RowVector imag (const ComplexRowVector &A)
 - : 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)

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

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

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

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

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

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

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

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

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

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

 - : DiagMatrix real (const ComplexDiagMatrix &A)
 - : DiagMatrix imag (const ComplexDiagMatrix &A)
 - : 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


File: liboct,  Node: Matrix Factorizations,  Next: Ranges,  Prev: Matrix and Vector Operations,  Up: Top

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


File: liboct,  Node: Ranges,  Next: Nonlinear Functions,  Prev: Matrix Factorizations,  Up: Top

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)

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

 - : void print_range (void)


File: liboct,  Node: Nonlinear Functions,  Next: Nonlinear Equations,  Prev: Ranges,  Up: Top

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)


File: liboct,  Node: Nonlinear Equations,  Next: Optimization,  Prev: Nonlinear Functions,  Up: Top

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)
 - : ColumnVector solve (const ColumnVector &X, int &INFO)


File: liboct,  Node: Optimization,  Next: Quadrature,  Prev: Nonlinear Equations,  Up: Top

Optimization
************

* Menu:

* Objective Functions::
* Bounds::
* Linear Constraints::
* Nonlinear Constraints::
* Quadratic Programming::
* Nonlinear Programming::


File: liboct,  Node: Objective Functions,  Next: Bounds,  Prev: Optimization,  Up: Optimization

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)


File: liboct,  Node: Bounds,  Next: Linear Constraints,  Prev: Objective Functions,  Up: Optimization

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)

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


File: liboct,  Node: Linear Constraints,  Next: Nonlinear Constraints,  Prev: Bounds,  Up: Optimization

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;

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


File: liboct,  Node: Nonlinear Constraints,  Next: Quadratic Programming,  Prev: Linear Constraints,  Up: Optimization

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)


File: liboct,  Node: Quadratic Programming,  Next: Nonlinear Programming,  Prev: Nonlinear Constraints,  Up: Optimization

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)

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


File: liboct,  Node: Nonlinear Programming,  Prev: Quadratic Programming,  Up: Optimization

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

 - : 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)


File: liboct,  Node: Quadrature,  Next: Ordinary Differential Equations,  Prev: Optimization,  Up: Top

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)

* Menu:

* Collocation Weights::


File: liboct,  Node: Collocation Weights,  Prev: Quadrature,  Up: Quadrature

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)

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


File: liboct,  Node: Ordinary Differential Equations,  Next: Differential Algebraic Equations,  Prev: Quadrature,  Up: Top

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)

