void GeometricRowScaling
( const Matrix<Field>& A,
Matrix<Base<Field>>& geomScaling )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
Matrix<Real> maxScaling;
RowMaxNorms( A, maxScaling );
RowMinAbsNonzero( A, maxScaling, geomScaling );
const Int m = A.Height();
for( Int i=0; i<m; ++i )
{
const Real maxAbs = maxScaling(i);
const Real minAbs = geomScaling(i);
geomScaling(i) = Sqrt(minAbs*maxAbs);
}
}
void GeometricRowScaling
( const DistMatrix<Field, U,V >& A,
DistMatrix<Base<Field>,U,STAR>& geomScaling )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
DistMatrix<Real,U,STAR> maxScaling(A.Grid());
RowMaxNorms( A, maxScaling );
RowMinAbsNonzero( A, maxScaling, geomScaling );
const Int mLocal = A.LocalHeight();
auto& maxScalingLoc = maxScaling.Matrix();
auto& geomScalingLoc = geomScaling.Matrix();
for( Int iLoc=0; iLoc<mLocal; ++iLoc )
{
const Real maxAbs = maxScalingLoc(iLoc);
const Real minAbs = geomScalingLoc(iLoc);
geomScalingLoc(iLoc) = Sqrt(minAbs*maxAbs);
}
}
void RuizEquil
( DistSparseMatrix<Field>& A,
DistMultiVec<Base<Field>>& dRow,
DistMultiVec<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
mpi::Comm comm = A.Comm();
dRow.SetComm( comm );
dCol.SetComm( comm );
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose to control structure
// For, simply hard-code a small number of iterations
const Int maxIter = 4;
DistMultiVec<Real> scales(comm);
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dCol );
DiagonalSolve( RIGHT, NORMAL, scales, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, scales );
EntrywiseMap( scales, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, scales, dRow );
DiagonalSolve( LEFT, NORMAL, scales, A );
}
SetIndent( indent );
}
void RuizEquil
( Matrix<Field>& A,
Matrix<Base<Field>>& dRow,
Matrix<Base<Field>>& dCol,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
const Int m = A.Height();
const Int n = A.Width();
Ones( dRow, m, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
Matrix<Real> rowScale, colScale;
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRow );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
}
SetIndent( indent );
}
void StackedRuizEquil
( AbstractDistMatrix<Field>& APre,
AbstractDistMatrix<Field>& BPre,
AbstractDistMatrix<Base<Field>>& dRowAPre,
AbstractDistMatrix<Base<Field>>& dRowBPre,
AbstractDistMatrix<Base<Field>>& dColPre,
bool progress )
{
EL_DEBUG_CSE
typedef Base<Field> Real;
ElementalProxyCtrl control;
control.colConstrain = true;
control.rowConstrain = true;
control.colAlign = 0;
control.rowAlign = 0;
DistMatrixReadWriteProxy<Field,Field,MC,MR> AProx( APre, control );
DistMatrixReadWriteProxy<Field,Field,MC,MR> BProx( BPre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dRowAProx( dRowAPre, control );
DistMatrixWriteProxy<Real,Real,MC,STAR> dRowBProx( dRowBPre, control );
DistMatrixWriteProxy<Real,Real,MR,STAR> dColProx( dColPre, control );
auto& A = AProx.Get();
auto& B = BProx.Get();
auto& dRowA = dRowAProx.Get();
auto& dRowB = dRowBProx.Get();
auto& dCol = dColProx.Get();
const Int mA = A.Height();
const Int mB = B.Height();
const Int n = A.Width();
const Int nLocal = A.LocalWidth();
Ones( dRowA, mA, 1 );
Ones( dRowB, mB, 1 );
Ones( dCol, n, 1 );
// TODO(poulson): Expose these as control parameters
// For now, simply hard-code the number of iterations
const Int maxIter = 4;
DistMatrix<Real,MC,STAR> rowScale(A.Grid());
DistMatrix<Real,MR,STAR> colScale(A.Grid()), colScaleB(B.Grid());
auto& colScaleLoc = colScale.Matrix();
auto& colScaleBLoc = colScaleB.Matrix();
const Int indent = PushIndent();
for( Int iter=0; iter<maxIter; ++iter )
{
// Rescale the columns
// -------------------
ColumnMaxNorms( A, colScale );
ColumnMaxNorms( B, colScaleB );
for( Int jLoc=0; jLoc<nLocal; ++jLoc )
colScaleLoc(jLoc) =
Max(colScaleLoc(jLoc),colScaleBLoc(jLoc));
EntrywiseMap( colScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, colScale, dCol );
DiagonalSolve( RIGHT, NORMAL, colScale, A );
DiagonalSolve( RIGHT, NORMAL, colScale, B );
// Rescale the rows
// ----------------
RowMaxNorms( A, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRowA );
DiagonalSolve( LEFT, NORMAL, rowScale, A );
RowMaxNorms( B, rowScale );
EntrywiseMap( rowScale, MakeFunction(DampScaling<Real>) );
DiagonalScale( LEFT, NORMAL, rowScale, dRowB );
DiagonalSolve( LEFT, NORMAL, rowScale, B );
}
SetIndent( indent );
}
