Typedefs | Enumerations | Functions | Variables
Eigen::internal Namespace Reference

Typedefs

typedef __vector unsigned char Packet16uc
typedef __m128d Packet2d
typedef __vector __bool int Packet4bi
typedef __vector float Packet4f
typedef __vector int Packet4i
typedef __vector unsigned int Packet4ui
typedef __vector short int Packet8i

Enumerations

enum  {
  floor_log2_terminate,
  floor_log2_move_up,
  floor_log2_move_down,
  floor_log2_bogus
}
enum  {
  SDP_IsDiagonal,
  SDP_IsSparseRowMajor,
  SDP_IsSparseColMajor
}
enum  {
  PreconditionIfMoreColsThanRows,
  PreconditionIfMoreRowsThanCols
}
enum  PermPermProduct_t { PermPermProduct }

Functions

template<typename T >
void aligned_delete (T *ptr, size_t size)
void aligned_free (void *ptr)
void * aligned_malloc (size_t size)
template<typename T >
T * aligned_new (size_t size)
void * aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<typename T >
amd_flip (const T &i)
template<typename T0 , typename T1 >
void amd_mark (const T0 *w, const T1 &j)
template<typename T0 , typename T1 >
bool amd_marked (const T0 *w, const T1 &j)
template<typename T >
amd_unflip (const T &i)
template<typename MatrixType , typename VectorsType , typename CoeffsType >
void apply_block_householder_on_the_left (MatrixType &mat, const VectorsType &vectors, const CoeffsType &hCoeffs)
template<typename VectorX , typename VectorY , typename OtherScalar >
void apply_rotation_in_the_plane (VectorX &_x, VectorY &_y, const JacobiRotation< OtherScalar > &j)
template<typename MatrixType >
SluMatrix asSluMatrix (MatrixType &mat)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool bicgstab (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, int &iters, typename Dest::RealScalar &tol_error)
template<typename Derived >
const Derived::Scalar bruteforce_det3_helper (const MatrixBase< Derived > &matrix, int a, int b, int c)
template<typename Derived >
const Derived::Scalar bruteforce_det4_helper (const MatrixBase< Derived > &matrix, int j, int k, int m, int n)
template<typename OldType , typename NewType >
NewType cast (const OldType &x)
template<typename Index >
EIGEN_ALWAYS_INLINE void check_rows_cols_for_overflow (Index rows, Index cols)
template<typename T >
EIGEN_ALWAYS_INLINE void check_size_for_overflow (size_t size)
void check_that_malloc_is_allowed ()
template<typename Scalar , typename CholmodType >
void cholmod_configure_matrix (CholmodType &mat)
template<typename MatrixType , int i, int j>
MatrixType::Scalar cofactor_3x3 (const MatrixType &m)
template<typename MatrixType , int i, int j>
MatrixType::Scalar cofactor_4x4 (const MatrixType &matrix)
template<typename MatrixType , typename ResultType >
void compute_inverse_size2_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, ResultType &result)
template<typename MatrixType , typename ResultType >
void compute_inverse_size3_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, const Matrix< typename ResultType::Scalar, 3, 1 > &cofactors_col0, ResultType &result)
template<typename LhsScalar , typename RhsScalar , int KcFactor>
void computeProductBlockingSizes (std::ptrdiff_t &k, std::ptrdiff_t &m, std::ptrdiff_t &n)
 Computes the blocking parameters for a m x k times k x n matrix product.
