Enumerations
enum	{ SDP_IsDiagonal, SDP_IsSparseRowMajor, SDP_IsSparseColMajor }
enum	{ PreconditionIfMoreColsThanRows, PreconditionIfMoreRowsThanCols }
enum	{ floor_log2_terminate, floor_log2_move_up, floor_log2_move_down, floor_log2_bogus }
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 >
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 >
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)
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)
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<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<int Offset, typename PacketType >
void	palign (PacketType &first, const PacketType &second)
template<typename Packet >
Packet	pand (const Packet &a, const Packet &b)
template<typename Packet >
Packet	pandnot (const Packet &a, const Packet &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<typename Packet >
Packet	pconj (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcos (const Packet &a)
template<typename Packet >
Packet	pcplxflip (const Packet &a)
template<typename Packet >
Packet	pdiv (const Packet &a, const Packet &b)
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<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexp (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type	pfirst (const Packet &a)
template<typename Packet >
Packet	pload (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
Packet	ploaddup (const typename unpacket_traits< Packet >::type *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<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog (const Packet &a)
template<typename Scalar >
packet_traits< Scalar >::type	plset (const Scalar &a)
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<typename Packet >
Packet	pmin (const Packet &a, const Packet &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<typename Packet >
Packet	pnegate (const Packet &a)
template<typename Packet >
Packet	por (const Packet &a, const Packet &b)
template<typename Packet >
unpacket_traits< Packet >::type	predux (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type	predux_max (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type	predux_min (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type	predux_mul (const Packet &a)
template<typename Packet >
Packet	preduxp (const Packet *vecs)
template<typename Scalar >
void	prefetch (const Scalar *addr)
template<typename Packet >
Packet	preverse (const Packet &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<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psin (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psqrt (const Packet &a)
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<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<typename Packet >
Packet	psub (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ptan (const Packet &a)
template<typename Packet >
Packet	pxor (const Packet &a, const Packet &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 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()

Enumeration Type Documentation

anonymous enum

Enumerator:

SDP_IsDiagonal
SDP_IsSparseRowMajor
SDP_IsSparseColMajor

anonymous enum

Enumerator:

PreconditionIfMoreColsThanRows
PreconditionIfMoreRowsThanCols

anonymous enum

Enumerator:

floor_log2_terminate
floor_log2_move_up
floor_log2_move_down
floor_log2_bogus

enum PermPermProduct_t

Enumerator:

PermPermProduct

Function Documentation

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

void aligned_free ( void * ptr ) [inline]

Referenced by qFree(), and qRealloc().

void * aligned_malloc ( size_t size ) [inline]

Referenced by qMalloc(), and qRealloc().

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]`

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

T Eigen::internal::amd_unflip ( const T & i ) [inline]

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 )

void Eigen::internal::check_that_malloc_is_allowed ( ) [inline]

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]

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]	k	Input: the third dimension of the product. Output: the blocking size along the same dimension.
[in,out]	m	Input: the number of rows of the left hand side. Output: the blocking size along the same dimension.
[in,out]	n	Input: 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

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]

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

void* Eigen::internal::conditional_aligned_malloc ( size_t size ) [inline]

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]`

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
	)

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

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

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

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

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

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

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

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

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

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

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

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
	)

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]`

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

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

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]`

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]

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]`

void Eigen::internal::manage_multi_threading	(	Action	action,
		int *	v
	)		`[inline]`

MappedSparseMatrix<Scalar,Flags,Index> Eigen::internal::map_superlu ( SluMatrix & sluMat )

View a Super LU matrix as an Eigen expression

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

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

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

Packet Eigen::internal::padd	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

void Eigen::internal::palign	(	PacketType &	first,
		const PacketType &	second
	)		`[inline]`

Packet Eigen::internal::pand	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

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

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

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

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

Packet Eigen::internal::pdiv	(	const Packet &	a,
		const Packet &	b
	)		`[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 permute_symm_to_symm	(	const MatrixType &	mat,
		SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::Index > &	_dest,
		const typename MatrixType::Index *	perm = `0`
	)

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

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

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

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

Packet Eigen::internal::ploadt ( const typename unpacket_traits< Packet >::type * from ) [inline]

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

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

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

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

Packet Eigen::internal::pmax	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

Packet Eigen::internal::pmin	(	const Packet &	a,
		const Packet &	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]`

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

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

Packet Eigen::internal::por	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

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

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

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

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

Packet Eigen::internal::preduxp ( const Packet * vecs ) [inline]

void Eigen::internal::prefetch ( const Scalar * addr ) [inline]

Packet Eigen::internal::preverse ( const Packet & 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]

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

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

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]`

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

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

Packet Eigen::internal::psub	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

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

Packet Eigen::internal::pxor	(	const Packet &	a,
		const Packet &	b
	)		`[inline]`

void Eigen::internal::queryCacheSizes	(	int &	l1,
		int &	l2,
		int &	l3
	)		`[inline]`

int Eigen::internal::queryL1CacheSize ( ) [inline]

int Eigen::internal::queryTopLevelCacheSize ( ) [inline]

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

void Eigen::internal::smart_copy	(	const T *	start,
		const T *	end,
		T *	target
	)

void Eigen::internal::stable_norm_kernel	(	const ExpressionType &	bl,
		Scalar &	ssq,
		Scalar &	scale,
		Scalar &	invScale
	)		`[inline]`

void Eigen::internal::throw_std_bad_alloc ( ) [inline]

void tridiagonalization_inplace	(	MatrixType &	matA,
		CoeffVectorType &	hCoeffs
	)

void tridiagonalization_inplace	(	MatrixType &	mat,
		DiagonalType &	diag,
		SubDiagonalType &	subdiag,
		bool	extractQ
	)

Performs a full tridiagonalization in place.

Parameters:

[in,out]	mat	On 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]	diag	The diagonal of the tridiagonal matrix T in the decomposition.
[out]	subdiag	The subdiagonal of the tridiagonal matrix T in the decomposition.
[in]	extractQ	If 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

bool IsComplex

const Scalar& y

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

Function Documentation

Variable Documentation