#include <dgeequ.h>

Inheritance diagram for RowMaxColMaxMatrixScale< T >:

Collaboration diagram for RowMaxColMaxMatrixScale< T >:

Public Member Functions
	RowMaxColMaxMatrixScale (const SolutionManager::ScaleOpt &scale)

virtual	~RowMaxColMaxMatrixScale ()

Public Member Functions inherited from MatrixScale< T >
	MatrixScale (const SolutionManager::ScaleOpt &scale)

virtual	~MatrixScale ()

T &	ScaleMatrix (T &mh) const

bool	ComputeScaleFactors (const T &mh)

Public Member Functions inherited from MatrixScaleBase
	MatrixScaleBase (const SolutionManager::ScaleOpt &scale)

virtual	~MatrixScaleBase ()

VectorHandler &	ScaleRightHandSide (VectorHandler &bVH) const

VectorHandler &	ScaleSolution (VectorHandler &xVH) const

std::ostream &	Report (std::ostream &os) const

const std::vector< doublereal > &	GetRowScale () const

const std::vector< doublereal > &	GetColScale () const

bool	bGetInitialized () const

Protected Member Functions
virtual bool	ComputeScaleFactors (const T &mh, std::vector< doublereal > &rowScale, std::vector< doublereal > &colScale)

virtual std::ostream &	vReport (std::ostream &os) const

Protected Member Functions inherited from MatrixScaleBase
MatrixHandler::Norm_t	GetCondNumNorm () const

void	Prepare (const MatrixHandler &mh, integer &nrows, integer &ncols)

void	PrepareRows (const MatrixHandler &mh, integer &nrows)

void	PrepareCols (const MatrixHandler &mh, integer &ncols)

bool	bReport () const

Private Attributes
const doublereal	dTol

doublereal	maxNormRow

doublereal	maxNormCol

std::vector< doublereal >	normRow

std::vector< doublereal >	normCol

Additional Inherited Members
Static Public Member Functions inherited from MatrixScale< T >
static MatrixScale< T > *	Allocate (const SolutionManager::ScaleOpt &scale)

Protected Attributes inherited from MatrixScaleBase
std::vector< doublereal >	rowScale

std::vector< doublereal >	colScale

doublereal	dCondBefore

doublereal	dCondAfter

const unsigned	uFlags

bool	bOK

Detailed Description

template<typename T>
class RowMaxColMaxMatrixScale< T >

Definition at line 200 of file dgeequ.h.

Constructor & Destructor Documentation

template<typename T >

RowMaxColMaxMatrixScale< T >::RowMaxColMaxMatrixScale ( const SolutionManager::ScaleOpt & scale )

inline

Definition at line 833 of file dgeequ.h.

 :MatrixScale<T>(scale),
  dTol(scale.dTol),
  maxNormRow(-1.),
  maxNormCol(-1.)
 {
 
 }

template<typename T >

RowMaxColMaxMatrixScale< T >::~RowMaxColMaxMatrixScale ( )

virtual

Definition at line 843 of file dgeequ.h.

 {
 
 }

Member Function Documentation

template<typename T >

bool RowMaxColMaxMatrixScale< T >::ComputeScaleFactors	(	const T &	mh,
		std::vector< doublereal > &	rowScale,
		std::vector< doublereal > &	colScale
	)

protectedvirtual

Implements MatrixScale< T >.

Definition at line 849 of file dgeequ.h.

References MBDYN_EXCEPT_ARGS.

 {
         const integer nrows = mh.iGetNumRows();
         const integer ncols = mh.iGetNumCols();
 
         if (nrows <= 0) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS,
                         "invalid null or negative row number");
         }
 
         if (ncols <= 0) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS,
                         "invalid null or negative column number");
         }
 
         if (rowScale.empty()) {
                 rowScale.resize(nrows, 1.);
                 normRow.resize(nrows);
         } else if (rowScale.size() != static_cast<size_t>(nrows)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS, "row number mismatch");
         }
 
         if (colScale.empty()) {
                 colScale.resize(ncols, 1.);
                 normCol.resize(ncols);
         } else if (colScale.size() != static_cast<size_t>(ncols)) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS, "column number mismatch");
         }
 
         std::fill(normRow.begin(), normRow.end(), 0.);
 
         for (typename T::const_iterator im = mh.begin(); im != mh.end(); ++im) {
                 doublereal d = im->dCoef;
 
                 if (d == 0.) {
                         continue;
                 }
 
                 d = std::abs(d);
 
                 if (d > normRow[im->iRow]) {
                         normRow[im->iRow] = d;
                 }
         }
 
         for (integer i = 0; i < nrows; ++i) {
                 rowScale[i] = 1. / normRow[i];
         }
 
         std::fill(normCol.begin(), normCol.end(), 0.);
 
         for (typename T::const_iterator im = mh.begin(); im != mh.end(); ++im) {
                 doublereal d = im->dCoef;
 
                 if (d == 0.) {
                         continue;
                 }
 
                 d = std::abs(rowScale[im->iRow] * d);
 
                 if (d > normCol[im->iCol]) {
                         normCol[im->iCol] = d;
                 }
         }
 
         for (integer i = 0; i < ncols; ++i) {
                 colScale[i] = 1. / normCol[i];
         }
 
         if (!this->bReport()) {
                 // Test for convergence will not be checked
                 // It would be a waste of time to compute the row and column norms
                 return true;
         }
 
         std::fill(normRow.begin(), normRow.end(), 0.);
         std::fill(normCol.begin(), normCol.end(), 0.);
 
         for (typename T::const_iterator im = mh.begin(); im != mh.end(); ++im) {
                 doublereal d = im->dCoef;
 
                 if (d == 0.) {
                         continue;
                 }
 
                 d = std::abs(colScale[im->iCol] * rowScale[im->iRow] * d);
 
                 if (d > normRow[im->iRow]) {
                         normRow[im->iRow] = d;
                 }
 
                 if (d > normCol[im->iCol]) {
                         normCol[im->iCol] = d;
                 }
         }
 
         maxNormRow = 0.;
 
         for (std::vector<doublereal>::const_iterator ir = normRow.begin();
                  ir != normRow.end(); ++ir) {
                 maxNormRow = std::max(maxNormRow, std::abs(1. - *ir));
         }
 
         maxNormCol = 0.;
 
         for (std::vector<doublereal>::const_iterator ic = normCol.begin();
                  ic != normCol.end(); ++ic) {
                 maxNormCol = std::max(maxNormCol, std::abs(1. - *ic));
         }
 
         return (maxNormRow < dTol && maxNormCol < dTol);
 }

template<typename T >

std::ostream & RowMaxColMaxMatrixScale< T >::vReport ( std::ostream & os ) const

protectedvirtual

Implements MatrixScaleBase.

Definition at line 963 of file dgeequ.h.

References MatrixScaleBase::bOK.

 {
         if (!MatrixScaleBase::bOK) {
                 os << "Warning: matrix scale did not converge\n";
         }
 
         os << "row scale: " << maxNormRow << std::endl
            << "col scale: " << maxNormCol << std::endl;
 
         return os;
 }