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

#include <AccelerateSupport.h>

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

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

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

Protected Types
using	Base = SparseSolverBase< AccelerateImpl >

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

Protected Attributes
ComputationInfo	m_info
Index	m_nRows
Index	m_nCols
std::unique_ptr< SymbolicFactorization, SymbolicFactorizationDeleter >	m_symbolicFactorization
std::unique_ptr< NumericFactorization, NumericFactorizationDeleter >	m_numericFactorization
SparseKind_t	m_sparseKind
SparseTriangle_t	m_triType
SparseOrder_t	m_order
bool	m_isInitialized
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)

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

AccelDenseVector

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

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

AccelSparseMatrix

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

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

Base

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

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

protected

MatrixType

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

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

NumericFactorization

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

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

NumericFactorizationDeleter

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

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

Scalar

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

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

StorageIndex

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

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

SymbolicFactorization

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

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

SymbolicFactorizationDeleter

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

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

Member Enumeration Documentation

anonymous enum

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

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

{ ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

anonymous enum

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

anonymous enum

Enumerator
UpLo

{ 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

                   {
    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;
  }

References Eigen::Lower, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_isInitialized, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_order, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_sparseKind, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_triType, Eigen::StrictlyLower, Eigen::StrictlyUpper, Eigen::Symmetric, Eigen::UnitLower, Eigen::UnitUpper, Eigen::Upper, and Eigen::value.

AccelerateImpl() [2/2]

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

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

inlineexplicit

: AccelerateImpl() { compute(matrix); }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::compute(), and matrix().

~AccelerateImpl()

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

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

inline

{}

Member Function Documentation

_solve_impl() [1/2]

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

                                                                                                         {
  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);
}

References b, eigen_assert, Eigen::InvalidInput, and plotDoE::x.

_solve_impl() [2/2]

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

template<typename Rhs , typename Dest >

void Eigen::SparseSolverBase< Derived >::_solve_impl ( typename Rhs  , typename Dest    )

inline

default implementation of solving with a sparse rhs

                                                                                       {
    internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
  }

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()

                                                                                                    {
  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;
}

References a, and eigen_assert.

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

                                                                                                             {
    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());
  }

References a, Eigen::PlainObjectBase< Derived >::data(), i, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_sparseKind, and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_triType.

cols()

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

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

inline

{ return m_nCols; }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_nCols.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

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

                                                                                             {
  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;
}

References a, and eigen_assert.

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

derived() [1/2]

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

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

inlineprotected

{ 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

{ 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

                                        {
    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);
  }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_numericFactorization, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_order, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_symbolicFactorization, and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::updateInfoStatus().

doFactorization()

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

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

inlineprivate

                                             {
    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);
  }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_numericFactorization, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_symbolicFactorization, and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::updateInfoStatus().

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()

                                                                                               {
  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);
}

References a, and eigen_assert.

info()

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

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

inline

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

References eigen_assert, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_info, and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_isInitialized.

rows()

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

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

inline

{ return m_nRows; }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_nRows.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

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.

{ m_order = order; }

References Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_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

                                                     {
    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;
    }
  }

References Eigen::InvalidInput, Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::m_info, Eigen::NumericalIssue, and Eigen::Success.

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doAnalysis(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doFactorization().

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

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::info(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::updateInfoStatus().

m_isInitialized

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

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::info().

m_nCols

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

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

protected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::cols().

m_nRows

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

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

protected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::rows().

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

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doAnalysis(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doFactorization().

m_order

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

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

protected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl(), Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doAnalysis(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::setOrder().

m_sparseKind

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

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

protected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::buildAccelSparseMatrix().

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

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doAnalysis(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::doFactorization().

m_triType

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

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

protected

Referenced by Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::AccelerateImpl(), and Eigen::AccelerateImpl< MatrixType_, UpLo_, Solver_, EnforceSquare_ >::buildAccelSparseMatrix().

---

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

• AccelerateSupport.h