Eigen::AMDOrdering< StorageIndex > Class Template Reference

#include <Ordering.h>

Public Types
typedef PermutationMatrix< Dynamic, Dynamic, StorageIndex >	PermutationType

Public Member Functions
template<typename MatrixType >
void	operator() (const MatrixType &mat, PermutationType &perm)
template<typename SrcType , unsigned int SrcUpLo>
void	operator() (const SparseSelfAdjointView< SrcType, SrcUpLo > &mat, PermutationType &perm)

Detailed Description

template<typename StorageIndex>
class Eigen::AMDOrdering< StorageIndex >

Functor computing the approximate minimum degree ordering If the matrix is not structurally symmetric, an ordering of A^T+A is computed

Template Parameters

StorageIndex

The type of indices of the matrix

See also

COLAMDOrdering

Member Typedef Documentation

PermutationType

template<typename StorageIndex >

typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> Eigen::AMDOrdering< StorageIndex >::PermutationType

Member Function Documentation

operator()() [1/2]

template<typename StorageIndex >

template<typename MatrixType >

void Eigen::AMDOrdering< StorageIndex >::operator() ( const MatrixType &  mat, PermutationType &  perm  )

inline

Compute the permutation vector from a sparse matrix This routine is much faster if the input matrix is column-major

                                                                {
    // Compute the symmetric pattern
    SparseMatrix<typename MatrixType::Scalar, ColMajor, StorageIndex> symm;
    internal::ordering_helper_at_plus_a(mat, symm);
 
    // Call the AMD routine
    // m_mat.prune(keep_diag());
    internal::minimum_degree_ordering(symm, perm);
  }

References Eigen::internal::minimum_degree_ordering(), Eigen::internal::ordering_helper_at_plus_a(), and symm().

operator()() [2/2]

template<typename StorageIndex >

template<typename SrcType , unsigned int SrcUpLo>

void Eigen::AMDOrdering< StorageIndex >::operator() ( const SparseSelfAdjointView< SrcType, SrcUpLo > &  mat, PermutationType &  perm  )

inline

Compute the permutation with a selfadjoint matrix

                                                                                             {
    SparseMatrix<typename SrcType::Scalar, ColMajor, StorageIndex> C;
    C = mat;
 
    // Call the AMD routine
    // m_mat.prune(keep_diag()); //Remove the diagonal elements
    internal::minimum_degree_ordering(C, perm);
  }

References Eigen::internal::minimum_degree_ordering().

---

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

• Ordering.h