Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ > Class Template Reference

Inheritance diagram for Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >:

Public Types
enum	{   ColsAtCompileTime ,   MaxColsAtCompileTime }
enum	{ UpLo }
using	AccelDenseMatrix = typename internal::SparseTypesTrait< Scalar >::AccelDenseMatrix
using	AccelDenseVector = typename internal::SparseTypesTrait< Scalar >::AccelDenseVector
using	AccelSparseMatrix = typename internal::SparseTypesTrait< Scalar >::AccelSparseMatrix
typedef MatrixType_	MatrixType
using	NumericFactorization = typename internal::SparseTypesTrait< Scalar >::NumericFactorization
using	NumericFactorizationDeleter = typename internal::SparseTypesTrait< Scalar >::NumericFactorizationDeleter
typedef MatrixType::Scalar	Scalar
typedef MatrixType::StorageIndex	StorageIndex
using	SymbolicFactorization = typename internal::SparseTypesTrait< Scalar >::SymbolicFactorization
using	SymbolicFactorizationDeleter = typename internal::SparseTypesTrait< Scalar >::SymbolicFactorizationDeleter

Public Member Functions
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
	AccelerateImpl ()
	AccelerateImpl (const MatrixType &matrix)
void	analyzePattern (const MatrixType &matrix)
Index	cols () const
void	compute (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
ComputationInfo	info () const
Index	rows () const
void	setOrder (SparseOrder_t order)
	~AccelerateImpl ()
Public Member Functions inherited from Eigen::SparseSolverBase< AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ > >
AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ > &	derived ()
const AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ > &	derived () const
const Solve< AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()

Protected Types
using	Base = SparseSolverBase< AccelerateImpl >

Protected Member Functions
Derived &	derived ()
const Derived &	derived () const
void	updateInfoStatus (SparseStatus_t status) const

Protected Attributes
ComputationInfo	m_info
bool	m_isInitialized
Index	m_nCols
Index	m_nRows
std::unique_ptr< NumericFactorization, NumericFactorizationDeleter >	m_numericFactorization
SparseOrder_t	m_order
SparseKind_t	m_sparseKind
std::unique_ptr< SymbolicFactorization, SymbolicFactorizationDeleter >	m_symbolicFactorization
SparseTriangle_t	m_triType
Protected Attributes inherited from Eigen::SparseSolverBase< AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ > >
bool	m_isInitialized

Private Member Functions
template<typename T >
void	buildAccelSparseMatrix (const SparseMatrix< T > &a, AccelSparseMatrix &A, std::vector< long > &columnStarts)
void	doAnalysis (AccelSparseMatrix &A)
void	doFactorization (AccelSparseMatrix &A)

Detailed Description

template<typename MatrixType_, int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>
class Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >

Definition at line 149 of file AccelerateSupport.h.

Member Typedef Documentation

AccelDenseMatrix

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelDenseMatrix = typename internal::SparseTypesTrait<Scalar>::AccelDenseMatrix

Definition at line 165 of file AccelerateSupport.h.

AccelDenseVector

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelDenseVector = typename internal::SparseTypesTrait<Scalar>::AccelDenseVector

Definition at line 164 of file AccelerateSupport.h.

AccelSparseMatrix

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelSparseMatrix = typename internal::SparseTypesTrait<Scalar>::AccelSparseMatrix

Definition at line 166 of file AccelerateSupport.h.

Base

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::Base = SparseSolverBase<AccelerateImpl>

protected

Definition at line 151 of file AccelerateSupport.h.

MatrixType

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

typedef MatrixType_ Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::MatrixType

Definition at line 158 of file AccelerateSupport.h.

NumericFactorization

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::NumericFactorization = typename internal::SparseTypesTrait<Scalar>::NumericFactorization

Definition at line 168 of file AccelerateSupport.h.

NumericFactorizationDeleter

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::NumericFactorizationDeleter = typename internal::SparseTypesTrait<Scalar>::NumericFactorizationDeleter

Definition at line 170 of file AccelerateSupport.h.

Scalar

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

typedef MatrixType::Scalar Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::Scalar

Definition at line 159 of file AccelerateSupport.h.

StorageIndex

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

typedef MatrixType::StorageIndex Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::StorageIndex

Definition at line 160 of file AccelerateSupport.h.

SymbolicFactorization

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::SymbolicFactorization = typename internal::SparseTypesTrait<Scalar>::SymbolicFactorization

Definition at line 167 of file AccelerateSupport.h.

SymbolicFactorizationDeleter

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

using Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::SymbolicFactorizationDeleter = typename internal::SparseTypesTrait<Scalar>::SymbolicFactorizationDeleter

Definition at line 169 of file AccelerateSupport.h.

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

Definition at line 161 of file AccelerateSupport.h.

{ ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

anonymous enum

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

anonymous enum

Enumerator
UpLo

Definition at line 162 of file AccelerateSupport.h.

{ UpLo = UpLo_ };

Constructor & Destructor Documentation

AccelerateImpl() [1/2]

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl ( )

inline

Definition at line 172 of file AccelerateSupport.h.

                   {
    m_isInitialized = false;
 
    auto check_flag_set = [](int value, int flag) { return ((value & flag) == flag); };
 
    if (check_flag_set(UpLo_, Symmetric)) {
      m_sparseKind = SparseSymmetric;
      m_triType = (UpLo_ & Lower) ? SparseLowerTriangle : SparseUpperTriangle;
    } else if (check_flag_set(UpLo_, UnitLower)) {
      m_sparseKind = SparseUnitTriangular;
      m_triType = SparseLowerTriangle;
    } else if (check_flag_set(UpLo_, UnitUpper)) {
      m_sparseKind = SparseUnitTriangular;
      m_triType = SparseUpperTriangle;
    } else if (check_flag_set(UpLo_, StrictlyLower)) {
      m_sparseKind = SparseTriangular;
      m_triType = SparseLowerTriangle;
    } else if (check_flag_set(UpLo_, StrictlyUpper)) {
      m_sparseKind = SparseTriangular;
      m_triType = SparseUpperTriangle;
    } else if (check_flag_set(UpLo_, Lower)) {
      m_sparseKind = SparseTriangular;
      m_triType = SparseLowerTriangle;
    } else if (check_flag_set(UpLo_, Upper)) {
      m_sparseKind = SparseTriangular;
      m_triType = SparseUpperTriangle;
    } else {
      m_sparseKind = SparseOrdinary;
      m_triType = (UpLo_ & Lower) ? SparseLowerTriangle : SparseUpperTriangle;
    }
 
    m_order = SparseOrderDefault;
  }

AccelerateImpl() [2/2]

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl ( const MatrixType &  matrix )

inlineexplicit

Definition at line 206 of file AccelerateSupport.h.

: AccelerateImpl() { compute(matrix); }

~AccelerateImpl()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::~AccelerateImpl ( )

inline

Definition at line 208 of file AccelerateSupport.h.

{}

Member Function Documentation

_solve_impl()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

template<typename Rhs , typename Dest >

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	dest
	)		const

Definition at line 385 of file AccelerateSupport.h.

                                                                                                         {
  if (!m_numericFactorization) {
    m_info = InvalidInput;
    return;
  }
 
  eigen_assert(m_nRows == b.rows());
  eigen_assert(((b.cols() == 1) || b.outerStride() == b.rows()));
 
  SparseStatus_t status = SparseStatusOK;
 
  Scalar* b_ptr = const_cast<Scalar*>(b.derived().data());
  Scalar* x_ptr = const_cast<Scalar*>(x.derived().data());
 
  AccelDenseMatrix xmat{};
  xmat.attributes = SparseAttributes_t();
  xmat.columnCount = static_cast<int>(x.cols());
  xmat.rowCount = static_cast<int>(x.rows());
  xmat.columnStride = xmat.rowCount;
  xmat.data = x_ptr;
 
  AccelDenseMatrix bmat{};
  bmat.attributes = SparseAttributes_t();
  bmat.columnCount = static_cast<int>(b.cols());
  bmat.rowCount = static_cast<int>(b.rows());
  bmat.columnStride = bmat.rowCount;
  bmat.data = b_ptr;
 
  SparseSolve(*m_numericFactorization, bmat, xmat);
 
  updateInfoStatus(status);
}

analyzePattern()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::analyzePattern

(

const MatrixType &

a

)

Performs a symbolic decomposition on the sparsity pattern of matrix a.

This function is particularly useful when solving for several problems having the same structure.

See also

factorize()

Definition at line 346 of file AccelerateSupport.h.

                                                                                                    {
  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
  m_nRows = a.rows();
  m_nCols = a.cols();
 
  AccelSparseMatrix A{};
  std::vector<long> columnStarts;
 
  buildAccelSparseMatrix(a, A, columnStarts);
 
  doAnalysis(A);
 
  m_isInitialized = true;
}

buildAccelSparseMatrix()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

template<typename T >

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::buildAccelSparseMatrix ( const SparseMatrix< T > &  a, AccelSparseMatrix &  A, std::vector< long > &  columnStarts  )

inlineprivate

Definition at line 232 of file AccelerateSupport.h.

                                                                                                             {
    const Index nColumnsStarts = a.cols() + 1;
 
    columnStarts.resize(nColumnsStarts);
 
    for (Index i = 0; i < nColumnsStarts; i++) columnStarts[i] = a.outerIndexPtr()[i];
 
    SparseAttributes_t attributes{};
    attributes.transpose = false;
    attributes.triangle = m_triType;
    attributes.kind = m_sparseKind;
 
    SparseMatrixStructure structure{};
    structure.attributes = attributes;
    structure.rowCount = static_cast<int>(a.rows());
    structure.columnCount = static_cast<int>(a.cols());
    structure.blockSize = 1;
    structure.columnStarts = columnStarts.data();
    structure.rowIndices = const_cast<int*>(a.innerIndexPtr());
 
    A.structure = structure;
    A.data = const_cast<T*>(a.valuePtr());
  }

cols()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Index Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::cols ( ) const

inline

Definition at line 210 of file AccelerateSupport.h.

{ return m_nCols; }

compute()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::compute

(

const MatrixType &

a

)

Computes the symbolic and numeric decomposition of matrix a

Definition at line 321 of file AccelerateSupport.h.

                                                                                             {
  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
  m_nRows = a.rows();
  m_nCols = a.cols();
 
  AccelSparseMatrix A{};
  std::vector<long> columnStarts;
 
  buildAccelSparseMatrix(a, A, columnStarts);
 
  doAnalysis(A);
 
  if (m_symbolicFactorization) doFactorization(A);
 
  m_isInitialized = true;
}

derived() [1/2]

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Derived& Eigen::SparseSolverBase< Derived >::derived

inlineprotected

Definition at line 83 of file SparseSolverBase.h.

{ return *static_cast<Derived*>(this); }

derived() [2/2]

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

const Derived& Eigen::SparseSolverBase< Derived >::derived

inlineprotected

Definition at line 84 of file SparseSolverBase.h.

{ return *static_cast<const Derived*>(this); }

doAnalysis()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doAnalysis ( AccelSparseMatrix &  A )

inlineprivate

Definition at line 256 of file AccelerateSupport.h.

                                        {
    m_numericFactorization.reset(nullptr);
 
    SparseSymbolicFactorOptions opts{};
    opts.control = SparseDefaultControl;
    opts.orderMethod = m_order;
    opts.order = nullptr;
    opts.ignoreRowsAndColumns = nullptr;
    opts.malloc = malloc;
    opts.free = free;
    opts.reportError = nullptr;
 
    m_symbolicFactorization.reset(new SymbolicFactorization(SparseFactor(Solver_, A.structure, opts)));
 
    SparseStatus_t status = m_symbolicFactorization->status;
 
    updateInfoStatus(status);
 
    if (status != SparseStatusOK) m_symbolicFactorization.reset(nullptr);
  }

doFactorization()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doFactorization ( AccelSparseMatrix &  A )

inlineprivate

Definition at line 277 of file AccelerateSupport.h.

                                             {
    SparseStatus_t status = SparseStatusReleased;
 
    if (m_symbolicFactorization) {
      m_numericFactorization.reset(new NumericFactorization(SparseFactor(*m_symbolicFactorization, A)));
 
      status = m_numericFactorization->status;
 
      if (status != SparseStatusOK) m_numericFactorization.reset(nullptr);
    }
 
    updateInfoStatus(status);
  }

factorize()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::factorize

(

const MatrixType &

a

)

Performs a numeric decomposition of matrix a.

The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.

See also

analyzePattern()

Definition at line 369 of file AccelerateSupport.h.

                                                                                               {
  eigen_assert(m_symbolicFactorization && "You must first call analyzePattern()");
  eigen_assert(m_nRows == a.rows() && m_nCols == a.cols());
 
  if (EnforceSquare_) eigen_assert(a.rows() == a.cols());
 
  AccelSparseMatrix A{};
  std::vector<long> columnStarts;
 
  buildAccelSparseMatrix(a, A, columnStarts);
 
  doFactorization(A);
}

info()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

ComputationInfo Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::info ( ) const

inline

Definition at line 213 of file AccelerateSupport.h.

                               {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return m_info;
  }

rows()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Index Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::rows ( ) const

inline

Definition at line 211 of file AccelerateSupport.h.

{ return m_nRows; }

setOrder()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::setOrder ( SparseOrder_t  order )

inline

Sets the ordering algorithm to use.

Definition at line 228 of file AccelerateSupport.h.

{ m_order = order; }

updateInfoStatus()

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

void Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::updateInfoStatus ( SparseStatus_t  status ) const

inlineprotected

Definition at line 292 of file AccelerateSupport.h.

                                                     {
    switch (status) {
      case SparseStatusOK:
        m_info = Success;
        break;
      case SparseFactorizationFailed:
      case SparseMatrixIsSingular:
        m_info = NumericalIssue;
        break;
      case SparseInternalError:
      case SparseParameterError:
      case SparseStatusReleased:
      default:
        m_info = InvalidInput;
        break;
    }
  }

Member Data Documentation

m_info

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

ComputationInfo Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_info

mutableprotected

Definition at line 310 of file AccelerateSupport.h.

m_isInitialized

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Definition at line 123 of file SparseSolverBase.h.

m_nCols

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Index Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_nCols

protected

Definition at line 311 of file AccelerateSupport.h.

m_nRows

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

Index Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_nRows

protected

Definition at line 311 of file AccelerateSupport.h.

m_numericFactorization

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

std::unique_ptr<NumericFactorization, NumericFactorizationDeleter> Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_numericFactorization

protected

Definition at line 313 of file AccelerateSupport.h.

m_order

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

SparseOrder_t Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_order

protected

Definition at line 316 of file AccelerateSupport.h.

m_sparseKind

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

SparseKind_t Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_sparseKind

protected

Definition at line 314 of file AccelerateSupport.h.

m_symbolicFactorization

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

std::unique_ptr<SymbolicFactorization, SymbolicFactorizationDeleter> Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_symbolicFactorization

protected

Definition at line 312 of file AccelerateSupport.h.

m_triType

template<typename MatrixType_ , int UpLo_, SparseFactorization_t Solver_, bool EnforceSquare_>

SparseTriangle_t Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_triType

protected

Definition at line 315 of file AccelerateSupport.h.

---

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

• AccelerateSupport.h