Beispiel #1
0
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
Beispiel #2
0
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
Beispiel #3
0
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