namespace ldl {
Int Analysis( NodeInfo& rootInfo, Int myOff=0 );
void Analysis
( DistNodeInfo& rootInfo, bool storeFactRecvInds=true );
void GetChildGridDims
( const DistNodeInfo& info, vector<int>& gridHeights, vector<int>& gridWidths );
void AMDOrder
( const vector<Int>& subOffsets,
const vector<Int>& subTargets,
vector<Int>& amdPerm,
double* control=nullptr,
double* info=nullptr );
void NestedDissection
( const Graph& graph,
vector<Int>& map,
Separator& rootSep,
NodeInfo& rootInfo,
const BisectCtrl& ctrl=BisectCtrl() );
void NestedDissection
( const DistGraph& graph,
DistMap& map,
DistSeparator& rootSep,
DistNodeInfo& rootInfo,
const BisectCtrl& ctrl=BisectCtrl() );
void NaturalNestedDissection
( Int nx, Int ny, Int nz,
const Graph& graph,
vector<Int>& map,
Separator& rootSep,
NodeInfo& info,
Int cutoff );
void NaturalNestedDissection
( Int nx, Int ny, Int nz,
const DistGraph& graph,
DistMap& map,
DistSeparator& rootSep,
DistNodeInfo& info,
Int cutoff,
bool storeFactRecvInds=false );
void BuildMap( const Separator& rootSep, vector<Int>& map );
void BuildMap( const DistSeparator& rootSep, DistMap& map );
} // namespace ldl
namespace El {
// Linear
// ======
template<typename F>
void LinearSolve( const Matrix<F>& A, Matrix<F>& B );
template<typename F>
void LinearSolve( const ElementalMatrix<F>& A, ElementalMatrix<F>& B );
template<typename F>
void LinearSolve
( const DistMatrix<F,MC,MR,BLOCK>& A, DistMatrix<F,MC,MR,BLOCK>& B );
template<typename F>
void LinearSolve
( const SparseMatrix<F>& A, Matrix<F>& B,
const LeastSquaresCtrl<Base<F>>& ctrl=LeastSquaresCtrl<Base<F>>() );
template<typename F>
void LinearSolve
( const DistSparseMatrix<F>& A, DistMultiVec<F>& B,
const LeastSquaresCtrl<Base<F>>& ctrl=LeastSquaresCtrl<Base<F>>() );
namespace lin_solve {
template<typename F>
void Overwrite( Matrix<F>& A, Matrix<F>& B );
template<typename F>
void Overwrite( ElementalMatrix<F>& A, ElementalMatrix<F>& B );
} // namespace lin_solve
// Hermitian
// =========
template<typename F>
void HermitianSolve
( UpperOrLower uplo, Orientation orientation,
const Matrix<F>& A, Matrix<F>& B,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void HermitianSolve
( UpperOrLower uplo, Orientation orientation,
const ElementalMatrix<F>& A, ElementalMatrix<F>& B,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void HermitianSolve
( const SparseMatrix<F>& A, Matrix<F>& B,
bool tryLDL=false,
const BisectCtrl& ctrl=BisectCtrl() );
template<typename F>
void HermitianSolve
( const DistSparseMatrix<F>& A, DistMultiVec<F>& B,
bool tryLDL=false,
const BisectCtrl& ctrl=BisectCtrl() );
namespace herm_solve {
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
Matrix<F>& A, Matrix<F>& B,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
ElementalMatrix<F>& A, ElementalMatrix<F>& B,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
} // namespace herm_solve
// Symmetric
// =========
template<typename F>
void SymmetricSolve
( UpperOrLower uplo, Orientation orientation,
const Matrix<F>& A, Matrix<F>& B,
bool conjugate=false,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void SymmetricSolve
( UpperOrLower uplo, Orientation orientation,
const ElementalMatrix<F>& A, ElementalMatrix<F>& B,
bool conjugate=false,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void SymmetricSolve
( const SparseMatrix<F>& A, Matrix<F>& B,
bool conjugate=false, bool tryLDL=false,
const BisectCtrl& ctrl=BisectCtrl() );
template<typename F>
void SymmetricSolve
( const DistSparseMatrix<F>& A, DistMultiVec<F>& B,
bool conjugate=false, bool tryLDL=false,
const BisectCtrl& ctrl=BisectCtrl() );
namespace symm_solve {
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
Matrix<F>& A, Matrix<F>& B,
bool conjugate=false,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
ElementalMatrix<F>& A, ElementalMatrix<F>& B,
bool conjugate=false,
const LDLPivotCtrl<Base<F>>& ctrl=LDLPivotCtrl<Base<F>>() );
} // namespace symm_solve
// Hermitian Positive-Definite
// ===========================
template<typename F>
void HPDSolve
( UpperOrLower uplo, Orientation orientation,
const Matrix<F>& A, Matrix<F>& B );
template<typename F>
void HPDSolve
( UpperOrLower uplo, Orientation orientation,
const ElementalMatrix<F>& A, ElementalMatrix<F>& B );
template<typename F>
void HPDSolve
( const SparseMatrix<F>& A, Matrix<F>& B,
const BisectCtrl& ctrl=BisectCtrl() );
template<typename F>
void HPDSolve
( const DistSparseMatrix<F>& A, DistMultiVec<F>& B,
const BisectCtrl& ctrl=BisectCtrl() );
namespace hpd_solve {
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
Matrix<F>& A, Matrix<F>& B );
template<typename F>
void Overwrite
( UpperOrLower uplo, Orientation orientation,
ElementalMatrix<F>& A, ElementalMatrix<F>& B );
} // namespace hpd_solve
// Multi-shift Hessenberg
// ======================
template<typename F>
void MultiShiftHessSolve
( UpperOrLower uplo, Orientation orientation,
F alpha, const Matrix<F>& H, const Matrix<F>& shifts,
Matrix<F>& X );
template<typename F>
void MultiShiftHessSolve
( UpperOrLower uplo, Orientation orientation,
F alpha, const ElementalMatrix<F>& H, const ElementalMatrix<F>& shifts,
ElementalMatrix<F>& X );
} // namespace El
namespace El {
// Graph reordering
// ================
struct BisectCtrl
{
bool sequential;
Int numDistSeps;
Int numSeqSeps;
Int cutoff;
bool storeFactRecvInds;
BisectCtrl()
: sequential(true), numDistSeps(1), numSeqSeps(1), cutoff(1024),
storeFactRecvInds(false)
{ }
};
Int Bisect
( const Graph& graph,
Graph& leftChild,
Graph& rightChild,
vector<Int>& perm,
const BisectCtrl& ctrl=BisectCtrl() );
// NOTE: for two or more processes
Int Bisect
( const DistGraph& graph,
DistGraph& child,
DistMap& perm,
bool& onLeft,
const BisectCtrl& ctrl=BisectCtrl() );
Int NaturalBisect
( Int nx, Int ny, Int nz,
const Graph& graph,
Int& nxLeft, Int& nyLeft, Int& nzLeft,
Graph& leftChild,
Int& nxRight, Int& nyRight, Int& nzRight,
Graph& rightChild, vector<Int>& perm );
// NOTE: for two or more processes
Int NaturalBisect
( Int nx, Int ny, Int nz,
const DistGraph& graph,
Int& nxChild, Int& nyChild, Int& nzChild,
DistGraph& child, DistMap& perm, bool& onLeft );
void EnsurePermutation( const vector<Int>& map );
void EnsurePermutation( const DistMap& map );
void BuildChildrenFromPerm
( const Graph& graph, const vector<Int>& perm,
Int leftChildSize, Graph& leftChild,
Int rightChildSize, Graph& rightChild );
void BuildChildFromPerm
( const DistGraph& graph, const DistMap& perm,
Int leftChildSize, Int rightChildSize,
bool& onLeft, DistGraph& child );
// Median
// ======
template<typename Real,typename=EnableIf<IsReal<Real>>>
ValueInt<Real> Median( const Matrix<Real>& x );
template<typename Real,typename=EnableIf<IsReal<Real>>>
ValueInt<Real> Median( const ElementalMatrix<Real>& x );
// Sort
// ====
template<typename Real,typename=EnableIf<IsReal<Real>>>
void Sort( Matrix<Real>& X, SortType sort=ASCENDING );
template<typename Real,typename=EnableIf<IsReal<Real>>>
void Sort( ElementalMatrix<Real>& X, SortType sort=ASCENDING );
template<typename Real,typename=EnableIf<IsReal<Real>>>
vector<ValueInt<Real>>
TaggedSort( const Matrix<Real>& x, SortType sort=ASCENDING );
template<typename Real,typename=EnableIf<IsReal<Real>>>
vector<ValueInt<Real>>
TaggedSort( const ElementalMatrix<Real>& x, SortType sort=ASCENDING );
} // namespace El