% Copyright (C) 1993, 1994, 1995 John W. Eaton
% This is part of the Octave manual.
% For copying conditions, see the file gpl.texi.

\input texinfo  @c -*-texinfo-*-
@setfilename liboctave.info

@c @smallbook
@c @setchapternewpage odd
@c @cropmarks
@c @finalout

@c Smaller amounts of whitespace for the 8.5 by 11 inch format.
@tex
\global\chapheadingskip = 15pt plus 4pt minus 2pt
\global\secheadingskip = 12pt plus 3pt minus 2pt
\global\subsecheadingskip = 9pt plus 2pt minus 2pt
\global\parskip 6pt plus 1pt
@end tex

@iftex
@set DONTINCLUDEGPL
@end iftex

@defindex op

@include conf.texi

c@settitle Octave C++ Classes

@ifinfo

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.

@ignore
Permission is granted to process this file through Tex and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
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.
@end ifinfo

@titlepage
@title{Octave C++ Classes}
@subtitle{Edition 1.0 for Octave version @value{VERSION}}
@subtitle{September 1993}
@author{John W. Eaton}
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1993, 1994, 1995 John W. Eaton.

This is the first edition of the documentation for Octave's C++ classes,
and is consistent with version @value{VERSION} of Octave.

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 same conditions as for modified versions.
@end titlepage

@ifinfo
@node Top, Acknowledgements, (dir), (dir)
@top

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

@c ------------------------------------------------------------------------

@menu
* Acknowledgements::            
* Introduction::                
* Arrays::                      
* Matrix and Vector @var{Operations}::  
* Matrix Factorizations::       
* Nonlinear Functions::         
* Objective Functions::         
* Bounds::                      
* Linear Constraints::          
* Nonlinear Constraints::       
* Nonlinear Equations::         
* Ordinary Differential Equations::  
* Differential Algebraic Equations::  
* Quadrature::                  
* Quadratic Programming::       
* Nonlinear Programming::       
* Collocation Weights::         
* Ranges::                      
* Installation::                
* Bugs::                        
* Concept Index::               
* Function Index::              
@end menu

@node Acknowledgements, Introduction, Top, Top
@chapter Acknowledgements
@cindex acknowledgements

@menu
* Contributors::                People who contributed to developing of Octave.
@end menu

@node Contributors,  , Acknowledgements, Acknowledgements
@unnumberedsec Contributors to Octave
@cindex contributors

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

@c Once lp_solve has been added, don't forget to include the lp_solve
@c author, and Kantor, for providing an example.

@itemize @bullet
@item A. Scottedward Hodel (scotte@@eng.auburn.edu) contributed a number
of functions including @code{expm}, @code{qzval}, @code{qzhess},
@code{syl}, @code{lyap}, and @code{balance}.

@item
R. Bruce Tenison (Bruce.Tenison@@eng.auburn.edu) wrote the @code{hess} and
@code{schur} functions.
@end itemize

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

@itemize @bullet
@item
Digital Equipment Corporation, for an equipment grant as part of their
External Research Program.

@item
Sun Microsystems, Inc., for an Academic Equipment grant.

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

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

@item
Noel Bell, Senior Engineer, Texaco Chemical Company, Austin Texas.

@item
James B. Rawlings, Associate Professor, Department of Chemical
Engineering, The University of Texas at Austin.
@end itemize