template<typename LhsScalar , typename RhsScalar >
void computeProductBlockingSizes (std::ptrdiff_t &k, std::ptrdiff_t &m, std::ptrdiff_t &n)
template<typename T , bool Align>
void conditional_aligned_delete (T *ptr, size_t size)
template<typename T , bool Align>
void conditional_aligned_delete_auto (T *ptr, size_t size)
template<bool Align>
void conditional_aligned_free (void *ptr)
template<>
void conditional_aligned_free< false > (void *ptr)
template<bool Align>
void * conditional_aligned_malloc (size_t size)
template<>
void * conditional_aligned_malloc< false > (size_t size)
template<typename T , bool Align>
T * conditional_aligned_new (size_t size)
template<typename T , bool Align>
T * conditional_aligned_new_auto (size_t size)
template<bool Align>
void * conditional_aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<>
void * conditional_aligned_realloc< false > (void *ptr, size_t new_size, size_t)
template<typename T , bool Align>
T * conditional_aligned_realloc_new (T *pts, size_t new_size, size_t old_size)
template<typename T , bool Align>
T * conditional_aligned_realloc_new_auto (T *pts, size_t new_size, size_t old_size)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
EIGEN_DONT_INLINE void conjugate_gradient (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, int &iters, typename Dest::RealScalar &tol_error)
template<typename T >
T * const_cast_ptr (const T *ptr)
template<typename T >
T * construct_elements_of_array (T *ptr, size_t size)
bool copy_bool (bool b)
template<typename Index >
Index cs_tdfs (Index j, Index k, Index *head, const Index *next, Index *post, Index *stack)
template<typename T >
void destruct_elements_of_array (T *ptr, size_t size)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (real, Scalar) real(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (imag, Scalar) imag(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (real_ref, Scalar) real_ref(Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (imag_ref, Scalar) imag_ref(Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (conj, Scalar) conj(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (abs, Scalar) abs(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (abs2, Scalar) abs2(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (norm1, Scalar) norm1(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (hypot, Scalar) hypot(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (sqrt, Scalar) sqrt(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (atan2, Scalar) atan2(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (pow, Scalar) pow(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (random, Scalar) random(const Scalar &x
 EIGEN_MEMBER_FUNCTOR (squaredNorm, Size *NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (norm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (stableNorm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (blueNorm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (hypotNorm,(Size-1)*functor_traits< scalar_hypot_op< Scalar > >::Cost)
 EIGEN_MEMBER_FUNCTOR (sum,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (mean,(Size-1)*NumTraits< Scalar >::AddCost+NumTraits< Scalar >::MulCost)
 EIGEN_MEMBER_FUNCTOR (minCoeff,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (maxCoeff,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (all,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (any,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (count,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (prod,(Size-1)*NumTraits< Scalar >::MulCost)
void eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int *invp, float *x, int nbrhs, int *iparm, double *dparm)
void eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int *invp, double *x, int nbrhs, int *iparm, double *dparm)
void eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex< float > *vals, int *perm, int *invp, std::complex< float > *x, int nbrhs, int *iparm, double *dparm)
void eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex< double > *vals, int *perm, int *invp, std::complex< double > *x, int nbrhs, int *iparm, double *dparm)
template<typename MatrixType >
void EigenSymmetrizeMatrixGraph (const MatrixType &In, MatrixType &Out, MatrixType &StrMatTrans, bool &hasTranspose)
template<typename MatrixType >
void EigenToCNumbering (MatrixType &mat)
template<typename MatrixType >
void EigenToFortranNumbering (MatrixType &mat)
template<typename T >
const T::Scalar * extract_data (const T &m)
template<typename CJ , typename A , typename B , typename C , typename T >
void gebp_madd (const CJ &cj, A &a, B &b, C &c, T &t)
template<typename Derived >
const Derived::Scalar general_det3_helper (const MatrixBase< Derived > &matrix, int i1, int i2, int i3, int j1, int j2, int j3)
void * generic_aligned_realloc (void *ptr, size_t size, size_t old_size)
void handmade_aligned_free (void *ptr)
void * handmade_aligned_malloc (size_t size)
void * handmade_aligned_realloc (void *ptr, size_t size, size_t=0)
template<typename MatrixQR , typename HCoeffs >
void householder_qr_inplace_blocked (MatrixQR &mat, HCoeffs &hCoeffs, typename MatrixQR::Index maxBlockSize=32, typename MatrixQR::Scalar *tempData=0)
template<typename MatrixQR , typename HCoeffs >
void householder_qr_inplace_unblocked (MatrixQR &mat, HCoeffs &hCoeffs, typename MatrixQR::Scalar *tempData=0)
template<typename Scalar >
add_const_on_value_type
< EIGEN_MATHFUNC_RETVAL(imag_ref,
Scalar) >::type 
imag_ref (const Scalar &x)
template<typename Scalar >
bool isApprox (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
bool isApproxOrLessThan (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename T >
bool isfinite (const T &x)
template<typename Scalar , typename OtherScalar >
bool isMuchSmallerThan (const Scalar &x, const OtherScalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename TriangularFactorType , typename VectorsType , typename CoeffsType >
void make_block_householder_triangular_factor (TriangularFactorType &triFactor, const VectorsType &vectors, const CoeffsType &hCoeffs)
void manage_caching_sizes (Action action, std::ptrdiff_t *l1=0, std::ptrdiff_t *l2=0)
std::ptrdiff_t manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
void manage_multi_threading (Action action, int *v)
template<typename Scalar , int Flags, typename Index >
MappedSparseMatrix< Scalar,
Flags, Index > 
map_superlu (SluMatrix &sluMat)
template<typename Scalar , typename Index >
void minimum_degree_ordering (SparseMatrix< Scalar, ColMajor, Index > &C, PermutationMatrix< Dynamic, Dynamic, Index > &perm)
int nbThreads ()
template<typename Packet >
Packet pabs (const Packet &a)
template<>
Packet4f pabs (const Packet4f &a)
template<>
Packet4i pabs (const Packet4i &a)
template<>
Packet2d pabs (const Packet2d &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
pacos (const Packet &a)
template<typename Packet >
Packet padd (const Packet &a, const Packet &b)
template<>
Packet1cd padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d padd< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f padd< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i padd< Packet4i > (const Packet4i &a, const Packet4i &b)
template<int Offset, typename PacketType >
void palign (PacketType &first, const PacketType &second)
template<typename Packet >
Packet pand (const Packet &a, const Packet &b)
template<>
Packet1cd pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d pand< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pand< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pand< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet >
Packet pandnot (const Packet &a, const Packet &b)
template<>
Packet1cd pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
template<bool Condition, typename Functor , typename Index >
void parallelize_gemm (const Functor &func, Index rows, Index cols, bool transpose)
template<typename MatrixType , typename TranspositionType >
void partial_lu_inplace (MatrixType &lu, TranspositionType &row_transpositions, typename TranspositionType::Index &nb_transpositions)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
pasin (const Packet &a)
template<>
Packet2cf pconj (const Packet2cf &a)
template<typename Packet >
Packet pconj (const Packet &a)
template<>
Packet1cd pconj (const Packet1cd &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
pcos (const Packet &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
EIGEN_UNUSED Packet4f 
pcos< Packet4f > (const Packet4f &_x)
template<typename Packet >
Packet pcplxflip (const Packet &a)
Packet2cf pcplxflip (const Packet2cf &x)
Packet1cd pcplxflip (const Packet1cd &x)
template<>
Packet2cf pcplxflip< Packet2cf > (const Packet2cf &x)
template<typename Packet >
Packet pdiv (const Packet &a, const Packet &b)
template<>
Packet1cd pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pdiv< Packet4i > (const Packet4i &, const Packet4i &)
template<int UpLo, typename MatrixType , int DestOrder>
void permute_symm_to_fullsymm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::Index > &_dest, const typename MatrixType::Index *perm=0)
template<int SrcUpLo, int DstUpLo, typename MatrixType , int DestOrder>
void permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::Index > &_dest, const typename MatrixType::Index *perm=0)
template<int _SrcUpLo, int _DstUpLo, typename MatrixType , int DstOrder>
void permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::Index > &_dest, const typename MatrixType::Index *perm)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
pexp (const Packet &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
EIGEN_UNUSED Packet4f 
pexp< Packet4f > (const Packet4f &_x)
template<typename Packet >
unpacket_traits< Packet >::type pfirst (const Packet &a)
template<>
std::complex< double > pfirst< Packet1cd > (const Packet1cd &a)
template<>
std::complex< float > pfirst< Packet2cf > (const Packet2cf &a)
template<>
double pfirst< Packet2d > (const Packet2d &a)
template<>
float pfirst< Packet4f > (const Packet4f &a)
template<>
int pfirst< Packet4i > (const Packet4i &a)
template<typename Packet >
Packet pload (const typename unpacket_traits< Packet >::type *from)
template<>
Packet1cd pload< Packet1cd > (const std::complex< double > *from)
template<>
Packet2cf pload< Packet2cf > (const std::complex< float > *from)
template<>
Packet2d pload< Packet2d > (const double *from)
template<>
Packet4f pload< Packet4f > (const float *from)
template<>
Packet4i pload< Packet4i > (const int *from)
template<typename Packet >
Packet ploaddup (const typename unpacket_traits< Packet >::type *from)
template<>
Packet1cd ploaddup< Packet1cd > (const std::complex< double > *from)
template<>
Packet2cf ploaddup< Packet2cf > (const std::complex< float > *from)
template<>
Packet2d ploaddup< Packet2d > (const double *from)
template<>
Packet4f ploaddup< Packet4f > (const float *from)
template<>
Packet4i ploaddup< Packet4i > (const int *from)
template<typename Packet , int LoadMode>
Packet ploadt (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
Packet ploadu (const typename unpacket_traits< Packet >::type *from)
template<>
Packet1cd ploadu< Packet1cd > (const std::complex< double > *from)
template<>
Packet2cf ploadu< Packet2cf > (const std::complex< float > *from)
template<>
Packet2d ploadu< Packet2d > (const double *from)
template<>
Packet4f ploadu< Packet4f > (const float *from)
template<>
Packet4i ploadu< Packet4i > (const int *from)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
plog (const Packet &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
EIGEN_UNUSED Packet4f 
plog< Packet4f > (const Packet4f &_x)
template<typename Scalar >
packet_traits< Scalar >::type plset (const Scalar &a)
template<>
Packet2d plset< double > (const double &a)
template<>
Packet4f plset< float > (const float &a)
template<>
Packet4i plset< int > (const int &a)
template<>
Packet4f pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
template<>
Packet4i pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
template<typename Packet >
Packet pmadd (const Packet &a, const Packet &b, const Packet &c)
template<typename Packet >
Packet pmax (const Packet &a, const Packet &b)
template<>
Packet2d pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet >
Packet pmin (const Packet &a, const Packet &b)
template<>
Packet2d pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet >
Packet pmul (const Packet &a, const Packet &b)
template<>
std::complex< float > pmul (const std::complex< float > &a, const std::complex< float > &b)
template<>
std::complex< double > pmul (const std::complex< double > &a, const std::complex< double > &b)
template<>
Packet1cd pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
template<>
Packet2cf pnegate (const Packet2cf &a)
template<typename Packet >
Packet pnegate (const Packet &a)
template<>
Packet2d pnegate (const Packet2d &a)
template<>
Packet4f pnegate (const Packet4f &a)
template<>
Packet4i pnegate (const Packet4i &a)
template<>
Packet1cd pnegate (const Packet1cd &a)
template<typename Packet >
Packet por (const Packet &a, const Packet &b)
template<>
Packet1cd por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d por< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f por< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i por< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet >
unpacket_traits< Packet >::type predux (const Packet &a)
template<>
std::complex< double > predux< Packet1cd > (const Packet1cd &a)
template<>
std::complex< float > predux< Packet2cf > (const Packet2cf &a)
template<>
double predux< Packet2d > (const Packet2d &a)
template<>
float predux< Packet4f > (const Packet4f &a)
template<>
int predux< Packet4i > (const Packet4i &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_max (const Packet &a)
template<>
double predux_max< Packet2d > (const Packet2d &a)
template<>
float predux_max< Packet4f > (const Packet4f &a)
template<>
int predux_max< Packet4i > (const Packet4i &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_min (const Packet &a)
template<>
double predux_min< Packet2d > (const Packet2d &a)
template<>
float predux_min< Packet4f > (const Packet4f &a)
template<>
int predux_min< Packet4i > (const Packet4i &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_mul (const Packet &a)
template<>
std::complex< double > predux_mul< Packet1cd > (const Packet1cd &a)
template<>
std::complex< float > predux_mul< Packet2cf > (const Packet2cf &a)
template<>
double predux_mul< Packet2d > (const Packet2d &a)
template<>
float predux_mul< Packet4f > (const Packet4f &a)
template<>
int predux_mul< Packet4i > (const Packet4i &a)
template<typename Packet >
Packet preduxp (const Packet *vecs)
template<>
Packet1cd preduxp< Packet1cd > (const Packet1cd *vecs)
template<>
Packet2cf preduxp< Packet2cf > (const Packet2cf *vecs)
template<>
Packet2d preduxp< Packet2d > (const Packet2d *vecs)
template<>
Packet4f preduxp< Packet4f > (const Packet4f *vecs)
template<>
Packet4i preduxp< Packet4i > (const Packet4i *vecs)
template<typename Scalar >
void prefetch (const Scalar *addr)
template<>
void prefetch< double > (const double *addr)
template<>
void prefetch< float > (const float *addr)
template<>
void prefetch< int > (const int *addr)
template<>
void prefetch< std::complex< double > > (const std::complex< double > *addr)
template<>
void prefetch< std::complex< float > > (const std::complex< float > *addr)
template<>
Packet2cf preverse (const Packet2cf &a)
template<typename Packet >
Packet preverse (const Packet &a)
template<>
Packet1cd preverse (const Packet1cd &a)
template<>
Packet2d preverse (const Packet2d &a)
template<>
Packet4f preverse (const Packet4f &a)
template<>
Packet4i preverse (const Packet4i &a)
template<typename Derived >
std::ostream & print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
template<typename Packet >
Packet pset1 (const typename unpacket_traits< Packet >::type &a)
template<>
Packet1cd pset1< Packet1cd > (const std::complex< double > &from)
template<>
Packet2cf pset1< Packet2cf > (const std::complex< float > &from)
template<>
Packet2d pset1< Packet2d > (const double &from)
template<>
Packet4f pset1< Packet4f > (const float &from)
template<>
Packet4i pset1< Packet4i > (const int &from)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
psin (const Packet &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
EIGEN_UNUSED Packet4f 
psin< Packet4f > (const Packet4f &_x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
psqrt (const Packet &a)
template<>
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
EIGEN_UNUSED Packet4f 
psqrt< Packet4f > (const Packet4f &_x)
template<typename Scalar , typename Packet >
void pstore (Scalar *to, const Packet &from)
template<typename Packet >
void pstore1 (typename unpacket_traits< Packet >::type *to, const typename unpacket_traits< Packet >::type &a)
template<>
void pstore1< Packet2d > (double *to, const double &a)
template<>
void pstore1< Packet4f > (float *to, const float &a)
template<>
void pstore< double > (double *to, const Packet2d &from)
template<>
void pstore< float > (float *to, const Packet4f &from)
template<>
void pstore< int > (int *to, const Packet4i &from)
template<>
void pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
void pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<typename Scalar , typename Packet , int LoadMode>
void pstoret (Scalar *to, const Packet &from)
template<typename Scalar , typename Packet >
void pstoreu (Scalar *to, const Packet &from)
template<>
void pstoreu< double > (double *to, const Packet2d &from)
template<>
void pstoreu< float > (float *to, const Packet4f &from)
template<>
void pstoreu< int > (int *to, const Packet4i &from)
template<>
void pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
template<>
void pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
template<typename Packet >
Packet psub (const Packet &a, const Packet &b)
template<>
Packet1cd psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d psub< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f psub< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i psub< Packet4i > (const Packet4i &a, const Packet4i &b)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 
ptan (const Packet &a)
void punpackp (Packet4f *vecs)
template<typename Packet >
Packet pxor (const Packet &a, const Packet &b)
template<>
Packet1cd pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
template<>
Packet2cf pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
template<>
Packet2d pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
template<>
Packet4f pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
template<>
Packet4i pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
void queryCacheSizes (int &l1, int &l2, int &l3)
int queryL1CacheSize ()
int queryTopLevelCacheSize ()
template<typename MatrixType , typename RealScalar , typename Index >
void real_2x2_jacobi_svd (const MatrixType &matrix, Index p, Index q, JacobiRotation< RealScalar > *j_left, JacobiRotation< RealScalar > *j_right)
template<typename Scalar >
add_const_on_value_type
< EIGEN_MATHFUNC_RETVAL(real_ref,
Scalar) >::type 
real_ref (const Scalar &x)
template<typename InputIterator , typename SparseMatrixType >
void set_from_triplets (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, int Options=0)
void setNbThreads (int v)
template<typename T >
void smart_copy (const T *start, const T *end, T *target)
template<typename SparseLhsType , typename DenseRhsType , typename DenseResType , typename AlphaType >
void sparse_time_dense_product (const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
template<typename ExpressionType , typename Scalar >
void stable_norm_kernel (const ExpressionType &bl, Scalar &ssq, Scalar &scale, Scalar &invScale)
void throw_std_bad_alloc ()
template<typename MatrixType , typename CoeffVectorType >
void tridiagonalization_inplace (MatrixType &matA, CoeffVectorType &hCoeffs)
template<typename MatrixType , typename DiagonalType , typename SubDiagonalType >
void tridiagonalization_inplace (MatrixType &mat, DiagonalType &diag, SubDiagonalType &subdiag, bool extractQ)
 Performs a full tridiagonalization in place.

Variables

bool IsComplex
const Scalar & y

Detailed Description

This is defined in the Jacobi module.

 #include <Eigen/Jacobi> 

Applies the clock wise 2D rotation j to the set of 2D vectors of cordinates x and y: $ \left ( \begin{array}{cc} x \\ y \end{array} \right ) = J \left ( \begin{array}{cc} x \\ y \end{array} \right ) $

See also:
MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Typedef Documentation

typedef __vector unsigned char Packet16uc
typedef __m128d Packet2d
typedef __vector __bool int Packet4bi
typedef __m128 Packet4f
typedef __m128i Packet4i
typedef uint32x4_t Packet4ui
typedef __vector short int Packet8i

Enumeration Type Documentation

anonymous enum
Enumerator:
floor_log2_terminate 
floor_log2_move_up 
floor_log2_move_down 
floor_log2_bogus 
anonymous enum
Enumerator:
SDP_IsDiagonal 
SDP_IsSparseRowMajor 
SDP_IsSparseColMajor 
anonymous enum
Enumerator:
PreconditionIfMoreColsThanRows 
PreconditionIfMoreRowsThanCols 
Enumerator:
PermPermProduct 

Function Documentation

void Eigen::internal::aligned_delete ( T *  ptr,
size_t  size 
) [inline]

References aligned_free().

void aligned_free ( void *  ptr) [inline]
void * aligned_malloc ( size_t  size) [inline]
T* Eigen::internal::aligned_new ( size_t  size) [inline]
void* Eigen::internal::aligned_realloc ( void *  ptr,
size_t  new_size,
size_t  old_size 
) [inline]
T Eigen::internal::amd_flip ( const T &  i) [inline]
void Eigen::internal::amd_mark ( const T0 *  w,
const T1 &  j 
) [inline]

References amd_flip().

bool Eigen::internal::amd_marked ( const T0 *  w,
const T1 &  j 
) [inline]
T Eigen::internal::amd_unflip ( const T &  i) [inline]

References amd_flip().

void Eigen::internal::apply_block_householder_on_the_left ( MatrixType &  mat,
const VectorsType &  vectors,
const CoeffsType &  hCoeffs 
)
void apply_rotation_in_the_plane ( VectorX &  _x,
VectorY &  _y,
const JacobiRotation< OtherScalar > &  j 
)
SluMatrix Eigen::internal::asSluMatrix ( MatrixType &  mat)
bool Eigen::internal::bicgstab ( const MatrixType &  mat,
const Rhs &  rhs,
Dest &  x,
const Preconditioner &  precond,
int iters,
typename Dest::RealScalar &  tol_error 
)
const Derived::Scalar Eigen::internal::bruteforce_det3_helper ( const MatrixBase< Derived > &  matrix,
int  a,
int  b,
int  c 
) [inline]
const Derived::Scalar Eigen::internal::bruteforce_det4_helper ( const MatrixBase< Derived > &  matrix,
int  j,
int  k,
int  m,
int  n 
)
NewType Eigen::internal::cast ( const OldType &  x) [inline]

References throw_std_bad_alloc().

void Eigen::internal::cholmod_configure_matrix ( CholmodType &  mat)
MatrixType::Scalar Eigen::internal::cofactor_3x3 ( const MatrixType &  m) [inline]
MatrixType::Scalar Eigen::internal::cofactor_4x4 ( const MatrixType &  matrix) [inline]

References general_det3_helper().

void Eigen::internal::compute_inverse_size2_helper ( const MatrixType &  matrix,
const typename ResultType::Scalar &  invdet,
ResultType &  result 
) [inline]
void Eigen::internal::compute_inverse_size3_helper ( const MatrixType &  matrix,
const typename ResultType::Scalar &  invdet,
const Matrix< typename ResultType::Scalar, 3, 1 > &  cofactors_col0,
ResultType &  result 
) [inline]
void Eigen::internal::computeProductBlockingSizes ( std::ptrdiff_t &  k,
std::ptrdiff_t &  m,
std::ptrdiff_t &  n 
)

Computes the blocking parameters for a m x k times k x n matrix product.

Parameters:
[in,out]kInput: the third dimension of the product. Output: the blocking size along the same dimension.
[in,out]mInput: the number of rows of the left hand side. Output: the blocking size along the same dimension.
[in,out]nInput: the number of columns of the right hand side. Output: the blocking size along the same dimension.

Given a m x k times k x n matrix product of scalar types LhsScalar and RhsScalar, this function computes the blocking size parameters along the respective dimensions for matrix products and related algorithms. The blocking sizes depends on various parameters:

  • the L1 and L2 cache sizes,
  • the register level blocking sizes defined by gebp_traits,
  • the number of scalars that fit into a packet (when vectorization is enabled).
See also:
setCpuCacheSizes

References EIGEN_UNUSED_VARIABLE, Eigen::GetAction, and manage_caching_sizes().

void Eigen::internal::computeProductBlockingSizes ( std::ptrdiff_t &  k,
std::ptrdiff_t &  m,
std::ptrdiff_t &  n 
) [inline]
void Eigen::internal::conditional_aligned_delete ( T *  ptr,
size_t  size 
) [inline]
void Eigen::internal::conditional_aligned_delete_auto ( T *  ptr,
size_t  size 
) [inline]
void Eigen::internal::conditional_aligned_free ( void *  ptr) [inline]

References aligned_free().

void Eigen::internal::conditional_aligned_free< false > ( void *  ptr) [inline]
void* Eigen::internal::conditional_aligned_malloc ( size_t  size) [inline]

References aligned_malloc().

void* Eigen::internal::conditional_aligned_malloc< false > ( size_t  size) [inline]
T* Eigen::internal::conditional_aligned_new ( size_t  size) [inline]
T* Eigen::internal::conditional_aligned_new_auto ( size_t  size) [inline]
void* Eigen::internal::conditional_aligned_realloc ( void *  ptr,
size_t  new_size,
size_t  old_size 
) [inline]

References aligned_realloc().

void* Eigen::internal::conditional_aligned_realloc< false > ( void *  ptr,
size_t  new_size,
size_t   
) [inline]
T* Eigen::internal::conditional_aligned_realloc_new ( T *  pts,
size_t  new_size,
size_t  old_size 
) [inline]
T* Eigen::internal::conditional_aligned_realloc_new_auto ( T *  pts,
size_t  new_size,
size_t  old_size 
) [inline]
EIGEN_DONT_INLINE void Eigen::internal::conjugate_gradient ( const MatrixType &  mat,
const Rhs &  rhs,
Dest &  x,
const Preconditioner &  precond,
int iters,
typename Dest::RealScalar &  tol_error 
)
T* Eigen::internal::const_cast_ptr ( const T *  ptr)
T* Eigen::internal::construct_elements_of_array ( T *  ptr,
size_t  size 
) [inline]
Index Eigen::internal::cs_tdfs ( Index  j,
Index  k,
Index *  head,
const Index *  next,
Index *  post,
Index *  stack 
)

References p.

void Eigen::internal::destruct_elements_of_array ( T *  ptr,
size_t  size 
) [inline]
Eigen::internal::EIGEN_MATHFUNC_RETVAL ( real  ,
Scalar   
) const [inline]

References EIGEN_MATHFUNC_IMPL, and real().

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( imag  ,
Scalar   
) const [inline]

References EIGEN_MATHFUNC_IMPL, and imag().

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( real_ref  ,
Scalar   
) [inline]

References EIGEN_MATHFUNC_IMPL, and real_ref().

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( imag_ref  ,
Scalar   
) [inline]

References EIGEN_MATHFUNC_IMPL, and imag_ref().

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( conj  ,
Scalar   
) const [inline]

References conj(), and EIGEN_MATHFUNC_IMPL.

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( abs  ,
Scalar   
) const [inline]

References abs(), and EIGEN_MATHFUNC_IMPL.

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( abs2  ,
Scalar   
) const [inline]

References abs2(), and EIGEN_MATHFUNC_IMPL.

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( norm1  ,
Scalar   
) const [inline]

References EIGEN_MATHFUNC_IMPL.

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( hypot  ,
Scalar   
) const [inline]
Eigen::internal::EIGEN_MATHFUNC_RETVAL ( sqrt  ,
Scalar   
) const [inline]

References EIGEN_MATHFUNC_IMPL, and sqrt().

Eigen::internal::EIGEN_MATHFUNC_RETVAL ( atan2  ,
Scalar   
) const [inline]
Eigen::internal::EIGEN_MATHFUNC_RETVAL ( pow  ,
Scalar   
) const [inline]
EIGEN_MATHFUNC_RETVAL ( random  ,
Scalar   
) const [inline]
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( squaredNorm  ,
Size *NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( norm  ,
(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( stableNorm  ,
(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( blueNorm  ,
(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( hypotNorm  ,
(Size-1)*functor_traits< scalar_hypot_op< Scalar > >::Cost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( sum  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( mean  ,
(Size-1)*NumTraits< Scalar >::AddCost+NumTraits< Scalar >::MulCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( minCoeff  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( maxCoeff  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( all  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( any  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( count  ,
(Size-1)*NumTraits< Scalar >::AddCost   
)
Eigen::internal::EIGEN_MEMBER_FUNCTOR ( prod  ,
(Size-1)*NumTraits< Scalar >::MulCost   
)
void Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data,
int  pastix_comm,
int  n,
int ptr,
int idx,
float *  vals,
int perm,
int invp,
float *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
void Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data,
int  pastix_comm,
int  n,
int ptr,
int idx,
double *  vals,
int perm,
int invp,
double *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
void Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data,
int  pastix_comm,
int  n,
int ptr,
int idx,
std::complex< float > *  vals,
int perm,
int invp,
std::complex< float > *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
void Eigen::internal::eigen_pastix ( pastix_data_t **  pastix_data,
int  pastix_comm,
int  n,
int ptr,
int idx,
std::complex< double > *  vals,
int perm,
int invp,
std::complex< double > *  x,
int  nbrhs,
int iparm,
double *  dparm 
)
void Eigen::internal::EigenSymmetrizeMatrixGraph ( const MatrixType &  In,
MatrixType &  Out,
MatrixType &  StrMatTrans,
bool hasTranspose 
)
void Eigen::internal::EigenToCNumbering ( MatrixType &  mat)
void Eigen::internal::EigenToFortranNumbering ( MatrixType &  mat)
const T::Scalar* Eigen::internal::extract_data ( const T &  m)
void Eigen::internal::gebp_madd ( const CJ &  cj,
A &  a,
B &  b,
C &  c,
T &  t 
) [inline]
const Derived::Scalar Eigen::internal::general_det3_helper ( const MatrixBase< Derived > &  matrix,
int  i1,
int  i2,
int  i3,
int  j1,
int  j2,
int  j3 
) [inline]

Referenced by cofactor_4x4().

void* Eigen::internal::generic_aligned_realloc ( void *  ptr,
size_t  size,
size_t  old_size 
) [inline]

References aligned_free(), and aligned_malloc().

Referenced by aligned_realloc().

void Eigen::internal::handmade_aligned_free ( void *  ptr) [inline]

Referenced by aligned_free().

void* Eigen::internal::handmade_aligned_malloc ( size_t  size) [inline]
void* Eigen::internal::handmade_aligned_realloc ( void *  ptr,
size_t  size,
size_t  = 0 
) [inline]

References handmade_aligned_malloc().

Referenced by aligned_realloc().

void Eigen::internal::householder_qr_inplace_blocked ( MatrixQR &  mat,
HCoeffs &  hCoeffs,
typename MatrixQR::Index  maxBlockSize = 32,
typename MatrixQR::Scalar *  tempData = 0 
)
void Eigen::internal::householder_qr_inplace_unblocked ( MatrixQR &  mat,
HCoeffs &  hCoeffs,
typename MatrixQR::Scalar *  tempData = 0 
)
add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(imag_ref, Scalar) >::type Eigen::internal::imag_ref ( const Scalar &  x) [inline]

Referenced by EIGEN_MATHFUNC_RETVAL().

bool Eigen::internal::isApprox ( const Scalar &  x,
const Scalar &  y,
typename NumTraits< Scalar >::Real  precision = NumTraits<Scalar>::dummy_precision() 
) [inline]
bool Eigen::internal::isApproxOrLessThan ( const Scalar &  x,
const Scalar &  y,
typename NumTraits< Scalar >::Real  precision = NumTraits<Scalar>::dummy_precision() 
) [inline]
bool Eigen::internal::isfinite ( const T &  x)
bool Eigen::internal::isMuchSmallerThan ( const Scalar &  x,
const OtherScalar &  y,
typename NumTraits< Scalar >::Real  precision = NumTraits<Scalar>::dummy_precision() 
) [inline]
void Eigen::internal::make_block_householder_triangular_factor ( TriangularFactorType &  triFactor,
const VectorsType &  vectors,
const CoeffsType &  hCoeffs 
)
void Eigen::internal::manage_caching_sizes ( Action  action,
std::ptrdiff_t *  l1 = 0,
std::ptrdiff_t *  l2 = 0 
) [inline]
std::ptrdiff_t Eigen::internal::manage_caching_sizes_helper ( std::ptrdiff_t  a,
std::ptrdiff_t  b 
) [inline]

Referenced by manage_caching_sizes().

void Eigen::internal::manage_multi_threading ( Action  action,
int v 
) [inline]
MappedSparseMatrix<Scalar,Flags,Index> Eigen::internal::map_superlu ( SluMatrix &  sluMat)
void Eigen::internal::minimum_degree_ordering ( SparseMatrix< Scalar, ColMajor, Index > &  C,
PermutationMatrix< Dynamic, Dynamic, Index > &  perm 
)
Returns:
the max number of threads reserved for Eigen
See also:
setNbThreads

References Eigen::GetAction, and manage_multi_threading().

Referenced by parallelize_gemm().

Packet Eigen::internal::pabs ( const Packet &  a) [inline]

References abs().

Packet4f pabs ( const Packet4f &  a) [inline]
Packet4i pabs ( const Packet4i &  a) [inline]
Packet2d Eigen::internal::pabs ( const Packet2d &  a) [inline]

References acos().

Packet Eigen::internal::padd ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::padd< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf padd< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::padd< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f padd< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i padd< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
void Eigen::internal::palign ( PacketType &  first,
const PacketType &  second 
) [inline]
Packet Eigen::internal::pand ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::pand< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf pand< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::pand< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pand< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pand< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
Packet Eigen::internal::pandnot ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::pandnot< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf pandnot< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::pandnot< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pandnot< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pandnot< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
void Eigen::internal::parallelize_gemm ( const Functor &  func,
Index  rows,
Index  cols,
bool  transpose 
)
void Eigen::internal::partial_lu_inplace ( MatrixType &  lu,
TranspositionType &  row_transpositions,
typename TranspositionType::Index &  nb_transpositions 
)

References asin().

Packet2cf pconj ( const Packet2cf &  a) [inline]
Packet Eigen::internal::pconj ( const Packet &  a) [inline]

References conj().

Packet1cd Eigen::internal::pconj ( const Packet1cd &  a) [inline]

References cos().

Packet Eigen::internal::pcplxflip ( const Packet &  a) [inline]

References imag(), and real().

Packet2cf Eigen::internal::pcplxflip ( const Packet2cf &  x) [inline]

References vec4f_swizzle1.

Packet1cd Eigen::internal::pcplxflip ( const Packet1cd &  x) [inline]

References preverse().

Packet2cf pcplxflip< Packet2cf > ( const Packet2cf &  x) [inline]
Packet Eigen::internal::pdiv ( const Packet &  a,
const Packet &  b 
) [inline]

Referenced by pdiv< Packet2cf >().

Packet1cd Eigen::internal::pdiv< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]

References pmul().

Packet2cf pdiv< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]

References pdiv(), and pmul().

Packet2d Eigen::internal::pdiv< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pdiv< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pdiv< Packet4i > ( const Packet4i &  ,
const Packet4i &   
) [inline]

References pset1< Packet4i >().

void permute_symm_to_fullsymm ( const MatrixType &  mat,
SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::Index > &  _dest,
const typename MatrixType::Index *  perm = 0 
)
void Eigen::internal::permute_symm_to_symm ( const MatrixType &  mat,
SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::Index > &  _dest,
const typename MatrixType::Index *  perm = 0 
)
void Eigen::internal::permute_symm_to_symm ( const MatrixType &  mat,
SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::Index > &  _dest,
const typename MatrixType::Index *  perm 
)

References exp().

unpacket_traits<Packet>::type Eigen::internal::pfirst ( const Packet &  a) [inline]
std::complex<double> Eigen::internal::pfirst< Packet1cd > ( const Packet1cd &  a) [inline]

References EIGEN_ALIGN16.

std::complex< float > pfirst< Packet2cf > ( const Packet2cf &  a) [inline]

References EIGEN_ALIGN16, and pstore().

double Eigen::internal::pfirst< Packet2d > ( const Packet2d &  a) [inline]
float pfirst< Packet4f > ( const Packet4f &  a) [inline]

References EIGEN_ALIGN16.

int pfirst< Packet4i > ( const Packet4i &  a) [inline]

References EIGEN_ALIGN16.

Packet Eigen::internal::pload ( const typename unpacket_traits< Packet >::type *  from) [inline]
Packet1cd Eigen::internal::pload< Packet1cd > ( const std::complex< double > *  from) [inline]

References pload< Packet2d >().

Packet2cf pload< Packet2cf > ( const std::complex< float > *  from) [inline]

References pload< Packet4f >().

Packet2d Eigen::internal::pload< Packet2d > ( const double *  from) [inline]

Referenced by pload< Packet1cd >().

Packet4f pload< Packet4f > ( const float *  from) [inline]
Packet4i pload< Packet4i > ( const int from) [inline]

Referenced by ploaddup< Packet4i >().

Packet Eigen::internal::ploaddup ( const typename unpacket_traits< Packet >::type *  from) [inline]
Packet1cd Eigen::internal::ploaddup< Packet1cd > ( const std::complex< double > *  from) [inline]

References pset1< Packet1cd >().

Packet2cf ploaddup< Packet2cf > ( const std::complex< float > *  from) [inline]

References pset1< Packet2cf >().

Packet2d Eigen::internal::ploaddup< Packet2d > ( const double *  from) [inline]

References pset1< Packet2d >().

Packet4f ploaddup< Packet4f > ( const float *  from) [inline]
Packet4i ploaddup< Packet4i > ( const int from) [inline]
Packet Eigen::internal::ploadt ( const typename unpacket_traits< Packet >::type *  from) [inline]

References Eigen::Aligned.

Packet Eigen::internal::ploadu ( const typename unpacket_traits< Packet >::type *  from) [inline]
Packet1cd Eigen::internal::ploadu< Packet1cd > ( const std::complex< double > *  from) [inline]

References ploadu< Packet2d >().

Referenced by pset1< Packet1cd >().

Packet2cf ploadu< Packet2cf > ( const std::complex< float > *  from) [inline]

References ploadu< Packet4f >().

Packet2d Eigen::internal::ploadu< Packet2d > ( const double *  from) [inline]

Referenced by ploadu< Packet1cd >().

Packet4f ploadu< Packet4f > ( const float *  from) [inline]
Packet4i ploadu< Packet4i > ( const int from) [inline]

Referenced by ploaddup< Packet4i >().

References log().

packet_traits<Scalar>::type Eigen::internal::plset ( const Scalar &  a) [inline]
Packet2d Eigen::internal::plset< double > ( const double &  a) [inline]

References pset1< Packet2d >().

Packet4f plset< float > ( const float &  a) [inline]

References pset1< Packet4f >().

Packet4i plset< int > ( const int a) [inline]

References pset1< Packet4i >().

Packet4f pmadd ( const Packet4f &  a,
const Packet4f &  b,
const Packet4f &  c 
) [inline]
Packet4i pmadd ( const Packet4i &  a,
const Packet4i &  b,
const Packet4i &  c 
) [inline]

References padd(), and pmul().

Packet Eigen::internal::pmadd ( const Packet &  a,
const Packet &  b,
const Packet &  c 
) [inline]

References padd(), and pmul().

Packet Eigen::internal::pmax ( const Packet &  a,
const Packet &  b 
) [inline]
Packet2d Eigen::internal::pmax< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pmax< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pmax< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
Packet Eigen::internal::pmin ( const Packet &  a,
const Packet &  b 
) [inline]

Referenced by pexp< Packet4f >().

Packet2d Eigen::internal::pmin< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pmin< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pmin< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
Packet Eigen::internal::pmul ( const Packet &  a,
const Packet &  b 
) [inline]
std::complex<float> Eigen::internal::pmul ( const std::complex< float > &  a,
const std::complex< float > &  b 
) [inline]

References imag(), and real().

std::complex<double> Eigen::internal::pmul ( const std::complex< double > &  a,
const std::complex< double > &  b 
) [inline]

References imag(), and real().

Packet1cd Eigen::internal::pmul< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]

References vec2d_swizzle1.

Packet2cf pmul< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::pmul< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pmul< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pmul< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
Packet2cf pnegate ( const Packet2cf &  a) [inline]

Referenced by pnegate().

Packet Eigen::internal::pnegate ( const Packet &  a) [inline]
Packet2d Eigen::internal::pnegate ( const Packet2d &  a) [inline]
Packet4f pnegate ( const Packet4f &  a) [inline]

References psub< Packet4f >().

Packet4i pnegate ( const Packet4i &  a) [inline]

References psub< Packet4i >().

Packet1cd Eigen::internal::pnegate ( const Packet1cd &  a) [inline]

References pnegate().

Packet Eigen::internal::por ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::por< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf por< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::por< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f por< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i por< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
unpacket_traits<Packet>::type Eigen::internal::predux ( const Packet &  a) [inline]
std::complex<double> Eigen::internal::predux< Packet1cd > ( const Packet1cd &  a) [inline]

References pfirst().

std::complex< float > predux< Packet2cf > ( const Packet2cf &  a) [inline]

References padd(), and pfirst().

double Eigen::internal::predux< Packet2d > ( const Packet2d &  a) [inline]

References pfirst().

float predux< Packet4f > ( const Packet4f &  a) [inline]

References pfirst().

int predux< Packet4i > ( const Packet4i &  a) [inline]

References pfirst().

unpacket_traits<Packet>::type Eigen::internal::predux_max ( const Packet &  a) [inline]
double Eigen::internal::predux_max< Packet2d > ( const Packet2d &  a) [inline]

References pfirst().

float predux_max< Packet4f > ( const Packet4f &  a) [inline]

References pfirst().

int predux_max< Packet4i > ( const Packet4i &  a) [inline]

References pfirst().

unpacket_traits<Packet>::type Eigen::internal::predux_min ( const Packet &  a) [inline]
double Eigen::internal::predux_min< Packet2d > ( const Packet2d &  a) [inline]

References pfirst().

float predux_min< Packet4f > ( const Packet4f &  a) [inline]

References pfirst().

int predux_min< Packet4i > ( const Packet4i &  a) [inline]

References pfirst().

unpacket_traits<Packet>::type Eigen::internal::predux_mul ( const Packet &  a) [inline]
std::complex<double> Eigen::internal::predux_mul< Packet1cd > ( const Packet1cd &  a) [inline]

References pfirst().

std::complex< float > predux_mul< Packet2cf > ( const Packet2cf &  a) [inline]

References pfirst(), and pmul().

double Eigen::internal::predux_mul< Packet2d > ( const Packet2d &  a) [inline]

References pfirst().

float predux_mul< Packet4f > ( const Packet4f &  a) [inline]

References pfirst(), and pmul().

int predux_mul< Packet4i > ( const Packet4i &  a) [inline]

References EIGEN_ALIGN16, and pstore().

Packet Eigen::internal::preduxp ( const Packet *  vecs) [inline]
Packet1cd Eigen::internal::preduxp< Packet1cd > ( const Packet1cd *  vecs) [inline]
Packet2cf preduxp< Packet2cf > ( const Packet2cf *  vecs) [inline]

References padd().

Packet2d Eigen::internal::preduxp< Packet2d > ( const Packet2d *  vecs) [inline]
Packet4f preduxp< Packet4f > ( const Packet4f *  vecs) [inline]
Packet4i preduxp< Packet4i > ( const Packet4i *  vecs) [inline]
void Eigen::internal::prefetch ( const Scalar *  addr) [inline]
void Eigen::internal::prefetch< double > ( const double *  addr) [inline]
void prefetch< float > ( const float *  addr) [inline]

References DST_CHAN, and DST_CTRL.

void prefetch< int > ( const int addr) [inline]

References DST_CHAN, and DST_CTRL.

void Eigen::internal::prefetch< std::complex< double > > ( const std::complex< double > *  addr) [inline]
void prefetch< std::complex< float > > ( const std::complex< float > *  addr) [inline]

References DST_CHAN, and DST_CTRL.

Packet2cf preverse ( const Packet2cf &  a) [inline]
Packet Eigen::internal::preverse ( const Packet &  a) [inline]
Packet1cd Eigen::internal::preverse ( const Packet1cd &  a) [inline]
Packet2d Eigen::internal::preverse ( const Packet2d &  a) [inline]
Packet4f preverse ( const Packet4f &  a) [inline]
Packet4i preverse ( const Packet4i &  a) [inline]
std::ostream & print_matrix ( std::ostream &  s,
const Derived &  _m,
const IOFormat &  fmt 
)
Packet Eigen::internal::pset1 ( const typename unpacket_traits< Packet >::type &  a) [inline]
Packet1cd Eigen::internal::pset1< Packet1cd > ( const std::complex< double > &  from) [inline]

References ploadu< Packet1cd >().

Referenced by ploaddup< Packet1cd >().

Packet2cf pset1< Packet2cf > ( const std::complex< float > &  from) [inline]
Packet2d Eigen::internal::pset1< Packet2d > ( const double &  from) [inline]
Packet4f pset1< Packet4f > ( const float &  from) [inline]

References EIGEN_ALIGN16.

Referenced by plset< float >(), and psqrt< Packet4f >().

Packet4i pset1< Packet4i > ( const int from) [inline]

References EIGEN_ALIGN16.

Referenced by pdiv< Packet4i >(), and plset< int >().

References sin().

References sqrt().

References pmul(), pset1< Packet4f >(), and psub().

void Eigen::internal::pstore ( Scalar *  to,
const Packet &  from 
) [inline]
void Eigen::internal::pstore1 ( typename unpacket_traits< Packet >::type *  to,
const typename unpacket_traits< Packet >::type &  a 
) [inline]

References pstore().

void Eigen::internal::pstore1< Packet2d > ( double *  to,
const double &  a 
) [inline]

References pstore(), and vec2d_swizzle1.

void Eigen::internal::pstore1< Packet4f > ( float *  to,
const float &  a 
) [inline]

References pstore(), and vec4f_swizzle1.

void Eigen::internal::pstore< double > ( double *  to,
const Packet2d &  from 
) [inline]
void pstore< float > ( float *  to,
const Packet4f &  from 
) [inline]
void pstore< int > ( int to,
const Packet4i &  from 
) [inline]
void Eigen::internal::pstore< std::complex< double > > ( std::complex< double > *  to,
const Packet1cd &  from 
) [inline]

References pstore().

void pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf &  from 
) [inline]

References pstore().

void Eigen::internal::pstoret ( Scalar *  to,
const Packet &  from 
) [inline]

References Eigen::Aligned, pstore(), and pstoreu().

void Eigen::internal::pstoreu ( Scalar *  to,
const Packet &  from 
) [inline]
void Eigen::internal::pstoreu< double > ( double *  to,
const Packet2d &  from 
) [inline]
void pstoreu< float > ( float *  to,
const Packet4f &  from 
) [inline]
void pstoreu< int > ( int to,
const Packet4i &  from 
) [inline]
void Eigen::internal::pstoreu< std::complex< double > > ( std::complex< double > *  to,
const Packet1cd &  from 
) [inline]

References pstoreu().

void pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf &  from 
) [inline]

References pstoreu().

Packet Eigen::internal::psub ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::psub< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf psub< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::psub< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f psub< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]

Referenced by pnegate().

Packet4i psub< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]

Referenced by pnegate().

References tan().

void Eigen::internal::punpackp ( Packet4f *  vecs) [inline]
Packet Eigen::internal::pxor ( const Packet &  a,
const Packet &  b 
) [inline]
Packet1cd Eigen::internal::pxor< Packet1cd > ( const Packet1cd &  a,
const Packet1cd &  b 
) [inline]
Packet2cf pxor< Packet2cf > ( const Packet2cf &  a,
const Packet2cf &  b 
) [inline]
Packet2d Eigen::internal::pxor< Packet2d > ( const Packet2d &  a,
const Packet2d &  b 
) [inline]
Packet4f pxor< Packet4f > ( const Packet4f &  a,
const Packet4f &  b 
) [inline]
Packet4i pxor< Packet4i > ( const Packet4i &  a,
const Packet4i &  b 
) [inline]
void Eigen::internal::queryCacheSizes ( int l1,
int l2,
int l3 
) [inline]

References queryCacheSizes().

Referenced by manage_caching_sizes().

References queryCacheSizes().

Referenced by manage_caching_sizes().

void Eigen::internal::real_2x2_jacobi_svd ( const MatrixType &  matrix,
Index  p,
Index  q,
JacobiRotation< RealScalar > *  j_left,
JacobiRotation< RealScalar > *  j_right 
)
add_const_on_value_type< EIGEN_MATHFUNC_RETVAL(real_ref, Scalar) >::type Eigen::internal::real_ref ( const Scalar &  x) [inline]
void Eigen::internal::set_from_triplets ( const InputIterator &  begin,
const InputIterator &  end,
SparseMatrixType &  mat,
int  Options = 0 
)
void Eigen::internal::setNbThreads ( int  v) [inline]

Sets the max number of threads reserved for Eigen

See also:
nbThreads

References manage_multi_threading(), and Eigen::SetAction.

void Eigen::internal::smart_copy ( const T *  start,
const T *  end,
T *  target 
)
void Eigen::internal::sparse_time_dense_product ( const SparseLhsType &  lhs,
const DenseRhsType &  rhs,
DenseResType &  res,
const AlphaType &  alpha 
) [inline]
void Eigen::internal::stable_norm_kernel ( const ExpressionType &  bl,
Scalar &  ssq,
Scalar &  scale,
Scalar &  invScale 
) [inline]

References abs2().

Referenced by MatrixBase< Derived >::stableNorm().

void tridiagonalization_inplace ( MatrixType &  matA,
CoeffVectorType &  hCoeffs 
)
void Eigen::internal::tridiagonalization_inplace ( MatrixType &  mat,
DiagonalType &  diag,
SubDiagonalType &  subdiag,
bool  extractQ 
)

Performs a full tridiagonalization in place.

Parameters:
[in,out]matOn input, the selfadjoint matrix whose tridiagonal decomposition is to be computed. Only the lower triangular part referenced. The rest is left unchanged. On output, the orthogonal matrix Q in the decomposition if extractQ is true.
[out]diagThe diagonal of the tridiagonal matrix T in the decomposition.
[out]subdiagThe subdiagonal of the tridiagonal matrix T in the decomposition.
[in]extractQIf true, the orthogonal matrix Q in the decomposition is computed and stored in mat.

Computes the tridiagonal decomposition of the selfadjoint matrix mat in place such that $ mat = Q T Q^* $ where $ Q $ is unitary and $ T $ a real symmetric tridiagonal matrix.

The tridiagonal matrix T is passed to the output parameters diag and subdiag. If extractQ is true, then the orthogonal matrix Q is passed to mat. Otherwise the lower part of the matrix mat is destroyed.

The vectors diag and subdiag are not resized. The function assumes that they are already of the correct size. The length of the vector diag should equal the number of rows in mat, and the length of the vector subdiag should be one left.

This implementation contains an optimized path for 3-by-3 matrices which is especially useful for plane fitting.

Note:
Currently, it requires two temporary vectors to hold the intermediate Householder coefficients, and to reconstruct the matrix Q from the Householder reflectors.

Example (this uses the same matrix as the example in Tridiagonalization::Tridiagonalization(const MatrixType&)):

MatrixXd X = MatrixXd::Random(5,5);
MatrixXd A = X + X.transpose();
cout << "Here is a random symmetric 5x5 matrix:" << endl << A << endl << endl;

VectorXd diag(5);
VectorXd subdiag(4);
internal::tridiagonalization_inplace(A, diag, subdiag, true);
cout << "The orthogonal matrix Q is:" << endl << A << endl;
cout << "The diagonal of the tridiagonal matrix T is:" << endl << diag << endl;
cout << "The subdiagonal of the tridiagonal matrix T is:" << endl << subdiag << endl;

Output:

Here is a random symmetric 5x5 matrix:
  1.36 -0.816  0.521   1.43 -0.144
-0.816 -0.659  0.794 -0.173 -0.406
 0.521  0.794 -0.541  0.461  0.179
  1.43 -0.173  0.461  -1.43  0.822
-0.144 -0.406  0.179  0.822  -1.37

The orthogonal matrix Q is:
       1        0        0        0        0
       0   -0.471    0.127   -0.671   -0.558
       0    0.301   -0.195    0.437   -0.825
       0    0.825   0.0459   -0.563 -0.00872
       0  -0.0832   -0.971   -0.202   0.0922
The diagonal of the tridiagonal matrix T is:
1.36
-1.2
-1.28
-1.69
0.164
The subdiagonal of the tridiagonal matrix T is:
1.73
-0.966
0.214
0.345
See also:
class Tridiagonalization

Variable Documentation

const Scalar& y