void SymmetricRuizEquil ( Matrix<F>& A, Matrix<Base<F>>& d, Int maxIter, bool progress ) { DEBUG_CSE typedef Base<F> Real; const Int n = A.Height(); Ones( d, n, 1 ); Matrix<Real> scales; const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns (and rows) // ------------------------------ ColumnMaxNorms( A, scales ); EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) ); EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, d ); // TODO(poulson): Replace with SymmetricDiagonalSolve DiagonalSolve( RIGHT, NORMAL, scales, A ); DiagonalSolve( LEFT, NORMAL, scales, A ); } SetIndent( indent ); }
void SymmetricRuizEquil ( DistSparseMatrix<F>& A, DistMultiVec<Base<F>>& d, Int maxIter, bool progress ) { DEBUG_CSE typedef Base<F> Real; const Int n = A.Height(); mpi::Comm comm = A.Comm(); d.SetComm( comm ); Ones( d, n, 1 ); DistMultiVec<Real> scales(comm); const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns (and rows) // ------------------------------ ColumnMaxNorms( A, scales ); EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) ); EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, d ); SymmetricDiagonalSolve( scales, A ); } SetIndent( indent ); }
void SymmetricRuizEquil ( DistSparseMatrix<Field>& A, DistMultiVec<Base<Field>>& d, Int maxIter, bool progress ) { EL_DEBUG_CSE typedef Base<Field> Real; const Int n = A.Height(); const Grid& grid = A.Grid(); d.SetGrid( grid ); Ones( d, n, 1 ); DistMultiVec<Real> scales(grid); const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns (and rows) // ------------------------------ ColumnMaxNorms( A, scales ); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); EntrywiseMap( scales, MakeFunction(SquareRootScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, d ); SymmetricDiagonalSolve( scales, A ); } SetIndent( indent ); }
void StackedRuizEquil ( DistSparseMatrix<Field>& A, DistSparseMatrix<Field>& B, DistMultiVec<Base<Field>>& dRowA, DistMultiVec<Base<Field>>& dRowB, DistMultiVec<Base<Field>>& dCol, bool progress ) { EL_DEBUG_CSE typedef Base<Field> Real; const Int mA = A.Height(); const Int mB = B.Height(); const Int n = A.Width(); mpi::Comm comm = A.Comm(); dRowA.SetComm( comm ); dRowB.SetComm( comm ); dCol.SetComm( comm ); Ones( dRowA, mA, 1 ); Ones( dRowB, mB, 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), maxAbsValsB(comm); auto& scalesLoc = scales.Matrix(); auto& maxAbsValsBLoc = maxAbsValsB.Matrix(); const Int localHeight = scalesLoc.Height(); const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns // ------------------- ColumnMaxNorms( A, scales ); ColumnMaxNorms( B, maxAbsValsB ); for( Int jLoc=0; jLoc<localHeight; ++jLoc ) scalesLoc(jLoc) = Max(scalesLoc(jLoc),maxAbsValsBLoc(jLoc)); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dCol ); DiagonalSolve( RIGHT, NORMAL, scales, A ); DiagonalSolve( RIGHT, NORMAL, scales, B ); // Rescale the rows // ---------------- RowMaxNorms( A, scales ); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dRowA ); DiagonalSolve( LEFT, NORMAL, scales, A ); RowMaxNorms( B, scales ); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dRowB ); DiagonalSolve( LEFT, NORMAL, scales, B ); } SetIndent( indent ); }
void RuizEquil ( AbstractDistMatrix<Field>& APre, AbstractDistMatrix<Base<Field>>& dRowPre, 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 ); DistMatrixWriteProxy<Real,Real,MC,STAR> dRowProx( dRowPre, control ); DistMatrixWriteProxy<Real,Real,MR,STAR> dColProx( dColPre, control ); auto& A = AProx.Get(); auto& dRow = dRowProx.Get(); auto& dCol = dColProx.Get(); 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; DistMatrix<Real,MC,STAR> rowScale(A.Grid()); DistMatrix<Real,MR,STAR> colScale(A.Grid()); 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 ( SparseMatrix<Field>& A, SparseMatrix<Field>& B, Matrix<Base<Field>>& dRowA, Matrix<Base<Field>>& dRowB, Matrix<Base<Field>>& dCol, bool progress ) { EL_DEBUG_CSE typedef Base<Field> Real; const Int mA = A.Height(); const Int mB = B.Height(); const Int n = A.Width(); 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; Matrix<Real> scales, maxAbsValsB; const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns // ------------------- ColumnMaxNorms( A, scales ); ColumnMaxNorms( B, maxAbsValsB ); for( Int j=0; j<n; ++j ) scales(j) = Max(scales(j),maxAbsValsB(j)); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dCol ); DiagonalSolve( RIGHT, NORMAL, scales, A ); DiagonalSolve( RIGHT, NORMAL, scales, B ); // Rescale the rows // ---------------- RowMaxNorms( A, scales ); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dRowA ); DiagonalSolve( LEFT, NORMAL, scales, A ); RowMaxNorms( B, scales ); EntrywiseMap( scales, MakeFunction(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, dRowB ); DiagonalSolve( LEFT, NORMAL, scales, B ); } SetIndent( indent ); }
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 SymmetricRuizEquil ( ElementalMatrix<F>& APre, ElementalMatrix<Base<F>>& dPre, Int maxIter, bool progress ) { DEBUG_CSE typedef Base<F> Real; ElementalProxyCtrl control; control.colConstrain = true; control.rowConstrain = true; control.colAlign = 0; control.rowAlign = 0; DistMatrixReadWriteProxy<F,F,MC,MR> AProx( APre, control ); DistMatrixWriteProxy<Real,Real,MC,STAR> dProx( dPre, control ); auto& A = AProx.Get(); auto& d = dProx.Get(); const Int n = A.Height(); Ones( d, n, 1 ); DistMatrix<Real,MR,STAR> scales(A.Grid()); const Int indent = PushIndent(); for( Int iter=0; iter<maxIter; ++iter ) { // Rescale the columns (and rows) // ------------------------------ ColumnMaxNorms( A, scales ); EntrywiseMap( scales, function<Real(Real)>(DampScaling<Real>) ); EntrywiseMap( scales, function<Real(Real)>(SquareRootScaling<Real>) ); DiagonalScale( LEFT, NORMAL, scales, d ); // TODO: Replace with SymmetricDiagonalSolve DiagonalSolve( RIGHT, NORMAL, scales, A ); DiagonalSolve( LEFT, NORMAL, scales, A ); } SetIndent( indent ); }
void rbBytecode::Parse() { wxLogMessage(wxT("")); // Initialize stack // parse until end-script marker Root = new rbToken(NULL,-1,wxT("ROOT"),wxT("ROOT")); PushIndent(); PrintOutput(wxT("{\n")); PushStack(Root); while( true ) { dword token = LoadToken(); if( token == 0x53 ) break; } PopStack(); PopIndent(); //ScriptText.RemoveLast(); // remove tab PrintOutput( wxT("}\n") ); }
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 ); }
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: 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()); 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 ) colScale.SetLocal ( jLoc, 0, Max(colScale.GetLocal(jLoc,0), colScaleB.GetLocal(jLoc,0)) ); EntrywiseMap( colScale, function<Real(Real)>(DampScaling<Real>) ); DiagonalScale( LEFT, NORMAL, colScale, dCol ); DiagonalSolve( RIGHT, NORMAL, colScale, A ); DiagonalSolve( RIGHT, NORMAL, colScale, B );
inline vector<BigInt> PollardRho ( const BigInt& n, const PollardRhoCtrl& ctrl ) { vector<BigInt> factors; BigInt nRem = n; Timer timer; PushIndent(); while( true ) { // Try Miller-Rabin first if( ctrl.time ) timer.Start(); Primality primality = PrimalityTest( nRem, ctrl.numReps ); if( primality == PRIME ) { if( ctrl.time ) Output(nRem," is prime (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is prime"); factors.push_back( nRem ); break; } else if( primality == PROBABLY_PRIME ) { if( ctrl.time ) Output(nRem," is probably prime (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is probably prime"); factors.push_back( nRem ); break; } else { if( ctrl.time ) Output(nRem," is composite (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is composite"); } if( ctrl.progress ) Output("Attempting to factor ",nRem," with a=",ctrl.a0); if( ctrl.time ) timer.Start(); PushIndent(); BigInt factor; try { factor = pollard_rho::FindFactor( nRem, ctrl.a0, ctrl ); } catch( const exception& e ) // TODO: Introduce factor exception? { // Try again with a=ctrl.a1 if( ctrl.progress ) Output("Attempting to factor ",nRem," with a=",ctrl.a1); factor = pollard_rho::FindFactor( nRem, ctrl.a1, ctrl ); } if( ctrl.time ) Output("Pollard-rho: ",timer.Stop()," seconds"); PopIndent(); factors.push_back( factor ); nRem /= factor; } PopIndent(); sort( factors.begin(), factors.end() ); return factors; }
static inline void PushAndClearIndent() { PushIndent(); ClearIndent(); }
inline vector<BigInt> PollardPMinusOne ( const BigInt& n, DynamicSieve<SieveUnsigned>& sieve, const PollardPMinusOneCtrl<SieveUnsigned>& ctrl ) { vector<BigInt> factors; BigInt nRem = n; Timer timer; PushIndent(); while( true ) { // Try Miller-Rabin first if( ctrl.time ) timer.Start(); Primality primality = PrimalityTest( nRem, ctrl.numReps ); if( primality == PRIME ) { if( ctrl.time ) Output(nRem," is prime (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is prime"); factors.push_back( nRem ); break; } else if( primality == PROBABLY_PRIME ) { if( ctrl.time ) Output(nRem," is probably prime (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is probably prime"); factors.push_back( nRem ); break; } else { if( ctrl.time ) Output(nRem," is composite (",timer.Stop()," seconds)"); else if( ctrl.progress ) Output(nRem," is composite"); } if( ctrl.progress ) Output("Attempting to factor ",nRem); if( ctrl.time ) timer.Start(); PushIndent(); BigInt factor = pollard_pm1::FindFactor( nRem, sieve, ctrl ); PopIndent(); if( ctrl.time ) Output("Pollard p-1: ",timer.Stop()," seconds"); // The factor might be composite, so attempt to factor it PushIndent(); auto subfactors = PollardPMinusOne( factor, ctrl ); PopIndent(); for( auto subfactor : subfactors ) factors.push_back( subfactor ); nRem /= factor; } PopIndent(); sort( factors.begin(), factors.end() ); return factors; }