#include <newmat.h>

Inheritance diagram for CroutMatrix:

Public Member Functions
	CroutMatrix (const BaseMatrix &)

MatrixType	Type () const

void	lubksb (Real *, int=0)

	~CroutMatrix ()

GeneralMatrix *	MakeSolver ()

LogAndSign	LogDeterminant () const

void	Solver (MatrixColX &, const MatrixColX &)

void	GetRow (MatrixRowCol &)

void	GetCol (MatrixRowCol &)

void	GetCol (MatrixColX &c)

void	CleanUp ()

void	MiniCleanUp ()

bool	IsEqual (const GeneralMatrix &) const

bool	IsSingular () const

Public Member Functions inherited from GeneralMatrix
GeneralMatrix *	Evaluate (MatrixType mt=MatrixTypeUnSp)

int	Nrows () const

int	Ncols () const

int	Storage () const

Real *	Store () const

virtual	~GeneralMatrix ()

void	tDelete ()

bool	reuse ()

void	Protect ()

int	Tag () const

bool	IsZero () const

void	Release ()

void	Release (int t)

void	ReleaseAndDelete ()

void	operator<< (const Real *)

void	operator<< (const int *)

void	operator<< (const BaseMatrix &X)

void	Inject (const GeneralMatrix &)

void	operator+= (const BaseMatrix &)

void	operator-= (const BaseMatrix &)

void	operator*= (const BaseMatrix &)

void	operator\|= (const BaseMatrix &)

void	operator &= (const BaseMatrix &)

void	operator+= (Real)

void	operator-= (Real r)

void	operator*= (Real)

void	operator/= (Real r)

virtual void	RestoreRow (MatrixRowCol &)

virtual void	NextRow (MatrixRowCol &)

virtual void	RestoreCol (MatrixRowCol &)

virtual void	RestoreCol (MatrixColX &)

virtual void	NextCol (MatrixRowCol &)

virtual void	NextCol (MatrixColX &)

Real	SumSquare () const

Real	SumAbsoluteValue () const

Real	Sum () const

Real	MaximumAbsoluteValue1 (int &i) const

Real	MinimumAbsoluteValue1 (int &i) const

Real	Maximum1 (int &i) const

Real	Minimum1 (int &i) const

Real	MaximumAbsoluteValue () const

Real	MaximumAbsoluteValue2 (int &i, int &j) const

Real	MinimumAbsoluteValue () const

Real	MinimumAbsoluteValue2 (int &i, int &j) const

Real	Maximum () const

Real	Maximum2 (int &i, int &j) const

Real	Minimum () const

Real	Minimum2 (int &i, int &j) const

void	CheckStore () const

virtual void	SetParameters (const GeneralMatrix *)

	operator ReturnMatrix () const

ReturnMatrix	ForReturn () const

virtual bool	SameStorageType (const GeneralMatrix &A) const

virtual void	ReSizeForAdd (const GeneralMatrix &A, const GeneralMatrix &B)

virtual void	ReSizeForSP (const GeneralMatrix &A, const GeneralMatrix &B)

virtual void	ReSize (const GeneralMatrix &A)

MatrixInput	operator<< (Real)

MatrixInput	operator<< (int f)

Public Member Functions inherited from BaseMatrix
AddedMatrix	operator+ (const BaseMatrix &) const

MultipliedMatrix	operator* (const BaseMatrix &) const

SubtractedMatrix	operator- (const BaseMatrix &) const

ConcatenatedMatrix	operator\| (const BaseMatrix &) const

StackedMatrix	operator & (const BaseMatrix &) const

ShiftedMatrix	operator+ (Real) const

ScaledMatrix	operator* (Real) const

ScaledMatrix	operator/ (Real) const

ShiftedMatrix	operator- (Real) const

TransposedMatrix	t () const

NegatedMatrix	operator- () const

ReversedMatrix	Reverse () const

InvertedMatrix	i () const

RowedMatrix	AsRow () const

ColedMatrix	AsColumn () const

DiagedMatrix	AsDiagonal () const

MatedMatrix	AsMatrix (int, int) const

GetSubMatrix	SubMatrix (int, int, int, int) const

GetSubMatrix	SymSubMatrix (int, int) const

GetSubMatrix	Row (int) const

GetSubMatrix	Rows (int, int) const

GetSubMatrix	Column (int) const

GetSubMatrix	Columns (int, int) const

Real	AsScalar () const

