Eigen::IterScaling< MatrixType_ > Class Template Reference

iterative scaling algorithm to equilibrate rows and column norms in matrices More...

#include <Scaling.h>

Public Types
typedef MatrixType_	MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::Index	Index

Public Member Functions
	IterScaling ()
	IterScaling (const MatrixType &matrix)
	~IterScaling ()
void	compute (const MatrixType &mat)
void	computeRef (MatrixType &mat)
VectorXd &	LeftScaling ()
VectorXd &	RightScaling ()
void	setTolerance (double tol)

Protected Member Functions
void	init ()

Protected Attributes
MatrixType	m_matrix
ComputationInfo	m_info
bool	m_isInitialized
VectorXd	m_left
VectorXd	m_right
double	m_tol
int	m_maxits

Detailed Description

template<typename MatrixType_>
class Eigen::IterScaling< MatrixType_ >

iterative scaling algorithm to equilibrate rows and column norms in matrices

This class can be used as a preprocessing tool to accelerate the convergence of iterative methods

This feature is useful to limit the pivoting amount during LU/ILU factorization The scaling strategy as presented here preserves the symmetry of the problem NOTE It is assumed that the matrix does not have empty row or column,

Example with key steps

VectorXd x(n), b(n);
SparseMatrix<double> A;
// fill A and b;
IterScaling<SparseMatrix<double> > scal;
// Compute the left and right scaling vectors. The matrix is equilibrated at output
scal.computeRef(A);
// Scale the right hand side
b = scal.LeftScaling().cwiseProduct(b);
// Now, solve the equilibrated linear system with any available solver
 
// Scale back the computed solution
x = scal.RightScaling().cwiseProduct(x);

Template Parameters

MatrixType_

the type of the matrix. It should be a real square sparsematrix

References : D. Ruiz and B. Ucar, A Symmetry Preserving Algorithm for Matrix Scaling, INRIA Research report RR-7552

See also

IncompleteLUT

Member Typedef Documentation

Index

template<typename MatrixType_ >

typedef MatrixType::Index Eigen::IterScaling< MatrixType_ >::Index

MatrixType

template<typename MatrixType_ >

typedef MatrixType_ Eigen::IterScaling< MatrixType_ >::MatrixType

Scalar

template<typename MatrixType_ >

typedef MatrixType::Scalar Eigen::IterScaling< MatrixType_ >::Scalar

Constructor & Destructor Documentation

IterScaling() [1/2]

template<typename MatrixType_ >

Eigen::IterScaling< MatrixType_ >::IterScaling ( )

inline

{ init(); }

References Eigen::IterScaling< MatrixType_ >::init().

IterScaling() [2/2]

template<typename MatrixType_ >

Eigen::IterScaling< MatrixType_ >::IterScaling ( const MatrixType &  matrix )

inline

                                        {
    init();
    compute(matrix);
  }

References Eigen::IterScaling< MatrixType_ >::compute(), Eigen::IterScaling< MatrixType_ >::init(), and matrix().

~IterScaling()

template<typename MatrixType_ >

Eigen::IterScaling< MatrixType_ >::~IterScaling ( )

inline

{}

Member Function Documentation

compute()

template<typename MatrixType_ >

void Eigen::IterScaling< MatrixType_ >::compute ( const MatrixType &  mat )

inline

Compute the left and right diagonal matrices to scale the input matrix mat

FIXME This algorithm will be modified such that the diagonal elements are permuted on the diagonal.

See also

LeftScaling() RightScaling()

                                      {
    using std::abs;
    int m = mat.rows();
    int n = mat.cols();
    eigen_assert((m > 0 && m == n) && "Please give a non - empty matrix");
    m_left.resize(m);
    m_right.resize(n);
    m_left.setOnes();
    m_right.setOnes();
    m_matrix = mat;
    VectorXd Dr, Dc, DrRes, DcRes;  // Temporary Left and right scaling vectors
    Dr.resize(m);
    Dc.resize(n);
    DrRes.resize(m);
    DcRes.resize(n);
    double EpsRow = 1.0, EpsCol = 1.0;
    int its = 0;
    do {  // Iterate until the infinite norm of each row and column is approximately 1
      // Get the maximum value in each row and column
      Dr.setZero();
      Dc.setZero();
      for (int k = 0; k < m_matrix.outerSize(); ++k) {
        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
          if (Dr(it.row()) < abs(it.value())) Dr(it.row()) = abs(it.value());
 
          if (Dc(it.col()) < abs(it.value())) Dc(it.col()) = abs(it.value());
        }
      }
      for (int i = 0; i < m; ++i) {
        Dr(i) = std::sqrt(Dr(i));
      }
      for (int i = 0; i < n; ++i) {
        Dc(i) = std::sqrt(Dc(i));
      }
      // Save the scaling factors
      for (int i = 0; i < m; ++i) {
        m_left(i) /= Dr(i);
      }
      for (int i = 0; i < n; ++i) {
        m_right(i) /= Dc(i);
      }
      // Scale the rows and the columns of the matrix
      DrRes.setZero();
      DcRes.setZero();
      for (int k = 0; k < m_matrix.outerSize(); ++k) {
        for (typename MatrixType::InnerIterator it(m_matrix, k); it; ++it) {
          it.valueRef() = it.value() / (Dr(it.row()) * Dc(it.col()));
          // Accumulate the norms of the row and column vectors
          if (DrRes(it.row()) < abs(it.value())) DrRes(it.row()) = abs(it.value());
 
          if (DcRes(it.col()) < abs(it.value())) DcRes(it.col()) = abs(it.value());
        }
      }
      DrRes.array() = (1 - DrRes.array()).abs();
      EpsRow = DrRes.maxCoeff();
      DcRes.array() = (1 - DcRes.array()).abs();
      EpsCol = DcRes.maxCoeff();
      its++;
    } while ((EpsRow > m_tol || EpsCol > m_tol) && (its < m_maxits));
    m_isInitialized = true;
  }

