#include <dgeequ.h>

Inheritance diagram for LapackMatrixScale< T >:

Collaboration diagram for LapackMatrixScale< T >:

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

virtual	~LapackMatrixScale ()

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
doublereal	SMLNUM

doublereal	BIGNUM

doublereal	rowcnd

doublereal	colcnd

doublereal	amax

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 LapackMatrixScale< T >

Definition at line 156 of file dgeequ.h.

Constructor & Destructor Documentation

template<typename T >

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

inline

Definition at line 548 of file dgeequ.h.

References LapackMatrixScale< T >::amax, LapackMatrixScale< T >::BIGNUM, LapackMatrixScale< T >::colcnd, LapackMatrixScale< T >::rowcnd, and LapackMatrixScale< T >::SMLNUM.

         :MatrixScale<T>(scale)
 {
 #if defined(HAVE_DLAMCH) || defined(HAVE_DLAMCH_)
         // Use dlamch according to Netlib's dgeequ.f
         SMLNUM = __FC_DECL__(dlamch)("S");
 #else
         // According to Netlib's dlamch for x86-64 machines
         SMLNUM = std::numeric_limits<doublereal>::min();
 #endif
         BIGNUM = 1./SMLNUM;
 
         rowcnd = colcnd = amax = -1;
 }

template<typename T >

LapackMatrixScale< T >::~LapackMatrixScale ( )

virtual

Definition at line 564 of file dgeequ.h.

 {
 
 }

Member Function Documentation

template<typename T >

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

protectedvirtual

Implements MatrixScale< T >.

Definition at line 570 of file dgeequ.h.

References MBDYN_EXCEPT_ARGS, and MatrixScaleBase::Prepare().

 {
         integer nrows, ncols;
         MatrixScale<T>::Prepare(mh, nrows, ncols);
 
         doublereal rcmin;
         doublereal rcmax;
 
         for (typename T::const_iterator i = mh.begin(); i != mh.end(); ++i) {
                 doublereal d = std::abs(i->dCoef);
                 if (d > rowScale[i->iRow]) {
                         rowScale[i->iRow] = d;
                 }
         }
 
         rcmin = BIGNUM;
         rcmax = 0.;
         for (std::vector<doublereal>::iterator i = rowScale.begin(); i != rowScale.end(); ++i) {
                 if (*i > rcmax) {
                         rcmax = *i;
                 }
                 if (*i < rcmin) {
                         rcmin = *i;
                 }
         }
 
         amax = rcmax;
 
         if (rcmin == 0.) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS,
                         "null min row value in dgeequ");
         }
 
         for (std::vector<doublereal>::iterator i = rowScale.begin(); i != rowScale.end(); ++i) {
                 *i = 1./(std::min(std::max(*i, SMLNUM), BIGNUM));
         }
 
         rowcnd = std::max(rcmin, SMLNUM)/std::min(rcmax, BIGNUM);
 
         for (typename T::const_iterator i = mh.begin(); i != mh.end(); ++i) {
                 doublereal d = std::abs(i->dCoef)*rowScale[i->iRow];
                 if (d > colScale[i->iCol]) {
                         colScale[i->iCol] = d;
                 }
         }
 
         rcmin = BIGNUM;
         rcmax = 0.;
         for (std::vector<doublereal>::iterator i = colScale.begin(); i != colScale.end(); ++i) {
                 if (*i > rcmax) {
                         rcmax = *i;
                 }
                 if (*i < rcmin) {
                         rcmin = *i;
                 }
         }
 
         if (rcmin == 0.) {
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS,
                         "null min column value in dgeequ");
         }
 
         for (std::vector<doublereal>::iterator i = colScale.begin(); i != colScale.end(); ++i) {
                 *i = 1./(std::min(std::max(*i, SMLNUM), BIGNUM));
         }
 
         colcnd = std::max(rcmin, SMLNUM)/std::min(rcmax, BIGNUM);
 
         return true;
 }

Here is the call graph for this function:

template<typename T >

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

protectedvirtual

Implements MatrixScaleBase.

Definition at line 642 of file dgeequ.h.

 {
         if (amax < std::numeric_limits<doublereal>::epsilon()
                 || amax > 1./std::numeric_limits<doublereal>::epsilon())
         {
                 os << "Warning: The matrix should be scaled\n";
         }
 
         if (colcnd >= 0.1) {
                 os << "Warning: it is not worth scaling the columns\n";
         }
 
         if (rowcnd >= 0.1
                 && amax >= std::numeric_limits<doublereal>::epsilon()
                 && amax <= 1./std::numeric_limits<doublereal>::epsilon())
         {
                 os << "Warning: it is not worth scaling the rows\n";
         }
 
         return os;
 }