Real	Determinant () const

Real	NormFrobenius () const

virtual Real	Trace () const

Real	Norm1 () const

Real	NormInfinity () const

virtual MatrixBandWidth	BandWidth () const

void	IEQND () const

Private Member Functions
void	ludcmp ()

void	operator= (const CroutMatrix &)

Private Attributes
int *	indx

bool	d

bool	sing

Additional Inherited Members
Protected Member Functions inherited from GeneralMatrix
	GeneralMatrix ()

	GeneralMatrix (ArrayLengthSpecifier)

void	Add (GeneralMatrix *, Real)

void	Add (Real)

void	NegAdd (GeneralMatrix *, Real)

void	NegAdd (Real)

void	Multiply (GeneralMatrix *, Real)

void	Multiply (Real)

void	Negate (GeneralMatrix *)

void	Negate ()

void	ReverseElements ()

void	ReverseElements (GeneralMatrix *)

void	operator= (Real)

Real *	GetStore ()

GeneralMatrix *	BorrowStore (GeneralMatrix *, MatrixType)

void	GetMatrix (const GeneralMatrix *)

void	Eq (const BaseMatrix &, MatrixType)

void	Eq (const GeneralMatrix &)

void	Eq (const BaseMatrix &, MatrixType, bool)

void	Eq2 (const BaseMatrix &, MatrixType)

int	search (const BaseMatrix *) const

virtual GeneralMatrix *	Transpose (TransposedMatrix *, MatrixType)

void	CheckConversion (const BaseMatrix &)

void	ReSize (int, int, int)

virtual short	SimpleAddOK (const GeneralMatrix *)

void	PlusEqual (const GeneralMatrix &gm)

void	MinusEqual (const GeneralMatrix &gm)

void	PlusEqual (Real f)

void	MinusEqual (Real f)

Protected Attributes inherited from GeneralMatrix
int	tag

int	nrows

int	ncols

int	storage

Real *	store

Detailed Description

Definition at line 902 of file newmat.h.

Constructor & Destructor Documentation

◆ CroutMatrix()

CroutMatrix::CroutMatrix ( const BaseMatrix & m )

Definition at line 170 of file newmat4.cpp.

References CleanUp(), d, GeneralMatrix::Evaluate(), GeneralMatrix::GetMatrix(), indx, ludcmp(), MatrixErrorNoSpace(), MONITOR_INT_NEW, GeneralMatrix::ncols, GeneralMatrix::nrows, REPORT, MatrixType::Rt, and sing.

 {
    REPORT
    Tracer tr("CroutMatrix");
    indx = 0;                     // in case of exception at next line
    GeneralMatrix* gm = ((BaseMatrix&)m).Evaluate(MatrixType::Rt);
    GetMatrix(gm);
    if (nrows!=ncols) { CleanUp(); Throw(NotSquareException(*gm)); }
    d=true; sing=false;
    indx=new int [nrows]; MatrixErrorNoSpace(indx);
    MONITOR_INT_NEW("Index (CroutMat)",nrows,indx)
    ludcmp();
 }

◆ ~CroutMatrix()

CroutMatrix::~CroutMatrix ( )

Definition at line 184 of file newmat4.cpp.

References indx, MONITOR_INT_DELETE, and GeneralMatrix::nrows.

 {
    MONITOR_INT_DELETE("Index (CroutMat)",nrows,indx)
    delete [] indx;
 }

Member Function Documentation

◆ CleanUp()

void CroutMatrix::CleanUp ( )

virtual

Reimplemented from GeneralMatrix.

Definition at line 898 of file newmat4.cpp.

References GeneralMatrix::CleanUp(), indx, GeneralMatrix::nrows, and REPORT.

Referenced by CroutMatrix().

 {
    REPORT
    if (nrows) delete [] indx;
    GeneralMatrix::CleanUp();
 }

◆ GetCol() [1/2]

void CroutMatrix::GetCol ( MatrixRowCol & )

virtual

Implements GeneralMatrix.

Definition at line 303 of file newmatex.cpp.

304 { Throw(NotDefinedException("GetCol","Crout")); }

NotDefinedException

Definition: newmat.h:1697

◆ GetCol() [2/2]

void CroutMatrix::GetCol ( MatrixColX & c )

inlinevirtual

Implements GeneralMatrix.

Definition at line 919 of file newmat.h.

References GetCol().

Referenced by GetCol().