Portions of this document have been adapted from the @code{gawk},
@code{readline}, @code{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.

@c ------------------------------------------------------------------------

@node Introduction, Arrays, Acknowledgements, Top
@chapter A Brief Introduction to Octave
@cindex introduction

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

@c ------------------------------------------------------------------------

@node Arrays, Matrix and Vector @var{Operations}, Introduction, Top
@chapter Arrays
@cindex arrays

@menu
* Constructors and Assignment::  
@end menu

@node Constructors and Assignment,  , Arrays, Arrays
@section Constructors and Assignment

@deftypefn  {} {}Array (void)
@deftypefnx  {} {}Array (int @var{n})
@deftypefnx  {} {}Array (int @var{n}, const T &@var{val})
@deftypefnx  {} {}Array (const Array<T> &@var{a})
@end deftypefn

@deftypefn {} Array<T>& {operator =} (const Array<T> &@var{a})
@end deftypefn

@deftypefn {} int capacity (void) const
@deftypefnx {} int length (void) const
@end deftypefn

@deftypefn {} T& elem (int @var{n})
@deftypefnx {} T& checkelem (int @var{n})
@deftypefnx {} T& {operator ()} (int @var{n})
@end deftypefn

@c This needs to be fixed.
@c
@c T& xelem (int @var{n})
@c
@c T elem (int @var{n}) const
@c T checkelem (int @var{n}) const
@c T operator () (int @var{n}) const

@deftypefn {} void resize (int @var{n})
@deftypefnx {} void resize (int @var{n}, const T &@var{val})
@end deftypefn

@deftypefn {} const T *data (void) const
@end deftypefn

@c Should this be public?
@c
@c T *fortran_vec (void)

@deftypefn  {} {}Array2 (void)
@deftypefnx  {} {}Array2 (int @var{n}, int @var{m})
@deftypefnx  {} {}Array2 (int @var{n}, int @var{m}, const T &@var{val})
@deftypefnx  {} {}Array2 (const Array2<T> &@var{a})
@deftypefnx  {} {}Array2 (const DiagArray<T> &@var{a})
@end deftypefn

@deftypefn {} Array2<T>& {operator =} (const Array2<T> &@var{a})
@end deftypefn

@deftypefn {} int dim1 (void) const
@deftypefnx {} int rows (void) const
@end deftypefn

@deftypefn {} int dim2 (void) const
@deftypefnx {} int cols (void) const
@deftypefnx {} int columns (void) const
@end deftypefn

@deftypefn {} T& elem (int @var{i}, int @var{j})
@deftypefnx {} T& checkelem (int @var{i}, int @var{j})
@deftypefnx {} T& {operator ()} (int @var{i}, int @var{j})
@end deftypefn

@c This needs to be fixed.
@c
@c T& xelem (int i, int j)
@c
@c T elem (int i, int j) const
@c T checkelem (int i, int j) const
@c T operator () (int i, int j) const

@deftypefn {} void resize (int @var{n}, int @var{m})
@deftypefnx {} void resize (int @var{n}, int @var{m}, const T &@var{val})
@end deftypefn

@deftypefn {} Array3 (void)
@deftypefnx {} Array3 (int @var{n}, int @var{m}, int @var{k})
@deftypefnx {} Array3 (int @var{n}, int @var{m}, int @var{k}, const T &@var{val})
@deftypefnx {} Array3 (const Array3<T> &@var{a})
@end deftypefn

@deftypefn {} Array3<T>& {operator =} (const Array3<T> &@var{a})
@end deftypefn

@deftypefn {} int dim1 (void) const
@deftypefnx {} int dim2 (void) const
@deftypefnx {} int dim3 (void) const
@end deftypefn

@deftypefn {} T& elem (int @var{i}, int @var{j}, int @var{k})
@deftypefnx {} T& checkelem (int @var{i}, int @var{j}, int @var{k})
@deftypefnx {} T& {operator ()} (int @var{i}, int @var{j}, int @var{k})
@end deftypefn

@c This needs to be fixed.
@c
@c T& xelem (int i, int j, int k)
@c
@c T elem (int i, int j, int k) const
@c T checkelem (int i, int j, int k) const
@c T operator () (int i, int j, int k) const

@deftypefn {} void resize (int @var{n}, int @var{m}, int @var{k})
@deftypefnx {} void resize (int @var{n}, int @var{m}, int @var{k}, const T &@var{val})
@end deftypefn

@deftypefn  {} {}DiagArray (void)
@deftypefnx  {} {}DiagArray (int @var{n})
@deftypefnx  {} {}DiagArray (int @var{n}, const T &@var{val})
@deftypefnx  {} {}DiagArray (int @var{r}, int @var{c})
@deftypefnx  {} {}DiagArray (int @var{r}, int @var{c}, const T &@var{val})
@deftypefnx  {} {}DiagArray (const Array<T> &@var{a})
@deftypefnx  {} {}DiagArray (const DiagArray<T> &@var{a})
@end deftypefn

@deftypefn {} DiagArray<T>& {operator =} (const DiagArray<T> &@var{a})
@end deftypefn

@deftypefn {} int dim1 (void) const
@deftypefnx {} int rows (void) const
@end deftypefn

@deftypefn {} int dim2 (void) const
@deftypefnx {} int cols (void) const
@deftypefnx {} int columns (void) const
@end deftypefn

@deftypefn {} T& elem (int @var{r}, int @var{c})
@deftypefnx {} T& checkelem (int @var{r}, int @var{c})
@deftypefnx {} T& {operator ()} (int @var{r}, int @var{c})
@end deftypefn

@c This needs to be fixed.
@c
@c T& xelem (int r, int c)
@c
@c T elem (int r, int c) const
@c T checkelem (int r, int c) const
@c T operator () (int r, int c) const

@deftypefn {} void resize (int @var{n}, int @var{m})
@deftypefnx {} void resize (int @var{n}, int @var{m}, const T &@var{val})
@end deftypefn

@c ------------------------------------------------------------------------

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

Element by element vector by scalar ops.

@deftypefn {} {friend RowVector} {operator +} (const RowVector &@var{a}, const double &@var{s})
@deftypefnx {} {friend RowVector} {operator -} (const RowVector &@var{a}, const double &@var{s})
@deftypefnx {} {friend RowVector} {operator *} (const RowVector &@var{a}, const double &@var{s})
@deftypefnx {} {friend RowVector} {operator /} (const RowVector &@var{a}, const double &@var{s})
@end deftypefn

Element by element scalar by vector ops.

@deftypefn {} {friend RowVector} {operator +} (const double &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend RowVector} {operator -} (const double &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend RowVector} {operator *} (const double &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend RowVector} {operator /} (const double &@var{s}, const RowVector &@var{a})
@end deftypefn

Element by element vector by vector ops.

@deftypefn {} {friend RowVector} {operator +} (const RowVector &@var{a}, const RowVector &@var{b})
@deftypefnx {} {friend RowVector} {operator -} (const RowVector &@var{a}, const RowVector &@var{b})
@end deftypefn

@deftypefn {} {friend RowVector} product (const RowVector &@var{a}, const RowVector &@var{b})
@deftypefnx {} {friend RowVector} quotient (const RowVector &@var{a}, const RowVector &@var{b})
@end deftypefn

Unary MArray ops.

@deftypefn {} {friend RowVector} {operator -} (const RowVector &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

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

Element by element matrix by scalar ops.

@deftypefn {} {friend Matrix} {operator +} (const Matrix &@var{a}, const double &@var{s})
@deftypefnx {} {friend Matrix} {operator -} (const Matrix &@var{a}, const double &@var{s})
@deftypefnx {} {friend Matrix} {operator *} (const Matrix &@var{a}, const double &@var{s})
@deftypefnx {} {friend Matrix} {operator /} (const Matrix &@var{a}, const double &@var{s})
@end deftypefn

Element by element scalar by matrix ops.

@deftypefn {} {friend Matrix} {operator +} (const double &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend Matrix} {operator -} (const double &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend Matrix} {operator *} (const double &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend Matrix} {operator /} (const double &@var{s}, const Matrix &@var{a})
@end deftypefn

Element by element matrix by matrix ops.

@deftypefn {} {friend Matrix} {operator +} (const Matrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend Matrix} {operator -} (const Matrix &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend Matrix} product (const Matrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend Matrix} quotient (const Matrix &@var{a}, const Matrix &@var{b})
@end deftypefn

Unary matrix ops.

@deftypefn {} {friend Matrix} {operator -} (const Matrix &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

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

Element by element MDiagArray by scalar ops.

@deftypefn {} {friend DiagMatrix} {operator *} (const DiagMatrix &@var{a}, const double &@var{s})
@deftypefnx {} {friend DiagMatrix} {operator /} (const DiagMatrix &@var{a}, const double &@var{s})
@end deftypefn

Element by element scalar by MDiagArray ops.

@deftypefn {} {friend DiagMatrix} {operator *} (const double &@var{s}, const DiagMatrix &@var{a})
@end deftypefn

Element by element MDiagArray by MDiagArray ops.

@deftypefn {} {friend DiagMatrix} {operator +} (const DiagMatrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend DiagMatrix} {operator -} (const DiagMatrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend DiagMatrix} product (const DiagMatrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

Unary MDiagArray ops.

@deftypefn {} {friend DiagMatrix} {operator -} (const DiagMatrix &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

@node Matrix and Vector @var{Operations}, Matrix Factorizations, Arrays, Top
@chapter Matrix and Vector Operations
@cindex matrix manipulations
@cindex vector manipulations

@deftypefn  {} {}Matrix (void)
@deftypefnx  {} {}Matrix (int @var{r}, int @var{c})
@deftypefnx  {} {}Matrix (int @var{r}, int @var{c}, double @var{val})
@deftypefnx  {} {}Matrix (const Array2<double> &@var{a})
@deftypefnx  {} {}Matrix (const Matrix &@var{a})
@deftypefnx  {} {}Matrix (const DiagArray<double> &@var{a})
@deftypefnx  {} {}Matrix (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} Matrix& {operator =} (const Matrix &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const Matrix &@var{a}) const
@deftypefnx {} int {operator !=} (const Matrix &@var{a}) const
@end deftypefn

@deftypefn {} Matrix& insert (const Matrix &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} Matrix& insert (const RowVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} Matrix& insert (const ColumnVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} Matrix& insert (const DiagMatrix &@var{a}, int @var{r}, int @var{c})
@end deftypefn

@deftypefn {} Matrix& fill (double @var{val})
@deftypefnx {} Matrix& fill (double @var{val}, int r1, int c1, int r2, int c2)
@end deftypefn

@deftypefn {} Matrix append (const Matrix &@var{a}) const
@deftypefnx {} Matrix append (const RowVector &@var{a}) const
@deftypefnx {} Matrix append (const ColumnVector &@var{a}) const
@deftypefnx {} Matrix append (const DiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} Matrix stack (const Matrix &@var{a}) const
@deftypefnx {} Matrix stack (const RowVector &@var{a}) const
@deftypefnx {} Matrix stack (const ColumnVector &@var{a}) const
@deftypefnx {} Matrix stack (const DiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} Matrix transpose (void) const
@end deftypefn

@deftypefn {} Matrix extract (int r1, int c1, int r2, int c2) const
@end deftypefn

@deftypefn {} RowVector row (int @var{i}) const
@deftypefnx {} RowVector row (char *s) const
@end deftypefn

@deftypefn {} ColumnVector column (int @var{i}) const
@deftypefnx {} ColumnVector column (char *s) const
@end deftypefn

@deftypefn {} Matrix inverse (void) const
@deftypefnx {} Matrix inverse (int &@var{info}) const
@deftypefnx {} Matrix inverse (int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix fourier (void) const
@deftypefnx {} ComplexMatrix ifourier (void) const
@end deftypefn

@deftypefn {} DET determinant (void) const
@deftypefnx {} DET determinant (int &@var{info}) const
@deftypefnx {} DET determinant (int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} Matrix solve (const Matrix &@var{b}) const
@deftypefnx {} Matrix solve (const Matrix &@var{b}, int &@var{info}) const
@deftypefnx {} Matrix solve (const Matrix &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix solve (const ComplexMatrix &@var{b}) const
@deftypefnx {} ComplexMatrix solve (const ComplexMatrix &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexMatrix solve (const ComplexMatrix &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ColumnVector solve (const ColumnVector &@var{b}) const
@deftypefnx {} ColumnVector solve (const ColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ColumnVector solve (const ColumnVector &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}) const
@deftypefnx {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} Matrix lssolve (const Matrix &@var{b}) const
@deftypefnx {} Matrix lssolve (const Matrix &@var{b}, int &@var{info}) const
@deftypefnx {} Matrix lssolve (const Matrix &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}) const
@deftypefnx {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} ColumnVector lssolve (const ColumnVector &@var{b}) const
@deftypefnx {} ColumnVector lssolve (const ColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ColumnVector lssolve (const ColumnVector &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}) const
@deftypefnx {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} Matrix& {operator +=} (const Matrix &@var{a})
@deftypefnx {} Matrix& {operator -=} (const Matrix &@var{a})
@end deftypefn

@deftypefn {} Matrix& {operator +=} (const DiagMatrix &@var{a})
@deftypefnx {} Matrix& {operator -=} (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} Matrix {operator !} (void) const
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Matrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Matrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const Matrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexMatrix} {operator /} (const Matrix &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Complex &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Complex &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const Complex &@var{s}, const Matrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator /} (const Complex &@var{s}, const Matrix &@var{a})
@end deftypefn

@deftypefn {} {friend ColumnVector} {operator *} (const Matrix &@var{a}, const ColumnVector &@var{b})
@deftypefnx {} {friend ComplexColumnVector} {operator *} (const Matrix &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend Matrix} {operator +} (const Matrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend Matrix} {operator -} (const Matrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend Matrix} {operator *} (const Matrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Matrix &@var{a}, const ComplexDiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Matrix &@var{a}, const ComplexDiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const Matrix &@var{a}, const ComplexDiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend Matrix} {operator *} (const Matrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const Matrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Matrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Matrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} product (const Matrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} quotient (const Matrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend Matrix} map (d_d_Mapper @var{f}, const Matrix &@var{a})
@deftypefnx {} void map (d_d_Mapper @var{f})
@end deftypefn

@deftypefn {} Matrix all (void) const
@deftypefnx {} Matrix any (void) const
@end deftypefn

@deftypefn {} Matrix cumprod (void) const
@deftypefnx {} Matrix cumsum (void) const
@deftypefnx {} Matrix prod (void) const
@deftypefnx {} Matrix sum (void) const
@deftypefnx {} Matrix sumsq (void) const
@end deftypefn

@deftypefn {} ColumnVector diag (void) const
@deftypefnx {} ColumnVector diag (int @var{k}) const
@end deftypefn

@deftypefn {} ColumnVector row_min (void) const
@deftypefnx {} ColumnVector row_min_loc (void) const
@end deftypefn

@deftypefn {} ColumnVector row_max (void) const
@deftypefnx {} ColumnVector row_max_loc (void) const
@end deftypefn

@deftypefn {} RowVector column_min (void) const
@deftypefnx {} RowVector column_min_loc (void) const
@end deftypefn

@deftypefn {} RowVector column_max (void) const
@deftypefnx {} RowVector column_max_loc (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const Matrix &@var{a})
@deftypefnx {} {friend istream&} {operator >>} (istream &@var{is}, Matrix &@var{a})
@end deftypefn

@deftypefn  {} {}ColumnVector (void)
@deftypefnx  {} {}ColumnVector (int @var{n})
@deftypefnx  {} {}ColumnVector (int @var{n}, double @var{val})
@deftypefnx  {} {}ColumnVector (const Array<double> &@var{a})
@deftypefnx  {} {}ColumnVector (const ColumnVector &@var{a})
@end deftypefn

@deftypefn {} ColumnVector& {operator =} (const ColumnVector &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const ColumnVector &@var{a}) const
@deftypefnx {} int {operator !=} (const ColumnVector &@var{a}) const
@end deftypefn

@deftypefn {} ColumnVector& insert (const ColumnVector &@var{a}, int @var{r})
@end deftypefn

@deftypefn {} ColumnVector& fill (double @var{val})
@deftypefnx {} ColumnVector& fill (double @var{val}, int r1, int r2)
@end deftypefn

@deftypefn {} ColumnVector stack (const ColumnVector &@var{a}) const
@end deftypefn

@deftypefn {} RowVector transpose (void) const
@end deftypefn

@deftypefn {} ColumnVector extract (int r1, int r2) const
@end deftypefn

@deftypefn {} ColumnVector& {operator +=} (const ColumnVector &@var{a})
@deftypefnx {} ColumnVector& {operator -=} (const ColumnVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (const ColumnVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator -} (const ColumnVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator *} (const ColumnVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator /} (const ColumnVector &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (const Complex &@var{s}, const ColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator -} (const Complex &@var{s}, const ColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator *} (const Complex &@var{s}, const ColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator /} (const Complex &@var{s}, const ColumnVector &@var{a})
@end deftypefn

@deftypefn {} {friend Matrix} {operator *} (const ColumnVector &@var{a}, const RowVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator *} (const ColumnVector &@var{a}, const ComplexRowVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (const ComplexColumnVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator -} (const ComplexColumnVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} product (const ComplexColumnVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} quotient (const ComplexColumnVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ColumnVector} map (d_d_Mapper @var{f}, const ColumnVector &@var{a})
@deftypefnx {} void map (d_d_Mapper @var{f})
@end deftypefn

@deftypefn {} double min (void) const
@deftypefnx {} double max (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ColumnVector &@var{a})
@end deftypefn

@deftypefn  {} {}RowVector (void)
@deftypefnx  {} {}RowVector (int @var{n})
@deftypefnx  {} {}RowVector (int @var{n}, double @var{val})
@deftypefnx  {} {}RowVector (const Array<double> &@var{a})
@deftypefnx  {} {}RowVector (const RowVector &@var{a})
@end deftypefn

@deftypefn {} RowVector& {operator =} (const RowVector &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const RowVector &@var{a}) const
@deftypefnx {} int {operator !=} (const RowVector &@var{a}) const
@end deftypefn

@deftypefn {} RowVector& insert (const RowVector &@var{a}, int @var{c})
@end deftypefn

@deftypefn {} RowVector& fill (double @var{val})
@deftypefnx {} RowVector& fill (double @var{val}, int c1, int c2)
@end deftypefn

@deftypefn {} RowVector append (const RowVector &@var{a}) const
@end deftypefn

@deftypefn {} ColumnVector transpose (void) const
@end deftypefn

@deftypefn {} RowVector extract (int c1, int c2) const
@end deftypefn

@deftypefn {} RowVector& {operator +=} (const RowVector &@var{a})
@deftypefnx {} RowVector& {operator -=} (const RowVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (const RowVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexRowVector} {operator -} (const RowVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexRowVector} {operator *} (const RowVector &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexRowVector} {operator /} (const RowVector &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (const Complex &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator -} (const Complex &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator *} (const Complex &@var{s}, const RowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator /} (const Complex &@var{s}, const RowVector &@var{a})
@end deftypefn

@deftypefn {} {friend double} {operator *} (const RowVector &@var{a}, ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend Complex} {operator *} (const RowVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend RowVector} {operator *} (const RowVector &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator *} (const RowVector &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (const RowVector &@var{a}, const ComplexRowVector &@var{b})
@deftypefnx {} {friend ComplexRowVector} {operator -} (const RowVector &@var{a}, const ComplexRowVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} product (const RowVector &@var{a}, const ComplexRowVector &@var{b})
@deftypefnx {} {friend ComplexRowVector} quotient (const RowVector &@var{a}, const ComplexRowVector &@var{b})
@end deftypefn

@deftypefn {} {friend RowVector} map (d_d_Mapper @var{f}, const RowVector &@var{a})
@deftypefnx {} void map (d_d_Mapper @var{f})
@end deftypefn

@deftypefn {} double min (void) const
@deftypefnx {} double max (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const RowVector &@var{a})
@end deftypefn

@deftypefn  {} {}DiagMatrix (void)
@deftypefnx  {} {}DiagMatrix (int @var{n})
@deftypefnx  {} {}DiagMatrix (int @var{n}, double @var{val})
@deftypefnx  {} {}DiagMatrix (int @var{r}, int @var{c})
@deftypefnx  {} {}DiagMatrix (int @var{r}, int @var{c}, double @var{val})
@deftypefnx  {} {}DiagMatrix (const RowVector &@var{a})
@deftypefnx  {} {}DiagMatrix (const ColumnVector &@var{a})
@deftypefnx  {} {}DiagMatrix (const DiagArray<double> &@var{a})
@deftypefnx  {} {}DiagMatrix (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} DiagMatrix& {operator =} (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const DiagMatrix &@var{a}) const
@deftypefnx {} int {operator !=} (const DiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} DiagMatrix& fill (double @var{val})
@deftypefnx {} DiagMatrix& fill (double @var{val}, int @var{beg}, int @var{end})
@deftypefnx {} DiagMatrix& fill (const ColumnVector &@var{a})
@deftypefnx {} DiagMatrix& fill (const RowVector &@var{a})
@deftypefnx {} DiagMatrix& fill (const ColumnVector &@var{a}, int @var{beg})
@deftypefnx {} DiagMatrix& fill (const RowVector &@var{a}, int @var{beg})
@end deftypefn

@deftypefn {} DiagMatrix transpose (void) const
@end deftypefn

@deftypefn {} Matrix extract (int r1, int c1, int r2, int c2) const
@end deftypefn

@deftypefn {} RowVector row (int @var{i}) const
@deftypefnx {} RowVector row (char *s) const
@end deftypefn

@deftypefn {} ColumnVector column (int @var{i}) const
@deftypefnx {} ColumnVector column (char *s) const
@end deftypefn

@deftypefn {} DiagMatrix inverse (void) const
@deftypefnx {} DiagMatrix inverse (int &@var{info}) const
@end deftypefn

@deftypefn {} DiagMatrix& {operator +=} (const DiagMatrix &@var{a})
@deftypefnx {} DiagMatrix& {operator -=} (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend Matrix} {operator +} (const DiagMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend Matrix} {operator -} (const DiagMatrix &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const DiagMatrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const DiagMatrix &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator *} (const DiagMatrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexDiagMatrix} {operator /} (const DiagMatrix &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend Matrix} {operator +} (double @var{s}, const DiagMatrix &@var{a})
@deftypefnx {} {friend Matrix} {operator -} (double @var{s}, const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Complex &@var{s}, const DiagMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Complex &@var{s}, const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator *} (const Complex &@var{s}, const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ColumnVector} {operator *} (const DiagMatrix &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator *} (const DiagMatrix &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator +} (const DiagMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@deftypefnx {} {friend ComplexDiagMatrix} {operator -} (const DiagMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} product (const DiagMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend Matrix} {operator +} (const DiagMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend Matrix} {operator -} (const DiagMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend Matrix} {operator *} (const DiagMatrix &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const DiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const DiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const DiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} ColumnVector diag (void) const
@deftypefnx {} ColumnVector diag (int @var{k}) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const DiagMatrix &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexMatrix (void)
@deftypefnx  {} {}ComplexMatrix (int @var{r}, int @var{c})
@deftypefnx  {} {}ComplexMatrix (int @var{r}, int @var{c}, const Complex &@var{val})
@deftypefnx  {} {}ComplexMatrix (const Matrix &@var{a})
@deftypefnx  {} {}ComplexMatrix (const Array2<Complex> &@var{a})
@deftypefnx  {} {}ComplexMatrix (const ComplexMatrix &@var{a})
@deftypefnx  {} {}ComplexMatrix (const DiagMatrix &@var{a})
@deftypefnx  {} {}ComplexMatrix (const DiagArray<Complex> &@var{a})
@deftypefnx  {} {}ComplexMatrix (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix& {operator =} (const ComplexMatrix &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const ComplexMatrix &@var{a}) const
@deftypefnx {} int {operator !=} (const ComplexMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexMatrix& insert (const Matrix &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const RowVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const ColumnVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const DiagMatrix &@var{a}, int @var{r}, int @var{c})
@end deftypefn

@deftypefn {} ComplexMatrix& insert (const ComplexMatrix &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const ComplexRowVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const ComplexColumnVector &@var{a}, int @var{r}, int @var{c})
@deftypefnx {} ComplexMatrix& insert (const ComplexDiagMatrix &@var{a}, int @var{r}, int @var{c})
@end deftypefn

@deftypefn {} ComplexMatrix& fill (double @var{val})
@deftypefnx {} ComplexMatrix& fill (const Complex &@var{val})
@deftypefnx {} ComplexMatrix& fill (double @var{val}, int r1, int c1, int r2, int c2)
@deftypefnx {} ComplexMatrix& fill (const Complex &@var{val}, int r1, int c1, int r2, int c2)
@end deftypefn

@deftypefn {} ComplexMatrix append (const Matrix &@var{a}) const
@deftypefnx {} ComplexMatrix append (const RowVector &@var{a}) const
@deftypefnx {} ComplexMatrix append (const ColumnVector &@var{a}) const
@deftypefnx {} ComplexMatrix append (const DiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexMatrix append (const ComplexMatrix &@var{a}) const
@deftypefnx {} ComplexMatrix append (const ComplexRowVector &@var{a}) const
@deftypefnx {} ComplexMatrix append (const ComplexColumnVector &@var{a}) const
@deftypefnx {} ComplexMatrix append (const ComplexDiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexMatrix stack (const Matrix &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const RowVector &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const ColumnVector &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const DiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexMatrix stack (const ComplexMatrix &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const ComplexRowVector &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const ComplexColumnVector &@var{a}) const
@deftypefnx {} ComplexMatrix stack (const ComplexDiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexMatrix transpose (void) const
@end deftypefn

@deftypefn {} {friend Matrix} real (const ComplexMatrix &@var{a})
@deftypefnx {} {friend Matrix} imag (const ComplexMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} conj (const ComplexMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix extract (int r1, int c1, int r2, int c2) const
@end deftypefn

@deftypefn {} ComplexRowVector row (int @var{i}) const
@deftypefnx {} ComplexRowVector row (char *s) const
@end deftypefn

@deftypefn {} ComplexColumnVector column (int @var{i}) const
@deftypefnx {} ComplexColumnVector column (char *s) const
@end deftypefn

@deftypefn {} ComplexMatrix inverse (void) const
@deftypefnx {} ComplexMatrix inverse (int &@var{info}) const
@deftypefnx {} ComplexMatrix inverse (int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix fourier (void) const
@deftypefnx {} ComplexMatrix ifourier (void) const
@end deftypefn

@deftypefn {} ComplexDET determinant (void) const
@deftypefnx {} ComplexDET determinant (int &@var{info}) const
@deftypefnx {} ComplexDET determinant (int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix solve (const Matrix &@var{b}) const
@deftypefnx {} ComplexMatrix solve (const Matrix &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexMatrix solve (const Matrix &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix solve (const ComplexMatrix &@var{b}) const
@deftypefnx {} ComplexMatrix solve (const ComplexMatrix &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexMatrix solve (const ComplexMatrix &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}) const
@deftypefnx {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexColumnVector solve (const ComplexColumnVector &@var{b}, int &@var{info}, double &@var{rcond}) const
@end deftypefn

@deftypefn {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}) const
@deftypefnx {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexMatrix lssolve (const ComplexMatrix &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}) const
@deftypefnx {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}, int &@var{info}) const
@deftypefnx {} ComplexColumnVector lssolve (const ComplexColumnVector &@var{b}, int &@var{info}, int &@var{rank}) const
@end deftypefn

@deftypefn {} ComplexMatrix& {operator +=} (const DiagMatrix &@var{a})
@deftypefnx {} ComplexMatrix& {operator -=} (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix& {operator +=} (const ComplexDiagMatrix &@var{a})
@deftypefnx {} ComplexMatrix& {operator -=} (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix& {operator +=} (const Matrix &@var{a})
@deftypefnx {} ComplexMatrix& {operator -=} (const Matrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix& {operator +=} (const ComplexMatrix &@var{a})
@deftypefnx {} ComplexMatrix& {operator -=} (const ComplexMatrix &@var{a})
@end deftypefn

@deftypefn {} Matrix {operator !} (void) const
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexMatrix} {operator /} (const ComplexMatrix &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (double @var{s}, const ComplexMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator -} (double @var{s}, const ComplexMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator *} (double @var{s}, const ComplexMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator /} (double @var{s}, const ComplexMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator *} (const ComplexMatrix &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator *} (const ComplexMatrix &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexMatrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexMatrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexMatrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexMatrix &@var{a}, const ComplexDiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexMatrix &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator *} (const ComplexMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexMatrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} product (const ComplexMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} quotient (const ComplexMatrix &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} map (c_c_Mapper @var{f}, const ComplexMatrix &@var{a})
@deftypefnx {} {friend Matrix} map (d_c_Mapper @var{f}, const ComplexMatrix &@var{a})
@deftypefnx {} void map (c_c_Mapper @var{f})
@end deftypefn

@deftypefn {} Matrix all (void) const
@deftypefnx {} Matrix any (void) const
@end deftypefn

@deftypefn {} ComplexMatrix cumprod (void) const
@deftypefnx {} ComplexMatrix cumsum (void) const
@deftypefnx {} ComplexMatrix prod (void) const
@deftypefnx {} ComplexMatrix sum (void) const
@deftypefnx {} ComplexMatrix sumsq (void) const
@end deftypefn

@deftypefn {} ComplexColumnVector diag (void) const
@deftypefnx {} ComplexColumnVector diag (int @var{k}) const
@end deftypefn

@deftypefn {} ComplexColumnVector row_min (void) const
@deftypefnx {} ComplexColumnVector row_min_loc (void) const
@end deftypefn

@deftypefn {} ComplexColumnVector row_max (void) const
@deftypefnx {} ComplexColumnVector row_max_loc (void) const
@end deftypefn

@deftypefn {} ComplexRowVector column_min (void) const
@deftypefnx {} ComplexRowVector column_min_loc (void) const
@end deftypefn

@deftypefn {} ComplexRowVector column_max (void) const
@deftypefnx {} ComplexRowVector column_max_loc (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexMatrix &@var{a})
@deftypefnx {} {friend istream&} {operator >>} (istream &@var{is}, ComplexMatrix &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexColumnVector (void)
@deftypefnx  {} {}ComplexColumnVector (int @var{n})
@deftypefnx  {} {}ComplexColumnVector (int @var{n}, const Complex &@var{val})
@deftypefnx  {} {}ComplexColumnVector (const ColumnVector &@var{a})
@deftypefnx  {} {}ComplexColumnVector (const Array<Complex> &@var{a})
@deftypefnx  {} {}ComplexColumnVector (const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn {} ComplexColumnVector& {operator =} (const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const ComplexColumnVector &@var{a}) const
@deftypefnx {} int {operator !=} (const ComplexColumnVector &@var{a}) const
@end deftypefn

@deftypefn {} ComplexColumnVector& insert (const ColumnVector &@var{a}, int @var{r})
@deftypefnx {} ComplexColumnVector& insert (const ComplexColumnVector &@var{a}, int @var{r})
@end deftypefn

@deftypefn {} ComplexColumnVector& fill (double @var{val})
@deftypefnx {} ComplexColumnVector& fill (const Complex &@var{val})
@deftypefnx {} ComplexColumnVector& fill (double @var{val}, int r1, int r2)
@deftypefnx {} ComplexColumnVector& fill (const Complex &@var{val}, int r1, int r2)
@end deftypefn

@deftypefn {} ComplexColumnVector stack (const ColumnVector &@var{a}) const
@deftypefnx {} ComplexColumnVector stack (const ComplexColumnVector &@var{a}) const
@end deftypefn

@deftypefn {} ComplexRowVector transpose (void) const
@end deftypefn

@deftypefn {} {friend ColumnVector} real (const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ColumnVector} imag (const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} conj (const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn {} ComplexColumnVector extract (int r1, int r2) const
@end deftypefn

@deftypefn {} ComplexColumnVector& {operator +=} (const ColumnVector &@var{a})
@deftypefnx {} ComplexColumnVector& {operator -=} (const ColumnVector &@var{a})
@end deftypefn

@deftypefn {} ComplexColumnVector& {operator +=} (const ComplexColumnVector &@var{a})
@deftypefnx {} ComplexColumnVector& {operator -=} (const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (const ComplexColumnVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator -} (const ComplexColumnVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator *} (const ComplexColumnVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexColumnVector} {operator /} (const ComplexColumnVector &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (double @var{s}, const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator -} (double @var{s}, const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator *} (double @var{s}, const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ComplexColumnVector} {operator /} (double @var{s}, const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator *} (const ComplexColumnVector &@var{a}, const ComplexRowVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator +} (const ComplexColumnVector &@var{a}, const ColumnVector &@var{b})
@deftypefnx {} {friend ComplexColumnVector} {operator -} (const ComplexColumnVector &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} product (const ComplexColumnVector &@var{a}, const ColumnVector &@var{b})
@deftypefnx {} {friend ComplexColumnVector} quotient (const ComplexColumnVector &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} map (c_c_Mapper @var{f}, const ComplexColumnVector &@var{a})
@deftypefnx {} {friend ColumnVector} map (d_c_Mapper @var{f}, const ComplexColumnVector &@var{a})
@deftypefnx {} void map (c_c_Mapper @var{f})
@end deftypefn

@deftypefn {} Complex min (void) const
@deftypefnx {} Complex max (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexColumnVector &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexRowVector (void)
@deftypefnx  {} {}ComplexRowVector (int @var{n})
@deftypefnx  {} {}ComplexRowVector (int @var{n}, const Complex &@var{val})
@deftypefnx  {} {}ComplexRowVector (const RowVector &@var{a})
@deftypefnx  {} {}ComplexRowVector (const Array<Complex> &@var{a})
@deftypefnx  {} {}ComplexRowVector (const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn {} ComplexRowVector& {operator =} (const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const ComplexRowVector &@var{a}) const
@deftypefnx {} int {operator !=} (const ComplexRowVector &@var{a}) const
@end deftypefn

@deftypefn {} ComplexRowVector& insert (const RowVector &@var{a}, int @var{c})
@deftypefnx {} ComplexRowVector& insert (const ComplexRowVector &@var{a}, int @var{c})
@end deftypefn

@deftypefn {} ComplexRowVector& fill (double @var{val})
@deftypefnx {} ComplexRowVector& fill (const Complex &@var{val})
@deftypefnx {} ComplexRowVector& fill (double @var{val}, int c1, int c2)
@deftypefnx {} ComplexRowVector& fill (const Complex &@var{val}, int c1, int c2)
@end deftypefn

@deftypefn {} ComplexRowVector append (const RowVector &@var{a}) const
@deftypefnx {} ComplexRowVector append (const ComplexRowVector &@var{a}) const
@end deftypefn

@deftypefn {} ComplexColumnVector transpose (void) const
@end deftypefn

@deftypefn {} {friend RowVector} real (const ComplexRowVector &@var{a})
@deftypefnx {} {friend RowVector} imag (const ComplexRowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} conj (const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn {} ComplexRowVector extract (int c1, int c2) const
@end deftypefn

@deftypefn {} ComplexRowVector& {operator +=} (const RowVector &@var{a})
@deftypefnx {} ComplexRowVector& {operator -=} (const RowVector &@var{a})
@end deftypefn

@deftypefn {} ComplexRowVector& {operator +=} (const ComplexRowVector &@var{a})
@deftypefnx {} ComplexRowVector& {operator -=} (const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (const ComplexRowVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexRowVector} {operator -} (const ComplexRowVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexRowVector} {operator *} (const ComplexRowVector &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexRowVector} {operator /} (const ComplexRowVector &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (double @var{s}, const ComplexRowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator -} (double @var{s}, const ComplexRowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator *} (double @var{s}, const ComplexRowVector &@var{a})
@deftypefnx {} {friend ComplexRowVector} {operator /} (double @var{s}, const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn {} {friend Complex} {operator *} (const ComplexRowVector &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend Complex} {operator *} (const ComplexRowVector &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator *} (const ComplexRowVector &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} {operator +} (const ComplexRowVector &@var{a}, const RowVector &@var{b})
@deftypefnx {} {friend ComplexRowVector} {operator -} (const ComplexRowVector &@var{a}, const RowVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} product (const ComplexRowVector &@var{a}, const RowVector &@var{b})
@deftypefnx {} {friend ComplexRowVector} quotient (const ComplexRowVector &@var{a}, const RowVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexRowVector} map (c_c_Mapper @var{f}, const ComplexRowVector &@var{a})
@deftypefnx {} {friend RowVector} map (d_c_Mapper @var{f}, const ComplexRowVector &@var{a})
@deftypefnx {} void map (c_c_Mapper @var{f})
@end deftypefn

@deftypefn {} Complex min (void) const
@deftypefnx {} Complex max (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexRowVector &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexDiagMatrix (void)
@deftypefnx  {} {}ComplexDiagMatrix (int @var{n})
@deftypefnx  {} {}ComplexDiagMatrix (int @var{n}, const Complex &@var{val})
@deftypefnx  {} {}ComplexDiagMatrix (int @var{r}, int @var{c})
@deftypefnx  {} {}ComplexDiagMatrix (int @var{r}, int @var{c}, const Complex &@var{val})
@deftypefnx  {} {}ComplexDiagMatrix (const RowVector &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const ComplexRowVector &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const ColumnVector &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const ComplexColumnVector &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const DiagMatrix &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const DiagArray<Complex> &@var{a})
@deftypefnx  {} {}ComplexDiagMatrix (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexDiagMatrix& {operator =} (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} int {operator ==} (const ComplexDiagMatrix &@var{a}) const
@deftypefnx {} int {operator !=} (const ComplexDiagMatrix &@var{a}) const
@end deftypefn

@deftypefn {} ComplexDiagMatrix& fill (double @var{val})
@deftypefnx {} ComplexDiagMatrix& fill (const Complex &@var{val})
@deftypefnx {} ComplexDiagMatrix& fill (double @var{val}, int @var{beg}, int @var{end})
@deftypefnx {} ComplexDiagMatrix& fill (const Complex &@var{val}, int @var{beg}, int @var{end})
@deftypefnx {} ComplexDiagMatrix& fill (const ColumnVector &@var{a})
@deftypefnx {} ComplexDiagMatrix& fill (const ComplexColumnVector &@var{a})
@deftypefnx {} ComplexDiagMatrix& fill (const RowVector &@var{a})
@deftypefnx {} ComplexDiagMatrix& fill (const ComplexRowVector &@var{a})
@deftypefnx {} ComplexDiagMatrix& fill (const ColumnVector &@var{a}, int @var{beg})
@deftypefnx {} ComplexDiagMatrix& fill (const ComplexColumnVector &@var{a}, int @var{beg})
@deftypefnx {} ComplexDiagMatrix& fill (const RowVector &@var{a}, int @var{beg})
@deftypefnx {} ComplexDiagMatrix& fill (const ComplexRowVector &@var{a}, int @var{beg})
@end deftypefn

@deftypefn {} ComplexDiagMatrix transpose (void) const
@end deftypefn

@deftypefn {} {friend DiagMatrix} real (const ComplexDiagMatrix &@var{a})
@deftypefnx {} {friend DiagMatrix} imag (const ComplexDiagMatrix &@var{a})
@deftypefnx {} {friend ComplexDiagMatrix} conj (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix extract (int r1, int c1, int r2, int c2) const
@end deftypefn

@deftypefn {} ComplexRowVector row (int @var{i}) const
@deftypefnx {} ComplexRowVector row (char *s) const
@end deftypefn

@deftypefn {} ComplexColumnVector column (int @var{i}) const
@deftypefnx {} ComplexColumnVector column (char *s) const
@end deftypefn

@deftypefn {} ComplexDiagMatrix inverse (int &@var{info}) const
@deftypefnx {} ComplexDiagMatrix inverse (void) const
@end deftypefn

@deftypefn {} ComplexDiagMatrix& {operator +=} (const DiagMatrix &@var{a})
@deftypefnx {} ComplexDiagMatrix& {operator -=} (const DiagMatrix &@var{a})
@end deftypefn

@deftypefn {} ComplexDiagMatrix& {operator +=} (const ComplexDiagMatrix &@var{a})
@deftypefnx {} ComplexDiagMatrix& {operator -=} (const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexDiagMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexDiagMatrix &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexDiagMatrix &@var{a}, const Complex &@var{s})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexDiagMatrix &@var{a}, const Complex &@var{s})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator *} (const ComplexDiagMatrix &@var{a}, double @var{s})
@deftypefnx {} {friend ComplexDiagMatrix} {operator /} (const ComplexDiagMatrix &@var{a}, double @var{s})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (double @var{s}, const ComplexDiagMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator -} (double @var{s}, const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const Complex &@var{s}, const ComplexDiagMatrix &@var{a})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const Complex &@var{s}, const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator *} (double @var{s}, const ComplexDiagMatrix &@var{a})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator *} (const ComplexDiagMatrix &@var{a}, const ColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexColumnVector} {operator *} (const ComplexDiagMatrix &@var{a}, const ComplexColumnVector &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} {operator +} (const ComplexDiagMatrix &@var{a}, const DiagMatrix &@var{b})
@deftypefnx {} {friend ComplexDiagMatrix} {operator -} (const ComplexDiagMatrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexDiagMatrix} product (const ComplexDiagMatrix &@var{a}, const DiagMatrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexDiagMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexDiagMatrix &@var{a}, const Matrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexDiagMatrix &@var{a}, const Matrix &@var{b})
@end deftypefn

@deftypefn {} {friend ComplexMatrix} {operator +} (const ComplexDiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator -} (const ComplexDiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@deftypefnx {} {friend ComplexMatrix} {operator *} (const ComplexDiagMatrix &@var{a}, const ComplexMatrix &@var{b})
@end deftypefn

@deftypefn {} ComplexColumnVector diag (void) const
@deftypefnx {} ComplexColumnVector diag (int @var{k}) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexDiagMatrix &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

@node Matrix Factorizations, Nonlinear Functions, Matrix and Vector @var{Operations}, Top
@chapter Matrix Factorizations
@cindex matrix factorizations
@cindex factorizations

@deftypefn  {} {}AEPBALANCE (void)
@deftypefnx  {} {}AEPBALANCE (const Matrix &@var{a}, const char *@var{balance_job})
@deftypefnx  {} {}AEPBALANCE (const AEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} AEPBALANCE& {operator =} (const AEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} Matrix balanced_matrix (void) const
@deftypefnx {} Matrix balancing_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const AEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} ComplexAEPBALANCE (void)
@deftypefnx {} ComplexAEPBALANCE (const ComplexMatrix &@var{a}, const char *@var{balance_job})
@deftypefnx {} ComplexAEPBALANCE (const ComplexAEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} ComplexAEPBALANCE& {operator =} (const ComplexAEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix balanced_matrix (void) const
@deftypefnx {} ComplexMatrix balancing_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexAEPBALANCE &@var{a})
@end deftypefn

@deftypefn  {} {}DET (void)
@deftypefnx  {} {}DET (const DET &@var{a})
@end deftypefn

@deftypefn {} DET& {operator =} (const DET &@var{a})
@end deftypefn

@deftypefn {} int value_will_overflow (void) const
@deftypefnx {} int value_will_underflow (void) const
@end deftypefn

@deftypefn {} double coefficient (void) const
@deftypefnx {} int exponent (void) const
@deftypefnx {} double value (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const DET &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexDET (void)
@deftypefnx  {} {}ComplexDET (const ComplexDET &@var{a})
@end deftypefn

@deftypefn {} ComplexDET& {operator =} (const ComplexDET &@var{a})
@end deftypefn

@deftypefn {} int value_will_overflow (void) const
@deftypefnx {} int value_will_underflow (void) const
@end deftypefn

@deftypefn {} Complex coefficient (void) const
@deftypefnx {} int exponent (void) const
@deftypefnx {} Complex value (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexDET &@var{a})
@end deftypefn

@deftypefn  {} {}GEPBALANCE (void)
@deftypefnx  {} {}GEPBALANCE (const Matrix &@var{a}, const Matrix &, const char *@var{balance_job})
@deftypefnx  {} {}GEPBALANCE (const GEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} GEPBALANCE& {operator =} (const GEPBALANCE &@var{a})
@end deftypefn

@deftypefn {} Matrix balanced_a_matrix (void) const
@deftypefnx {} Matrix balanced_b_matrix (void) const
@deftypefnx {} Matrix left_balancing_matrix (void) const
@deftypefnx {} Matrix right_balancing_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const GEPBALANCE &@var{a})
@end deftypefn

@deftypefn  {} {}CHOL (void)
@deftypefnx  {} {}CHOL (const Matrix &@var{a})
@deftypefnx  {} {}CHOL (const Matrix &@var{a}, int &@var{info})
@deftypefnx  {} {}CHOL (const CHOL &@var{a})
@end deftypefn

@deftypefn {} CHOL& {operator =} (const CHOL &@var{a})
@end deftypefn

@deftypefn {} Matrix chol_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const CHOL &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexCHOL (void)
@deftypefnx  {} {}ComplexCHOL (const ComplexMatrix &@var{a})
@deftypefnx  {} {}ComplexCHOL (const ComplexMatrix &@var{a}, int &@var{info})
@deftypefnx  {} {}ComplexCHOL (const ComplexCHOL &@var{a})
@end deftypefn

@deftypefn {} ComplexCHOL& {operator =} (const ComplexCHOL &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix chol_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexCHOL &@var{a})
@end deftypefn

@deftypefn  {} {}HESS (void)
@deftypefnx  {} {}HESS (const Matrix &@var{a})
@deftypefnx  {} {}HESS (const Matrix&a, int &@var{info})
@deftypefnx  {} {}HESS (const HESS &@var{a})
@end deftypefn

@deftypefn {} HESS& {operator =} (const HESS &@var{a})
@end deftypefn

@deftypefn {} Matrix hess_matrix (void) const
@deftypefnx {} Matrix unitary_hess_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const HESS &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexHESS (void)
@deftypefnx  {} {}ComplexHESS (const ComplexMatrix &@var{a})
@deftypefnx  {} {}ComplexHESS (const ComplexMatrix &@var{a}, int &@var{info})
@deftypefnx  {} {}ComplexHESS (const ComplexHESS &@var{a})
@end deftypefn

@deftypefn {} ComplexHESS& {operator =} (const ComplexHESS &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix hess_matrix (void) const
@deftypefnx {} ComplexMatrix unitary_hess_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexHESS &@var{a})
@end deftypefn

@deftypefn  {} {}SCHUR (void)
@deftypefnx  {} {}SCHUR (const Matrix &@var{a}, const char *@var{ord})
@deftypefnx  {} {}SCHUR (const Matrix &@var{a}, const char *@var{ord}, int &@var{info})
@deftypefnx  {} {}SCHUR (const SCHUR &@var{a}, const char *@var{ord})
@end deftypefn

@deftypefn {} SCHUR& {operator =} (const SCHUR &@var{a})
@end deftypefn

@deftypefn {} Matrix schur_matrix (void) const
@deftypefnx {} Matrix unitary_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const SCHUR &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexSCHUR (void)
@deftypefnx  {} {}ComplexSCHUR (const ComplexMatrix &@var{a}, const char *@var{ord})
@deftypefnx  {} {}ComplexSCHUR (const ComplexMatrix &@var{a}, const char *@var{ord}, int &@var{info})
@deftypefnx  {} {}ComplexSCHUR (const ComplexSCHUR &@var{a}, const char *@var{ord})
@end deftypefn

@deftypefn {} ComplexSCHUR& {operator =} (const ComplexSCHUR &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix schur_matrix (void) const
@deftypefnx {} ComplexMatrix unitary_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexSCHUR &@var{a})
@end deftypefn

@deftypefn  {} {}SVD (void)
@deftypefnx  {} {}SVD (const Matrix &@var{a})
@deftypefnx  {} {}SVD (const Matrix &@var{a}, int &@var{info})
@deftypefnx  {} {}SVD (const SVD &@var{a})
@end deftypefn

@deftypefn {} SVD& {operator =} (const SVD &@var{a})
@end deftypefn

@deftypefn {} DiagMatrix singular_values (void) const
@deftypefnx {} Matrix left_singular_matrix (void) const
@deftypefnx {} Matrix right_singular_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const SVD &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexSVD (void)
@deftypefnx  {} {}ComplexSVD (const ComplexMatrix &@var{a})
@deftypefnx  {} {}ComplexSVD (const ComplexMatrix &@var{a}, int &@var{info})
@deftypefnx  {} {}ComplexSVD (const ComplexSVD &@var{a})
@end deftypefn

@deftypefn {} ComplexSVD& {operator =} (const ComplexSVD &@var{a})
@end deftypefn

@deftypefn {} DiagMatrix singular_values (void) const
@deftypefnx {} ComplexMatrix left_singular_matrix (void) const
@deftypefnx {} ComplexMatrix right_singular_matrix (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexSVD &@var{a})
@end deftypefn

@deftypefn  {} {}EIG (void)
@deftypefnx  {} {}EIG (const Matrix &@var{a})
@deftypefnx  {} {}EIG (const Matrix &@var{a}, int &@var{info})
@deftypefnx  {} {}EIG (const ComplexMatrix &@var{a})
@deftypefnx  {} {}EIG (const ComplexMatrix &@var{a}, int &@var{info})
@deftypefnx  {} {}EIG (const EIG &@var{a})
@end deftypefn

@deftypefn {} EIG& {operator =} (const EIG &@var{a})
@end deftypefn

@deftypefn {} ComplexColumnVector eigenvalues (void) const
@end deftypefn

@deftypefn {} ComplexMatrix eigenvectors (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const EIG &@var{a})
@end deftypefn

@deftypefn  {} {}LU (void)
@deftypefnx  {} {}LU (const Matrix &@var{a})
@deftypefnx  {} {}LU (const LU &@var{a})
@end deftypefn

@deftypefn {} LU& {operator =} (const LU &@var{a})
@end deftypefn

@deftypefn {} Matrix L (void) const
@deftypefnx {} Matrix U (void) const
@deftypefnx {} Matrix P (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const LU &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexLU (void)
@deftypefnx  {} {}ComplexLU (const ComplexMatrix &@var{a})
@deftypefnx  {} {}ComplexLU (const ComplexLU &@var{a})
@end deftypefn

@deftypefn {} ComplexLU& {operator =} (const ComplexLU &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix L (void) const
@deftypefnx {} ComplexMatrix U (void) const
@deftypefnx {} Matrix P (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexLU &@var{a})
@end deftypefn

@deftypefn  {} {}QR (void)
@deftypefnx  {} {}QR (const Matrix &@var{A})
@deftypefnx  {} {}QR (const QR &@var{a})
@end deftypefn

@deftypefn {} QR& {operator =} (const QR &@var{a})
@end deftypefn

@deftypefn {} Matrix Q (void) const
@deftypefnx {} Matrix R (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const QR &@var{a})
@end deftypefn

@deftypefn  {} {}ComplexQR (void)
@deftypefnx  {} {}ComplexQR (const ComplexMatrix &@var{A})
@deftypefnx  {} {}ComplexQR (const ComplexQR &@var{a})
@end deftypefn

@deftypefn {} ComplexQR& {operator =} (const ComplexQR &@var{a})
@end deftypefn

@deftypefn {} ComplexMatrix Q (void) const
@deftypefnx {} ComplexMatrix R (void) const
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const ComplexQR &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

@node Nonlinear Functions, Objective Functions, Matrix Factorizations, Top
@chapter Nonlinear Functions
@cindex nonlinear functions

@deftypefn  {} {}NLFunc (void)
@deftypefnx  {} {}NLFunc (const @var{nonlinear_fcn})
@deftypefnx  {} {}NLFunc (const @var{nonlinear_fcn}, const @var{jacobian_fcn})
@deftypefnx  {} {}NLFunc (const NLFunc &@var{a})
@end deftypefn

@deftypefn {} NLFunc& {operator =} (const NLFunc &@var{a})
@end deftypefn

@deftypefn {} nonlinear_fcn function (void) const;
@end deftypefn

@deftypefn {} NLFunc& set_function (const nonlinear_fcn @var{f})
@end deftypefn

@deftypefn {} jacobian_fcn jacobian_function (void) const;
@end deftypefn

@deftypefn {} NLFunc& set_jacobian_function (const jacobian_fcn @var{j})
@end deftypefn

@c ------------------------------------------------------------------------

@node Objective Functions, Bounds, Nonlinear Functions, Top
@chapter Objective Functions
@cindex objective functions

@deftypefn  {} {}Objective (void)
@deftypefnx  {} {}Objective (const @var{objective_fcn})
@deftypefnx  {} {}Objective (const @var{objective_fcn}, const @var{gradient_fcn})
@deftypefnx  {} {}Objective (const Objective &@var{a})
@end deftypefn

@deftypefn {} Objective& {operator =} (const Objective &@var{a})
@end deftypefn

@deftypefn {} objective_fcn objective_function (void) const;
@end deftypefn

@deftypefn {} Objective& set_objective_function (const @var{objective_fcn})
@end deftypefn

@deftypefn {} gradient_fcn gradient_function (void) const;
@end deftypefn

@deftypefn {} Objective& set_gradient_function (const @var{gradient_fcn})
@end deftypefn

@c ------------------------------------------------------------------------

@node Bounds, Linear Constraints, Objective Functions, Top
@chapter Bounds
@cindex bounds

@deftypefn  {} {}Bounds (void)
@deftypefnx  {} {}Bounds (int @var{n})
@deftypefnx  {} {}Bounds (const ColumnVector @var{lb}, const ColumnVector @var{ub})
@deftypefnx  {} {}Bounds (const Bounds &@var{a})
@end deftypefn

@deftypefn {} Bounds& {operator =} (const Bounds &@var{a})
@end deftypefn

@deftypefn {} Bounds& resize (int @var{n})
@end deftypefn

@deftypefn {} double lower_bound (int @var{index}) const;
@deftypefnx {} double upper_bound (int @var{index}) const;
@end deftypefn

@deftypefn {} ColumnVector lower_bounds (void) const;
@deftypefnx {} ColumnVector upper_bounds (void) const;
@end deftypefn

@deftypefn {} int size (void) const;
@end deftypefn

@deftypefn {} Bounds& set_bound (int @var{index}, double @var{low}, double @var{high})
@end deftypefn

@deftypefn {} Bounds& set_bounds (double @var{low}, double @var{high})
@deftypefnx {} Bounds& set_bounds (const ColumnVector @var{lb}, const ColumnVector @var{ub})
@end deftypefn

@deftypefn {} Bounds& set_lower_bound (int @var{index}, double @var{low})
@deftypefnx {} Bounds& set_upper_bound (int @var{index}, double @var{high})
@end deftypefn

@deftypefn {} Bounds& set_lower_bounds (double @var{low})
@deftypefnx {} Bounds& set_upper_bounds (double @var{high})
@end deftypefn

@deftypefn {} Bounds& set_lower_bounds (const ColumnVector @var{lb})
@deftypefnx {} Bounds& set_upper_bounds (const ColumnVector @var{ub})
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const Bounds &@var{b})
@end deftypefn

@c ------------------------------------------------------------------------

@node Linear Constraints, Nonlinear Constraints, Bounds, Top
@chapter Linear Constraints
@cindex linear Constraints

@deftypefn  {} {}LinConst (void)
@deftypefnx  {} {}LinConst (int @var{nclin}, int @var{nx})
@deftypefnx  {} {}LinConst (int @var{nclin_eq}, int @var{nclin_ineq}, int @var{nx})
@deftypefnx  {} {}LinConst (const ColumnVector &@var{lb}, const Matrix &@var{A}, const ColumnVector &@var{ub})
@deftypefnx  {} {}LinConst (const Matrix &@var{A_eq}, const ColumnVector &@var{b_eq}, const Matrix &@var{A_ineq}, const ColumnVector &@var{b_ineq})
@deftypefnx  {} {}LinConst (const LinConst &@var{a})
@end deftypefn

@deftypefn {} LinConst& {operator =} (const LinConst &@var{a})
@end deftypefn

@deftypefn {} LinConst& resize (int @var{nclin}, int @var{n})
@end deftypefn

@deftypefn {} Matrix constraint_matrix (void) const;
@end deftypefn

@deftypefn {} LinConst& set_constraint_matrix (const Matrix &@var{A})
@end deftypefn

@deftypefn {} Matrix eq_constraint_matrix (void) const;
@deftypefnx {} Matrix ineq_constraint_matrix (void) const;
@end deftypefn

@deftypefn {} ColumnVector eq_constraint_vector (void) const;
@deftypefnx {} ColumnVector ineq_constraint_vector (void) const;
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const LinConst &@var{b})
@end deftypefn

@c ------------------------------------------------------------------------

@node Nonlinear Constraints, Nonlinear Equations, Linear Constraints, Top
@chapter Nonlinear Constraints
@cindex nonlinear Constraints

@deftypefn  {} {}NLConst (void)
@deftypefnx  {} {}NLConst (int @var{n})
@deftypefnx  {} {}NLConst (const ColumnVector @var{lb}, const NLFunc @var{f}, const ColumnVector @var{ub})
@deftypefnx  {} {}NLConst (const NLConst &@var{a})
@end deftypefn

@deftypefn {} NLConst& {operator =} (const NLConst &@var{a})
@end deftypefn

@c ------------------------------------------------------------------------

@node Nonlinear Equations, Ordinary Differential Equations, Nonlinear Constraints, Top
@chapter Nonlinear Equations
@cindex nonlinear equations

@deftypefn  {} {}NLEqn_options (void)
@deftypefnx  {} {}NLEqn_options (const NLEqn_options &@var{opt})
@end deftypefn

@deftypefn {} NLEqn_options& {operator =} (const NLEqn_options &@var{opt})
@end deftypefn

@deftypefn {} void init (void)
@end deftypefn

@deftypefn {} void copy (const NLEqn_options &@var{opt})
@end deftypefn

@deftypefn {} void set_default_options (void)
@end deftypefn

@deftypefn {} void set_tolerance (double @var{val})
@end deftypefn

@deftypefn {} double tolerance (void)
@end deftypefn

@deftypefn  {} {}NLEqn (void)
@deftypefnx  {} {}NLEqn (const ColumnVector&, const @var{NLFunc})
@deftypefnx  {} {}NLEqn (const NLEqn &@var{a})
@end deftypefn

@deftypefn {} NLEqn& {operator =} (const NLEqn &@var{a})
@end deftypefn

@deftypefn {} void resize (int @var{n})
@end deftypefn

@deftypefn {} void set_states (const ColumnVector &@var{x})
@end deftypefn

@deftypefn {} ColumnVector states (void) const
@end deftypefn

@deftypefn {} int size (void) const
@end deftypefn

@deftypefn {} ColumnVector solve (void)
@deftypefnx {} ColumnVector solve (const ColumnVector &@var{x})
@end deftypefn

@deftypefn {} ColumnVector solve (int &@var{info})
@deftypefnx{} ColumnVector solve (const ColumnVector &@var{x}, int &@var{info})
@end deftypefn

@c ------------------------------------------------------------------------

@node Ordinary Differential Equations, Differential Algebraic Equations, Nonlinear Equations, Top
@chapter Ordinary Differential Equations
@cindex ODE

@deftypefn  {} {}ODE_options (void)
@deftypefnx  {} {}ODE_options (const ODE_options &@var{opt})
@end deftypefn

@deftypefn {} ODE_options& {operator =} (const ODE_options &@var{opt})
@end deftypefn

@deftypefn {} void init (void)
@end deftypefn

@deftypefn {} void copy (const ODE_options &@var{opt})
@end deftypefn

@deftypefn {} void set_default_options (void)
@end deftypefn

@deftypefn {} void set_absolute_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_initial_step_size (double @var{val})
@end deftypefn

@deftypefn {} void set_maximum_step_size (double @var{val})
@end deftypefn

@deftypefn {} void set_minimum_step_size (double @var{val})
@end deftypefn

@deftypefn {} void set_relative_tolerance (double @var{val})
@end deftypefn

@deftypefn {} double absolute_tolerance (void)
@deftypefnx {} double initial_step_size (void)
@deftypefnx {} double maximum_step_size (void)
@deftypefnx {} double minimum_step_size (void)
@deftypefnx {} double relative_tolerance (void)
@end deftypefn

@deftypefn  {} {}ODE (void)
@deftypefnx  {} {}ODE (int @var{n})
@deftypefnx  {} {}ODE (const ColumnVector &@var{state}, double @var{time}, const ODEFunc &@var{f})
@end deftypefn

@deftypefn {} {virtual int} size (void) const
@end deftypefn

@deftypefn {} {virtual ColumnVector} state (void) const
@end deftypefn

@deftypefn {} {virtual double} time (void) const
@end deftypefn

@deftypefn {} {virtual void} force_restart (void)
@end deftypefn

@deftypefn {} {virtual void} initialize (const ColumnVector &@var{x}, double @var{t})
@end deftypefn

@deftypefn {} {virtual void} set_stop_time (double @var{t})
@end deftypefn

@deftypefn {} {virtual void} clear_stop_time (void)
@end deftypefn

@deftypefn {} {virtual ColumnVector} integrate (double @var{t})
@end deftypefn

@deftypefn {} void integrate (int @var{nsteps}, double @var{tstep}, ostream &@var{s})
@end deftypefn

@deftypefn {} Matrix integrate (const ColumnVector &@var{tout})
@deftypefnx {} Matrix integrate (const ColumnVector &@var{tout}, const ColumnVector &@var{tcrit})
@end deftypefn

@c ------------------------------------------------------------------------

@node Differential Algebraic Equations, Quadrature, Ordinary Differential Equations, Top
@chapter Differential Algebraic Equations
@cindex DAE

@deftypefn  {} {}DAE (void)
@deftypefnx  {} {}DAE (int @var{n})
@deftypefnx  {} {}DAE (const ColumnVector &@var{x}, double @var{time}, DAEFunc &@var{f})
@deftypefnx  {} {}DAE (const ColumnVector &@var{x}, ColumnVector &@var{xdot}, double @var{time}, DAEFunc &@var{f})
@end deftypefn

@deftypefn {} ColumnVector deriv (void)
@end deftypefn

@deftypefn {} {virtual void} initialize (const ColumnVector &@var{x}, double @var{t})
@deftypefnx {} {virtual void} initialize (const ColumnVector &@var{x}, ColumnVector &@var{xdot}, double @var{t})
@end deftypefn

@deftypefn {} ColumnVector integrate (double @var{t})
@end deftypefn

@deftypefn {} Matrix integrate (const ColumnVector &@var{tout}, Matrix &@var{xdot_out})
@deftypefnx {} Matrix integrate (const ColumnVector &@var{tout}, Matrix &@var{xdot_out}, const ColumnVector &@var{tcrit})
@end deftypefn

@c ------------------------------------------------------------------------

@node Quadrature, Quadratic Programming, Differential Algebraic Equations, Top
@chapter Quadrature
@cindex quadrature
@cindex numerical integration
@cindex integration

@deftypefn  {} {}Quad (integrand_fcn @var{fcn})
@deftypefnx  {} {}Quad (integrand_fcn @var{fcn}, double @var{abs}, double @var{rel})
@end deftypefn

@deftypefn {} {virtual double} integrate (void)
@deftypefnx {} {virtual double} integrate (int &@var{ier})
@deftypefnx {} {virtual double} integrate (int &@var{ier}, int &@var{neval})
@deftypefnx {} {virtual double} integrate (int &@var{ier}, int &@var{neval}, double &@var{abserr}) = 0
@end deftypefn

@deftypefn {} Quad_options (void)
@deftypefnx {} Quad_options (const Quad_options &@var{opt})
@end deftypefn

@deftypefn {} Quad_options& {operator =} (const Quad_options &@var{opt})
@end deftypefn

@deftypefn {} void init (void)
@end deftypefn

@deftypefn {} void copy (const Quad_options &@var{opt})
@end deftypefn

@deftypefn {} void set_default_options (void)
@end deftypefn

@deftypefn {} void set_absolute_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_relative_tolerance (double @var{val})
@end deftypefn

@deftypefn {} double absolute_tolerance (void)
@deftypefnx {} double relative_tolerance (void)
@end deftypefn

@deftypefn  {} {}DefQuad (integrand_fcn @var{fcn})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, double @var{ll}, double @var{ul})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, double @var{ll}, double @var{ul}, double @var{abs}, double @var{rel})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, double @var{ll}, double @var{ul}, const ColumnVector &@var{sing})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, const ColumnVector &@var{sing}, double @var{abs}, double @var{rel})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, const ColumnVector &@var{sing})
@deftypefnx  {} {}DefQuad (integrand_fcn @var{fcn}, double @var{ll}, double @var{ul}, const ColumnVector &@var{sing}, double @var{abs}, double @var{rel})
@end deftypefn

@deftypefn  {} {}IndefQuad (integrand_fcn @var{fcn})
@deftypefnx  {} {}IndefQuad (integrand_fcn @var{fcn}, double @var{b}, IntegralType @var{t})
@deftypefnx  {} {}IndefQuad (integrand_fcn @var{fcn}, double @var{b}, IntegralType @var{t}, double @var{abs}, double @var{rel})
@deftypefnx  {} {}IndefQuad (integrand_fcn @var{fcn}, double @var{abs}, double @var{rel})
@end deftypefn

@c ------------------------------------------------------------------------

@node Quadratic Programming, Nonlinear Programming, Quadrature, Top
@chapter Quadratic Programming
@cindex QP
@cindex quadratic programming

@deftypefn  {} {}QP (void)
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const Bounds &@var{b})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const LinConst &@var{lc})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const Bounds &@var{b})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const LinConst &@var{lc})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const Bounds &@var{b}, const LinConst &@var{lc})
@deftypefnx  {} {}QP (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const Bounds &@var{b}, const LinConst &@var{lc})
@end deftypefn

@deftypefn {} {virtual ColumnVector} minimize (void)
@deftypefnx {} {virtual ColumnVector} minimize (double &@var{objf})
@deftypefnx {} {virtual ColumnVector} minimize (double &@var{objf}, int &@var{inform})
@deftypefnx {} {virtual ColumnVector} minimize (double &@var{objf}, int &@var{inform}, ColumnVector &@var{lambda}) = 0;
@end deftypefn

@deftypefn {} {virtual ColumnVector} minimize (const ColumnVector &@var{x})
@deftypefnx {} {virtual ColumnVector} minimize (const ColumnVector &@var{x}, double &@var{objf})
@deftypefnx {} {virtual ColumnVector} minimize (const ColumnVector &@var{x}, double &@var{objf}, int &@var{inform})
@deftypefnx {} {virtual ColumnVector} minimize (const ColumnVector &@var{x}, double &@var{objf}, int &@var{inform}, ColumnVector &@var{lambda})
@end deftypefn

@deftypefn  {} {}QPSOL_options (void)
@deftypefnx  {} {}QPSOL_options (const QPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} QPSOL_options& {operator =} (const QPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} void init (void)
@end deftypefn

@deftypefn {} void copy (const QPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} void set_default_options (void)
@end deftypefn

@deftypefn {} void set_feasibility_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_infinite_bound (double @var{val})
@end deftypefn

@deftypefn {} void set_iteration_limit (int @var{val})
@end deftypefn

@deftypefn {} void set_print_level (int @var{val})
@end deftypefn

@deftypefn {} double feasibility_tolerance (void)
@deftypefnx {} double infinite_bound (void)
@deftypefnx {} int iteration_limit (void)
@deftypefnx {} int print_level (void)
@end deftypefn

@deftypefn  {} {}QPSOL (void)
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const Bounds &@var{b})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const LinConst &@var{lc})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const Bounds &@var{b})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const LinConst &@var{lc})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const Bounds &@var{b}, const LinConst &@var{lc})
@deftypefnx  {} {}QPSOL (const ColumnVector &@var{x}, const Matrix &@var{H}, const ColumnVector &@var{c}, const Bounds &@var{b}, const LinConst &@var{lc})
@deftypefnx  {} {}QPSOL (const QPSOL &@var{a})
@end deftypefn

@deftypefn {} QPSOL& {operator =} (const QPSOL &@var{a})
@end deftypefn

@deftypefn {} ColumnVector minimize (double &@var{objf}, int &@var{inform}, ColumnVector &@var{lambda})
@end deftypefn

@c ------------------------------------------------------------------------

@node Nonlinear Programming, Collocation Weights, Quadratic Programming, Top
@chapter Nonlinear Programming
@cindex NLP
@cindex nonlinear programming

@deftypefn  {} {}NLP (void)
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const LinConst &@var{lc})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const LinConst &@var{lc}, const NLConst &@var{nlc})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const LinConst &@var{lc})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const LinConst &@var{lc}, const NLConst &@var{nlc})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const NLConst &@var{nlc})
@deftypefnx  {} {}NLP (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const NLConst &@var{nlc})
@end deftypefn

@deftypefn {} NLP& {operator =} (const NLP &@var{a})
@end deftypefn

@deftypefn {} int size (void) const
@end deftypefn

@deftypefn  {} {}NPSOL_options (void)
@deftypefnx  {} {}NPSOL_options (const NPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} NPSOL_options& {operator =} (const NPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} void init (void)
@deftypefnx {} void copy (const NPSOL_options &@var{opt})
@end deftypefn

@deftypefn {} void set_default_options (void)
@end deftypefn

@deftypefn {} void set_central_difference_interval (double @var{val})
@end deftypefn

@deftypefn {} void set_crash_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_difference_interval (double @var{val})
@end deftypefn

@deftypefn {} void set_function_precision (double @var{val})
@end deftypefn

@deftypefn {} void set_infinite_bound (double @var{val})
@end deftypefn

@deftypefn {} void set_infinite_step (double @var{val})
@end deftypefn

@deftypefn {} void set_linear_feasibility_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_linesearch_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_nonlinear_feasibility_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_optimality_tolerance (double @var{val})
@end deftypefn

@deftypefn {} void set_derivative_level (int @var{val})
@end deftypefn

@deftypefn {} void set_major_iteration_limit (int @var{val})
@end deftypefn

@deftypefn {} void set_minor_iteration_limit (int @var{val})
@end deftypefn

@deftypefn {} void set_major_print_level (int @var{val})
@end deftypefn

@deftypefn {} void set_minor_print_level (int @var{val})
@end deftypefn

@deftypefn {} void set_start_objective_check (int @var{val})
@end deftypefn

@deftypefn {} void set_start_constraint_check (int @var{val})
@end deftypefn

@deftypefn {} void set_stop_objective_check (int @var{val})
@end deftypefn

@deftypefn {} void set_stop_constraint_check (int @var{val})
@end deftypefn

@deftypefn {} void set_verify_level (int @var{val})
@end deftypefn

@deftypefn {} double central_difference_interval (void) const
@deftypefnx {} double crash_tolerance (void) const
@deftypefnx {} double difference_interval (void) const
@deftypefnx {} double function_precision (void) const
@deftypefnx {} double infinite_bound (void) const
@deftypefnx {} double infinite_step (void) const
@deftypefnx {} double linear_feasibility_tolerance (void) const
@deftypefnx {} double linesearch_tolerance (void) const
@deftypefnx {} double nonlinear_feasibility_tolerance (void) const
@deftypefnx {} double optimality_tolerance (void) const
@deftypefnx {} int derivative_level (void) const
@deftypefnx {} int major_iteration_limit (void) const
@deftypefnx {} int minor_iteration_limit (void) const
@deftypefnx {} int major_print_level (void) const
@deftypefnx {} int minor_print_level (void) const
@deftypefnx {} int start_objective_check (void) const
@deftypefnx {} int start_constraint_check (void) const
@deftypefnx {} int stop_objective_check (void) const
@deftypefnx {} int stop_constraint_check (void) const
@deftypefnx {} int verify_level (void) const
@end deftypefn

@deftypefn  {} {}NPSOL (void)
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const LinConst &@var{lc})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const LinConst &@var{lc}, const NLConst &@var{nlc})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const LinConst &@var{lc})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const LinConst &@var{lc}, const NLConst &@var{nlc})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const NLConst &@var{nlc})
@deftypefnx  {} {}NPSOL (const ColumnVector &@var{x}, const Objective &@var{phi}, const Bounds &@var{b}, const NLConst &@var{nlc})
@deftypefnx  {} {}NPSOL (const NPSOL &@var{a})
@end deftypefn

@deftypefn {} ColumnVector minimize (void)
@deftypefnx {} ColumnVector minimize (double &@var{objf})
@deftypefnx {} ColumnVector minimize (double &@var{objf}, int &@var{inform})
@deftypefnx {} ColumnVector minimize (double &@var{objf}, int &@var{inform}, ColumnVector &@var{lambda})
@end deftypefn

@deftypefn {} ColumnVector minimize (const ColumnVector &@var{x})
@deftypefnx {} ColumnVector minimize (const ColumnVector &@var{x}, double &@var{objf})
@deftypefnx {} ColumnVector minimize (const ColumnVector &@var{x}, double &@var{objf}, int &@var{inform})
@deftypefnx {} ColumnVector minimize (const ColumnVector &@var{x}, double &@var{objf}, int &@var{inform}, ColumnVector &@var{lambda})
@end deftypefn

@c ------------------------------------------------------------------------

@node Collocation Weights, Ranges, Nonlinear Programming, Top
@chapter Collocation Weights
@cindex orthogonal collocation
@cindex collocation weights

@deftypefn  {} {}CollocWt (void)
@deftypefnx  {} {}CollocWt (int @var{n}, int @var{inc_l}, int @var{inc_r})
@deftypefnx  {} {}CollocWt (int @var{n}, int @var{inc_l}, int @var{inc_r}, double @var{l}, double @var{r})
@deftypefnx  {} {}CollocWt (int @var{n}, double @var{a}, double @var{b}, int @var{inc_l}, int @var{inc_r})
@deftypefnx  {} {}CollocWt (int @var{n}, int @var{inc_l}, int @var{inc_r}, double @var{l}, double @var{r})
@deftypefnx  {} {}CollocWt (const CollocWt&)
@end deftypefn

@deftypefn {} CollocWt& {operator =} (const CollocWt&)
@end deftypefn

@deftypefn {} CollocWt& resize (int @var{ncol})
@end deftypefn

@deftypefn {} CollocWt& add_left (void)
@deftypefnx {} CollocWt& add_right (void)
@end deftypefn

@deftypefn {} CollocWt& delete_left (void)
@deftypefnx {} CollocWt& delete_right (void)
@end deftypefn

@deftypefn {} CollocWt& set_left (double @var{val})
@deftypefnx {} CollocWt& set_right (double @var{val})
@end deftypefn

@deftypefn {} CollocWt& set_alpha (double @var{val})
@deftypefnx {} CollocWt& set_beta (double @var{val})
@end deftypefn

@deftypefn {} int ncol (void) const
@end deftypefn

@deftypefn {} int left_included (void) const
@deftypefnx {} int right_included (void) const
@end deftypefn

@deftypefn {} double left (void) const
@deftypefnx {} double right (void) const
@deftypefnx {} double width (void) const
@end deftypefn

@deftypefn {} double alpha (void) const
@deftypefnx {} double beta (void) const
@end deftypefn

@deftypefn {} ColumnVector roots (void)
@deftypefnx {} ColumnVector quad (void)
@deftypefnx {} ColumnVector quad_weights (void)
@end deftypefn

@deftypefn {} Matrix first (void)
@deftypefnx {} Matrix second (void)
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const CollocWt &@var{c})
@end deftypefn

@c ------------------------------------------------------------------------

@node Ranges, Installation, Collocation Weights, Top
@chapter Ranges
@cindex ranges

@deftypefn  {} {}Range (void)
@deftypefnx  {} {}Range (const Range &@var{r})
@deftypefnx  {} {}Range (double @var{b}, double @var{l})
@deftypefnx  {} {}Range (double @var{b}, double @var{l}, double @var{i})
@end deftypefn

@deftypefn {} double base (void) const
@deftypefnx {} double limit (void) const
@deftypefnx {} double inc (void) const
@end deftypefn

@deftypefn {} void set_base (double @var{b})
@deftypefnx {} void set_limit (double @var{l})
@deftypefnx {} void set_inc (double @var{i})
@end deftypefn

@deftypefn {} int nelem (void) const
@end deftypefn

@deftypefn {} double min (void) const
@deftypefnx {} double max (void) const
@end deftypefn

@deftypefn {} void sort (void)
@end deftypefn

@deftypefn {} {friend ostream&} {operator <<} (ostream &@var{os}, const Range &@var{r})
@deftypefnx {} {friend istream&} {operator >>} (istream &@var{is}, Range &@var{r})
@end deftypefn

@deftypefn {} void print_range (void)
@end deftypefn

@c ------------------------------------------------------------------------

@node Installation, Bugs, Ranges, Top
@chapter Installation
@cindex installation

@c ------------------------------------------------------------------------

@node Bugs, Concept Index, Installation, Top
@chapter Bugs
@cindex bugs, known
@cindex installation trouble
@cindex known causes of trouble
@cindex troubleshooting

@c ------------------------------------------------------------------------

@node Concept Index, Function Index, Bugs, Top
@unnumbered Concept Index

@printindex cp

@c ------------------------------------------------------------------------

@node Function Index,  , Concept Index, Top
@unnumbered Function Index

@printindex fn

@contents

@bye
