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

Element by element vector by scalar ops.

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

Element by element scalar by vector ops.

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

Element by element vector by vector ops.

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

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

Unary MArray ops.

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

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

Element by element matrix by scalar ops.

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

Element by element scalar by matrix ops.

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

Element by element matrix by matrix ops.

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

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

Unary matrix ops.

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

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

Element by element MDiagArray by scalar ops.

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

Element by element scalar by MDiagArray ops.

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

Element by element MDiagArray by MDiagArray ops.

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

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

Unary MDiagArray ops.

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

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

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

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

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

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

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

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

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

 -- Matrix: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- Matrix: operator ! (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- RowVector: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- ColumnVector: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- DiagMatrix: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- ComplexMatrix: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- Matrix: operator ! (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- ComplexRowVector: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- ComplexColumnVector: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 -- ComplexDiagMatrix: transpose (void) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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