919 { GetCol((MatrixRowCol&)c); }

CroutMatrix::GetCol

void GetCol(MatrixRowCol &)

Definition: newmatex.cpp:303

MatrixRowCol

Definition: newmatrc.h:33

◆ GetRow()

void CroutMatrix::GetRow ( MatrixRowCol & )

virtual

Implements GeneralMatrix.

Definition at line 301 of file newmatex.cpp.

302 { Throw(NotDefinedException("GetRow","Crout")); }

NotDefinedException

Definition: newmat.h:1697

◆ IsEqual()

bool CroutMatrix::IsEqual ( const GeneralMatrix & A ) const

virtual

Reimplemented from GeneralMatrix.

Definition at line 918 of file newmat7.cpp.

References A, and REPORT.

 {
    Tracer tr("CroutMatrix IsEqual");
    if (A.Type() != Type())                       // not same types
       { REPORT return false; }
    if (&A == this)                               // same matrix
       { REPORT  return true; }
    if (A.nrows != nrows || A.ncols != ncols)
                                                  // different dimensions
    { REPORT return false; }
    // is matrix storage the same - compare store
    REPORT
    return RealEqual(A.store,store,storage)
       && intEqual(((CroutMatrix&)A).indx, indx, nrows);
 }

◆ IsSingular()

bool CroutMatrix::IsSingular ( ) const

inline

Definition at line 923 of file newmat.h.

923 { return sing; }

CroutMatrix::sing

bool sing

Definition: newmat.h:906

◆ LogDeterminant()

LogAndSign CroutMatrix::LogDeterminant ( ) const

virtual

Reimplemented from GeneralMatrix.

Definition at line 696 of file newmat8.cpp.

References LogAndSign::ChangeSign(), and REPORT.

 {
    REPORT
    if (sing) return 0.0;
    int i = nrows; int dd = i+1; LogAndSign sum; Real* s = store;
    if (i) for(;;)
    {
       sum *= *s;
       if (!(--i)) break;
       s += dd;
    }
    if (!d) sum.ChangeSign(); return sum;
 
 }

◆ lubksb()

void CroutMatrix::lubksb	(	Real *	B,
		int	mini = `0`
	)

Definition at line 98 of file newmat8.cpp.

 {
    REPORT
    // this has been adapted from Numerical Recipes in C. The code has been
    // substantially streamlined, so I do not think much of the original
    // copyright remains. However there is not much opportunity for
    // variation in the code, so it is still similar to the NR code.
    // I follow the NR code in skipping over initial zeros in the B vector.
    Tracer trace("Crout(lubksb)");
    sing = false;
    // if ((this->LogDeterminant()).Value() != 0) sing = false;
    if (sing) Throw(SingularException(*this));
    int i, j, ii = nrows;            // ii initialised : B might be all zeros
 
 
    // scan for first non-zero in B
    for (i = 0; i < nrows; i++)
    {
       int ip = indx[i]; Real temp = B[ip]; B[ip] = B[i]; B[i] = temp;
       if (temp != 0.0) { ii = i; break; }
    }
 
    Real* bi; Real* ai;
    i = ii + 1;
 
    if (i < nrows)
    {
       bi = B + ii; ai = store + ii + i * nrows;
       for (;;)
       {
          int ip = indx[i]; Real sum = B[ip]; B[ip] = B[i];
          Real* aij = ai; Real* bj = bi; j = i - ii;
          while (j--) sum -= *aij++ * *bj++;
          B[i] = sum;
          if (++i == nrows) break;
          ai += nrows;
       }
    }
 
    ai = store + nrows * nrows;
 
    for (i = nrows - 1; i >= mini; i--)
    {
       Real* bj = B+i; ai -= nrows; Real* ajx = ai+i;
       Real sum = *bj; Real diag = *ajx;
       j = nrows - i; while(--j) sum -= *(++ajx) * *(++bj);
       B[i] = sum / diag;
    }
 }

◆ ludcmp()

void CroutMatrix::ludcmp ( )

private

Definition at line 27 of file newmat8.cpp.

References REPORT.