References abs(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), eigen_assert, i, k, m, Eigen::IterScaling< MatrixType_ >::m_isInitialized, Eigen::IterScaling< MatrixType_ >::m_left, Eigen::IterScaling< MatrixType_ >::m_matrix, Eigen::IterScaling< MatrixType_ >::m_maxits, Eigen::IterScaling< MatrixType_ >::m_right, Eigen::IterScaling< MatrixType_ >::m_tol, n, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and sqrt().

Referenced by Eigen::IterScaling< MatrixType_ >::computeRef(), and Eigen::IterScaling< MatrixType_ >::IterScaling().

computeRef()

template<typename MatrixType_ >

void Eigen::IterScaling< MatrixType_ >::computeRef ( MatrixType &  mat )

inline

Compute the left and right vectors to scale the vectors the input matrix is scaled with the computed vectors at output

See also

compute()

                                   {
    compute(mat);
    mat = m_matrix;
  }

References Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::m_matrix.

init()

template<typename MatrixType_ >

void Eigen::IterScaling< MatrixType_ >::init ( )

inlineprotected

              {
    m_tol = 1e-10;
    m_maxits = 5;
    m_isInitialized = false;
  }

References e(), Eigen::IterScaling< MatrixType_ >::m_isInitialized, Eigen::IterScaling< MatrixType_ >::m_maxits, and Eigen::IterScaling< MatrixType_ >::m_tol.

Referenced by Eigen::IterScaling< MatrixType_ >::IterScaling().

LeftScaling()

template<typename MatrixType_ >

VectorXd& Eigen::IterScaling< MatrixType_ >::LeftScaling ( )

inline

Get the vector to scale the rows of the matrix

{ return m_left; }

References Eigen::IterScaling< MatrixType_ >::m_left.

RightScaling()

template<typename MatrixType_ >

VectorXd& Eigen::IterScaling< MatrixType_ >::RightScaling ( )

inline

Get the vector to scale the columns of the matrix

{ return m_right; }

References Eigen::IterScaling< MatrixType_ >::m_right.

setTolerance()

template<typename MatrixType_ >

void Eigen::IterScaling< MatrixType_ >::setTolerance ( double  tol )

inline

Set the tolerance for the convergence of the iterative scaling algorithm

{ m_tol = tol; }

References Eigen::IterScaling< MatrixType_ >::m_tol.

Member Data Documentation

m_info

template<typename MatrixType_ >

ComputationInfo Eigen::IterScaling< MatrixType_ >::m_info

mutableprotected

m_isInitialized

template<typename MatrixType_ >

bool Eigen::IterScaling< MatrixType_ >::m_isInitialized

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::init().

m_left

template<typename MatrixType_ >

VectorXd Eigen::IterScaling< MatrixType_ >::m_left

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::LeftScaling().

m_matrix

template<typename MatrixType_ >

MatrixType Eigen::IterScaling< MatrixType_ >::m_matrix

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::computeRef().

m_maxits

template<typename MatrixType_ >

int Eigen::IterScaling< MatrixType_ >::m_maxits

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::init().

m_right

template<typename MatrixType_ >

VectorXd Eigen::IterScaling< MatrixType_ >::m_right

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), and Eigen::IterScaling< MatrixType_ >::RightScaling().

m_tol

template<typename MatrixType_ >

double Eigen::IterScaling< MatrixType_ >::m_tol

protected

Referenced by Eigen::IterScaling< MatrixType_ >::compute(), Eigen::IterScaling< MatrixType_ >::init(), and Eigen::IterScaling< MatrixType_ >::setTolerance().

---

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

• unsupported/Eigen/src/IterativeSolvers/Scaling.h