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
EIGEN_ALWAYS_INLINE void Eigen::internal::check_rows_cols_for_overflow ( Index  rows,
Index  cols 
)
EIGEN_ALWAYS_INLINE void Eigen::internal::check_size_for_overflow ( size_t  size)

References throw_std_bad_alloc().

void Eigen::internal::check_that_malloc_is_allowed ( )
inline
void Eigen::internal::cholmod_configure_matrix ( CholmodType &  mat)

References eigen_assert.

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
bool Eigen::internal::copy_bool ( bool  b)
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 
)

References eigen_assert.

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 
)
int Eigen::internal::nbThreads ( )
inline
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
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pacos ( const Packet &  a)

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 
)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pasin ( const Packet &  a)

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
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pcos ( const Packet &  a)

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
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 
)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pexp ( const Packet &  a)

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
Packet2cf pload< Packet2cf > ( const std::complex< float > *  from)
inline
Packet2d Eigen::internal::pload< Packet2d > ( const double *  from)
inline

References EIGEN_DEBUG_ALIGNED_LOAD.

Referenced by pload< Packet1cd >().

Packet4f pload< Packet4f > ( const float *  from)
inline
Packet4i pload< Packet4i > ( const int from)
inline
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
Packet2cf ploadu< Packet2cf > ( const std::complex< float > *  from)
inline
Packet2d Eigen::internal::ploadu< Packet2d > ( const double *  from)
inline
Packet4f ploadu< Packet4f > ( const float *  from)
inline
Packet4i ploadu< Packet4i > ( const int from)
inline
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plog ( const Packet &  a)

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

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psin ( const Packet &  a)

References sin().

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::psqrt ( const Packet &  a)

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
void pstore< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf &  from 
)
inline
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
void pstoreu< std::complex< float > > ( std::complex< float > *  to,
const Packet2cf &  from 
)
inline
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().

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ptan ( const Packet &  a)

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
int Eigen::internal::queryL1CacheSize ( )
inline

References queryCacheSizes().

Referenced by manage_caching_sizes().

int Eigen::internal::queryTopLevelCacheSize ( )
inline

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 Eigen::internal::throw_std_bad_alloc ( )
inline
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

References eigen_assert.


Variable Documentation

bool IsComplex
const Scalar& y