Referenced by CroutMatrix().

 {
    REPORT
    Tracer trace( "Crout(ludcmp)" ); sing = false;
    Real* akk = store;                    // runs down diagonal
 
    Real big = fabs(*akk); int mu = 0; Real* ai = akk; int k;
 
    for (k = 1; k < nrows; k++)
    {
       ai += nrows; const Real trybig = fabs(*ai);
       if (big < trybig) { big = trybig; mu = k; }
    }
 
 
    if (nrows) for (k = 0;;)
    {
       /*
       int mu1;
       {
          Real big = fabs(*akk); mu1 = k; Real* ai = akk; int i;
 
          for (i = k+1; i < nrows; i++)
          {
             ai += nrows; const Real trybig = fabs(*ai);
             if (big < trybig) { big = trybig; mu1 = i; }
          }
       }
       if (mu1 != mu) cout << k << " " << mu << " " << mu1 << endl;
       */
 
       indx[k] = mu;
 
       if (mu != k)                       //row swap
       {
          Real* a1 = store + nrows * k; Real* a2 = store + nrows * mu; d = !d;
          int j = nrows;
          while (j--) { const Real temp = *a1; *a1++ = *a2; *a2++ = temp; }
       }
 
       Real diag = *akk; big = 0; mu = k + 1;
       if (diag != 0)
       {
          ai = akk; int i = nrows - k - 1;
          while (i--)
          {
             ai += nrows; Real* al = ai; Real mult = *al / diag; *al = mult;
             int l = nrows - k - 1; Real* aj = akk;
             // work out the next pivot as part of this loop
             // this saves a column operation
             if (l-- != 0)
             {
                *(++al) -= (mult * *(++aj));
                const Real trybig = fabs(*al);
                if (big < trybig) { big = trybig; mu = nrows - i - 1; }
                while (l--) *(++al) -= (mult * *(++aj));
             }
          }
       }
       else sing = true;
       if (++k == nrows) break;          // so next line won't overflow
       akk += nrows + 1;
    }
 }

◆ MakeSolver()

GeneralMatrix* CroutMatrix::MakeSolver ( )

inlinevirtual

Reimplemented from GeneralMatrix.

Definition at line 914 of file newmat.h.

914 { return this; } // for solving

◆ MiniCleanUp()

void CroutMatrix::MiniCleanUp ( )

virtual

Reimplemented from GeneralMatrix.

Definition at line 905 of file newmat4.cpp.

References indx, GeneralMatrix::MiniCleanUp(), GeneralMatrix::nrows, and REPORT.

 {
    REPORT
    if (nrows) delete [] indx;
    GeneralMatrix::MiniCleanUp();
 }

◆ operator=()

void CroutMatrix::operator= ( const CroutMatrix & )

inlineprivate

Definition at line 908 of file newmat.h.

908 {} // not allowed

◆ Solver()

void CroutMatrix::Solver	(	MatrixColX &	mcout,
		const MatrixColX &	mcin
	)

virtual

Reimplemented from GeneralMatrix.

Definition at line 38 of file newmat7.cpp.

References MatrixRowCol::data, REPORT, MatrixRowCol::skip, and MatrixRowCol::storage.

 {
    REPORT
    int i = mcin.skip; Real* el = mcin.data-i; Real* el1 = el;
    while (i--) *el++ = 0.0;
    el += mcin.storage; i = nrows - mcin.skip - mcin.storage;
    while (i--) *el++ = 0.0;
    lubksb(el1, mcout.skip);
 }

◆ Type()

MatrixType CroutMatrix::Type ( ) const

virtual

Implements GeneralMatrix.

Definition at line 421 of file newmat4.cpp.

References MatrixType::Ct.

421 { return MatrixType::Ct; }

MatrixType::Ct

Definition: newmat.h:122

Member Data Documentation

◆ d

bool CroutMatrix::d

private

Definition at line 905 of file newmat.h.

Referenced by CroutMatrix().

◆ indx

int* CroutMatrix::indx

private

Definition at line 904 of file newmat.h.

Referenced by CleanUp(), CroutMatrix(), MiniCleanUp(), and ~CroutMatrix().

◆ sing

bool CroutMatrix::sing

private

Definition at line 906 of file newmat.h.

Referenced by CroutMatrix().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CroutMatrix()

◆ ~CroutMatrix()

Member Function Documentation

◆ CleanUp()

◆ GetCol() [1/2]

◆ GetCol() [2/2]

◆ GetRow()

◆ IsEqual()

◆ IsSingular()

◆ LogDeterminant()

◆ lubksb()

◆ ludcmp()

◆ MakeSolver()

◆ MiniCleanUp()

◆ operator=()

◆ Solver()

◆ Type()

Member Data Documentation

◆ d

◆ indx

◆ sing