mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-04-18 19:30:38 +08:00
Code Issues Packages Projects Releases Wiki Activity

* Refactoring of the class hierarchy: introduction of DenseDirectAccessBase, removal of extra _Base/_Options template parameters.

Browse Source 
* Introduction of strides-at-compile-time so for example the optimized code really knows when it needs to evaluate to a temporary
* StorageKind / XprKind
* Quaternion::setFromTwoVectors: use JacobiSVD instead of SVD
* ComplexSchur: support the 1x1 case
This commit is contained in:
Benoit Jacob 2010-04-16 10:13:32 -04:00
parent 1803db6e84
commit ff6a46105d
43 changed files with 269 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Eigen/Core
View File

@ -208,9 +208,6 @@ using std::size_t;
* \endcode
*/
/** The type used to identify a dense storage. */
struct Dense {};
#include "src/Core/util/Constants.h"
#include "src/Core/util/ForwardDeclarations.h"
#include "src/Core/util/Meta.h"
@ -235,6 +232,7 @@ struct Dense {};
#include "src/Core/Functors.h"
#include "src/Core/DenseBase.h"
#include "src/Core/DenseDirectAccessBase.h"
#include "src/Core/MatrixBase.h"
#include "src/Core/EigenBase.h"
#include "src/Core/Coeffs.h"

7
Eigen/src/Array/Array.h
View File

@ -28,16 +28,17 @@
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
struct ei_traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
typedef DenseStorageArray DenseStorageType;
typedef ArrayXpr XprKind;
typedef ArrayBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
};
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Array
: public DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, ArrayBase, _Options>
: public DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
public:
typedef DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Eigen::ArrayBase, _Options> Base;
typedef DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Array)
enum { Options = _Options };

4
Eigen/src/Array/ArrayWrapper.h
View File

@ -38,7 +38,7 @@ template<typename ExpressionType>
struct ei_traits<ArrayWrapper<ExpressionType> >
: public ei_traits<typename ei_cleantype<typename ExpressionType::Nested>::type >
{
typedef DenseStorageArray DenseStorageType;
typedef ArrayXpr XprKind;
};
template<typename ExpressionType>
@ -123,7 +123,7 @@ template<typename ExpressionType>
struct ei_traits<MatrixWrapper<ExpressionType> >
: public ei_traits<typename ei_cleantype<typename ExpressionType::Nested>::type >
{
typedef DenseStorageMatrix DenseStorageType;
typedef MatrixXpr XprKind;
};
template<typename ExpressionType>

8
Eigen/src/Array/Random.h
View File

@ -136,9 +136,9 @@ inline Derived& DenseBase<Derived>::setRandom()
*
* \sa MatrixBase::setRandom(), setRandom(int,int), class CwiseNullaryOp, MatrixBase::Random()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setRandom(int size)
DenseStorageBase<Derived>::setRandom(int size)
{
resize(size);
return setRandom();
@ -154,9 +154,9 @@ DenseStorageBase<Derived,_Base,_Options>::setRandom(int size)
*
* \sa MatrixBase::setRandom(), setRandom(int), class CwiseNullaryOp, MatrixBase::Random()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setRandom(int rows, int cols)
DenseStorageBase<Derived>::setRandom(int rows, int cols)
{
resize(rows, cols);
return setRandom();

7
Eigen/src/Array/Replicate.h
View File

@ -43,7 +43,7 @@ struct ei_traits<Replicate<MatrixType,RowFactor,ColFactor> >
: ei_traits<MatrixType>
{
typedef typename MatrixType::Scalar Scalar;
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
enum {
@ -53,10 +53,11 @@ struct ei_traits<Replicate<MatrixType,RowFactor,ColFactor> >
ColsAtCompileTime = ColFactor==Dynamic || int(MatrixType::ColsAtCompileTime)==Dynamic
? Dynamic
: ColFactor * MatrixType::ColsAtCompileTime,
//FIXME we don't propagate the max sizes !!!
MaxRowsAtCompileTime = RowsAtCompileTime,
MaxColsAtCompileTime = ColsAtCompileTime,
IsRowMajor = RowsAtCompileTime==1 && ColsAtCompileTime!=1 ? 1
: ColsAtCompileTime==1 && RowsAtCompileTime!=1 ? 0
IsRowMajor = MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1 ? 1
: MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1 ? 0
: (MatrixType::Flags & RowMajorBit) ? 1 : 0,
Flags = (_MatrixTypeNested::Flags & HereditaryBits & ~RowMajorBit) | (IsRowMajor ? RowMajorBit : 0),
CoeffReadCost = _MatrixTypeNested::CoeffReadCost

2
Eigen/src/Array/Reverse.h
View File

@ -46,7 +46,7 @@ struct ei_traits<Reverse<MatrixType, Direction> >
: ei_traits<MatrixType>
{
typedef typename MatrixType::Scalar Scalar;
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
enum {

2
Eigen/src/Array/Select.h
View File

@ -46,7 +46,7 @@ struct ei_traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
: ei_traits<ThenMatrixType>
{
typedef typename ei_traits<ThenMatrixType>::Scalar Scalar;
typedef Dense StorageType;
typedef Dense StorageKind;
typedef typename ConditionMatrixType::Nested ConditionMatrixNested;
typedef typename ThenMatrixType::Nested ThenMatrixNested;
typedef typename ElseMatrixType::Nested ElseMatrixNested;

2
Eigen/src/Array/VectorwiseOp.h
View File

@ -51,7 +51,7 @@ struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
: ei_traits<MatrixType>
{
typedef typename MemberOp::result_type Scalar;
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename MatrixType::Scalar InputScalar;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested;

53
Eigen/src/Core/Block.h
View File

@ -61,22 +61,36 @@ template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessSta
struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> > : ei_traits<MatrixType>
{
typedef typename ei_traits<MatrixType>::Scalar Scalar;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename ei_traits<MatrixType>::XprKind XprKind;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
enum{
RowsAtCompileTime = BlockRows,
ColsAtCompileTime = BlockCols,
MaxRowsAtCompileTime = RowsAtCompileTime == 1 ? 1
: (BlockRows==Dynamic ? int(ei_traits<MatrixType>::MaxRowsAtCompileTime) : BlockRows),
MaxColsAtCompileTime = ColsAtCompileTime == 1 ? 1
: (BlockCols==Dynamic ? int(ei_traits<MatrixType>::MaxColsAtCompileTime) : BlockCols),
MatrixRows = ei_traits<MatrixType>::RowsAtCompileTime,
MatrixCols = ei_traits<MatrixType>::ColsAtCompileTime,
RowsAtCompileTime = MatrixRows == 0 ? 0 : BlockRows,
ColsAtCompileTime = MatrixCols == 0 ? 0 : BlockCols,
MaxRowsAtCompileTime = BlockRows==0 ? 0
: RowsAtCompileTime != Dynamic ? int(RowsAtCompileTime)
: int(ei_traits<MatrixType>::MaxRowsAtCompileTime),
MaxColsAtCompileTime = BlockCols==0 ? 0
: ColsAtCompileTime != Dynamic ? int(ColsAtCompileTime)
: int(ei_traits<MatrixType>::MaxColsAtCompileTime),
MatrixTypeIsRowMajor = (int(ei_traits<MatrixType>::Flags)&RowMajorBit) != 0,
IsRowMajor = (BlockRows==1&&BlockCols!=1) ? 1
: (BlockCols==1&&BlockRows!=1) ? 0
IsRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
: (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
: MatrixTypeIsRowMajor,
InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
HasSameStorageOrderAsMatrixType = (IsRowMajor == MatrixTypeIsRowMajor),
InnerSize = MatrixTypeIsRowMajor // notice how it's MatrixTypeIsRowMajor here, not IsRowMajor. Inner size is computed wrt the host matrix's storage order.
? int(ColsAtCompileTime) : int(RowsAtCompileTime),
InnerStrideAtCompileTime = HasSameStorageOrderAsMatrixType
? int(ei_inner_stride_at_compile_time<MatrixType>::ret)
: int(ei_outer_stride_at_compile_time<MatrixType>::ret),
OuterStrideAtCompileTime = HasSameStorageOrderAsMatrixType
? int(ei_outer_stride_at_compile_time<MatrixType>::ret)
: int(ei_inner_stride_at_compile_time<MatrixType>::ret),
MaskPacketAccessBit = (InnerSize == Dynamic || (InnerSize % ei_packet_traits<Scalar>::size) == 0)
&& (IsRowMajor == MatrixTypeIsRowMajor) // check for bad case of row-xpr inside col-major matrix...
&& (InnerStrideAtCompileTime == 1)
? PacketAccessBit : 0,
FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
Flags0 = ei_traits<MatrixType>::Flags & (HereditaryBits | MaskPacketAccessBit | DirectAccessBit),
@ -86,7 +100,7 @@ struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >
};
template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessStatus> class Block
: public MatrixType::template MakeBase< Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >::Type
: public ei_dense_xpr_base<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >::type
{
public:
@ -217,12 +231,11 @@ template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessSta
/** \internal */
template<typename MatrixType, int BlockRows, int BlockCols>
class Block<MatrixType,BlockRows,BlockCols,HasDirectAccess>
: public MapBase<Block<MatrixType, BlockRows, BlockCols,HasDirectAccess>,
typename MatrixType::template MakeBase< Block<MatrixType, BlockRows, BlockCols,HasDirectAccess> >::Type>
: public MapBase<Block<MatrixType, BlockRows, BlockCols,HasDirectAccess> >
{
public:
typedef MapBase<Block, typename MatrixType::template MakeBase<Block>::Type> Base;
typedef MapBase<Block> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Block)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
@ -268,15 +281,17 @@ class Block<MatrixType,BlockRows,BlockCols,HasDirectAccess>
/** \sa MapBase::innerStride() */
inline int innerStride() const
{
return RowsAtCompileTime==1 ? m_matrix.colStride()
: ColsAtCompileTime==1 ? m_matrix.rowStride()
: m_matrix.innerStride();
return ei_traits<Block>::HasSameStorageOrderAsMatrixType
? m_matrix.innerStride()
: m_matrix.outerStride();
}
/** \sa MapBase::outerStride() */
inline int outerStride() const
{
return IsVectorAtCompileTime ? this->size() : m_matrix.outerStride();
return ei_traits<Block>::HasSameStorageOrderAsMatrixType
? m_matrix.outerStride()
: m_matrix.innerStride();
}
#ifndef __SUNPRO_CC

14
Eigen/src/Core/CwiseBinaryOp.h
View File

@ -54,8 +54,8 @@ struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > : ei_traits<Lhs>
typename Rhs::Scalar
)
>::type Scalar;
typedef typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageType,
typename ei_traits<Rhs>::StorageType>::ret StorageType;
typedef typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind,
typename ei_traits<Rhs>::StorageKind>::ret StorageKind;
typedef typename Lhs::Nested LhsNested;
typedef typename Rhs::Nested RhsNested;
typedef typename ei_unref<LhsNested>::type _LhsNested;
@ -80,22 +80,22 @@ struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > : ei_traits<Lhs>
};
};
template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageType>
template<typename BinaryOp, typename Lhs, typename Rhs, typename StorageKind>
class CwiseBinaryOpImpl;
template<typename BinaryOp, typename Lhs, typename Rhs>
class CwiseBinaryOp : ei_no_assignment_operator,
public CwiseBinaryOpImpl<
BinaryOp, Lhs, Rhs,
typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageType,
typename ei_traits<Rhs>::StorageType>::ret>
typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind,
typename ei_traits<Rhs>::StorageKind>::ret>
{
public:
typedef typename CwiseBinaryOpImpl<
BinaryOp, Lhs, Rhs,
typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageType,
typename ei_traits<Rhs>::StorageType>::ret>::Base Base;
typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind,
typename ei_traits<Rhs>::StorageKind>::ret>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(CwiseBinaryOp)
typedef typename ei_nested<Lhs>::type LhsNested;

24
Eigen/src/Core/CwiseNullaryOp.h
View File

@ -319,9 +319,9 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& value
*
* \sa MatrixBase::setConstant(const Scalar&), setConstant(int,int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setConstant(int size, const Scalar& value)
DenseStorageBase<Derived>::setConstant(int size, const Scalar& value)
{
resize(size);
return setConstant(value);
@ -337,9 +337,9 @@ DenseStorageBase<Derived,_Base,_Options>::setConstant(int size, const Scalar& va
*
* \sa MatrixBase::setConstant(const Scalar&), setConstant(int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setConstant(int rows, int cols, const Scalar& value)
DenseStorageBase<Derived>::setConstant(int rows, int cols, const Scalar& value)
{
resize(rows, cols);
return setConstant(value);
@ -467,9 +467,9 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
*
* \sa DenseBase::setZero(), setZero(int,int), class CwiseNullaryOp, DenseBase::Zero()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setZero(int size)
DenseStorageBase<Derived>::setZero(int size)
{
resize(size);
return setConstant(Scalar(0));
@ -485,9 +485,9 @@ DenseStorageBase<Derived,_Base,_Options>::setZero(int size)
*
* \sa DenseBase::setZero(), setZero(int), class CwiseNullaryOp, DenseBase::Zero()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setZero(int rows, int cols)
DenseStorageBase<Derived>::setZero(int rows, int cols)
{
resize(rows, cols);
return setConstant(Scalar(0));
@ -593,9 +593,9 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
*
* \sa MatrixBase::setOnes(), setOnes(int,int), class CwiseNullaryOp, MatrixBase::Ones()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setOnes(int size)
DenseStorageBase<Derived>::setOnes(int size)
{
resize(size);
return setConstant(Scalar(1));
@ -611,9 +611,9 @@ DenseStorageBase<Derived,_Base,_Options>::setOnes(int size)
*
* \sa MatrixBase::setOnes(), setOnes(int), class CwiseNullaryOp, MatrixBase::Ones()
*/
template<typename Derived, template<typename> class _Base, int _Options>
template<typename Derived>
EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived,_Base,_Options>::setOnes(int rows, int cols)
DenseStorageBase<Derived>::setOnes(int rows, int cols)
{
resize(rows, cols);
return setConstant(Scalar(1));

6
Eigen/src/Core/CwiseUnaryOp.h
View File

@ -56,16 +56,16 @@ struct ei_traits<CwiseUnaryOp<UnaryOp, MatrixType> >
};
};
template<typename UnaryOp, typename MatrixType, typename StorageType>
template<typename UnaryOp, typename MatrixType, typename StorageKind>
class CwiseUnaryOpImpl;
template<typename UnaryOp, typename MatrixType>
class CwiseUnaryOp : ei_no_assignment_operator,
public CwiseUnaryOpImpl<UnaryOp, MatrixType, typename ei_traits<MatrixType>::StorageType>
public CwiseUnaryOpImpl<UnaryOp, MatrixType, typename ei_traits<MatrixType>::StorageKind>
{
public:
typedef typename CwiseUnaryOpImpl<UnaryOp, MatrixType,typename ei_traits<MatrixType>::StorageType>::Base Base;
typedef typename CwiseUnaryOpImpl<UnaryOp, MatrixType,typename ei_traits<MatrixType>::StorageKind>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(CwiseUnaryOp)
inline CwiseUnaryOp(const MatrixType& mat, const UnaryOp& func = UnaryOp())

6
Eigen/src/Core/CwiseUnaryView.h
View File

@ -52,16 +52,16 @@ struct ei_traits<CwiseUnaryView<ViewOp, MatrixType> >
};
};
template<typename ViewOp, typename MatrixType, typename StorageType>
template<typename ViewOp, typename MatrixType, typename StorageKind>
class CwiseUnaryViewImpl;
template<typename ViewOp, typename MatrixType>
class CwiseUnaryView : ei_no_assignment_operator,
public CwiseUnaryViewImpl<ViewOp, MatrixType, typename ei_traits<MatrixType>::StorageType>
public CwiseUnaryViewImpl<ViewOp, MatrixType, typename ei_traits<MatrixType>::StorageKind>
{
public:
typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename ei_traits<MatrixType>::StorageType>::Base Base;
typedef typename CwiseUnaryViewImpl<ViewOp, MatrixType,typename ei_traits<MatrixType>::StorageKind>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(CwiseUnaryView)
inline CwiseUnaryView(const MatrixType& mat, const ViewOp& func = ViewOp())

60
Eigen/src/Core/DenseBase.h
View File

@ -112,8 +112,8 @@ template<typename Derived> class DenseBase
* \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
*/
IsVectorAtCompileTime = ei_traits<Derived>::RowsAtCompileTime == 1
|| ei_traits<Derived>::ColsAtCompileTime == 1,
IsVectorAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime == 1
|| ei_traits<Derived>::MaxColsAtCompileTime == 1,
/**< This is set to true if either the number of rows or the number of
* columns is known at compile-time to be equal to 1. Indeed, in that case,
* we are dealing with a column-vector (if there is only one column) or with
@ -127,7 +127,7 @@ template<typename Derived> class DenseBase
IsRowMajor = int(Flags) & RowMajorBit, /**< True if this expression has row-major storage order. */
InnerSizeAtCompileTime = int(IsVectorAtCompileTime) ? SizeAtCompileTime
: int(Flags)&RowMajorBit ? ColsAtCompileTime : RowsAtCompileTime,
: int(IsRowMajor) ? ColsAtCompileTime : RowsAtCompileTime,
CoeffReadCost = ei_traits<Derived>::CoeffReadCost,
/**< This is a rough measure of how expensive it is to read one coefficient from
@ -172,7 +172,7 @@ template<typename Derived> class DenseBase
int outerSize() const
{
return IsVectorAtCompileTime ? 1
: (int(Flags)&RowMajorBit) ? this->rows() : this->cols();
: int(IsRowMajor) ? this->rows() : this->cols();
}
/** \returns the inner size.
@ -183,7 +183,7 @@ template<typename Derived> class DenseBase
int innerSize() const
{
return IsVectorAtCompileTime ? this->size()
: (int(Flags)&RowMajorBit) ? this->cols() : this->rows();
: int(IsRowMajor) ? this->cols() : this->rows();
}
/** Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are
@ -205,52 +205,6 @@ template<typename Derived> class DenseBase
&& "DenseBase::resize() does not actually allow to resize.");
}
/** \returns the pointer increment between two consecutive elements within a slice in the inner direction.
*
* \sa outerStride(), rowStride(), colStride()
*/
inline int innerStride() const
{
EIGEN_STATIC_ASSERT(int(Flags)&DirectAccessBit,
THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
return derived().innerStride();
}
/** \returns the pointer increment between two consecutive inner slices (for example, between two consecutive columns
* in a column-major matrix).
*
* \sa innerStride(), rowStride(), colStride()
*/
inline int outerStride() const
{
EIGEN_STATIC_ASSERT(int(Flags)&DirectAccessBit,
THIS_METHOD_IS_ONLY_FOR_EXPRESSIONS_WITH_DIRECT_MEMORY_ACCESS_SUCH_AS_MAP_OR_PLAIN_MATRICES)
return derived().outerStride();
}
inline int stride() const
{
return IsVectorAtCompileTime ? innerStride() : outerStride();
}
/** \returns the pointer increment between two consecutive rows.
*
* \sa innerStride(), outerStride(), colStride()
*/
inline int rowStride() const
{
return IsRowMajor ? outerStride() : innerStride();
}
/** \returns the pointer increment between two consecutive columns.
*
* \sa innerStride(), outerStride(), rowStride()
*/
inline int colStride() const
{
return IsRowMajor ? innerStride() : outerStride();
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** \internal the return type of coeff()
*/
@ -589,8 +543,8 @@ template<typename Derived> class DenseBase
#ifdef EIGEN_INTERNAL_DEBUGGING
EIGEN_STATIC_ASSERT(ei_are_flags_consistent<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(RowsAtCompileTime==1 && ColsAtCompileTime!=1, (Flags&RowMajorBit)==RowMajorBit)
&& EIGEN_IMPLIES(ColsAtCompileTime==1 && RowsAtCompileTime!=1, (Flags&RowMajorBit)==0)),
EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor))
&& EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))),
INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION)
#endif
}

20
Eigen/src/Core/DenseStorageBase.h
View File

@ -38,12 +38,12 @@ template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct e
/**
* \brief Dense storage base class for matrices and arrays.
**/
template<typename Derived, template<typename> class _Base, int _Options>
class DenseStorageBase : public _Base<Derived>
template<typename Derived>
class DenseStorageBase : public DenseDirectAccessBase<Derived>
{
public:
enum { Options = _Options };
typedef _Base<Derived> Base;
enum { Options = ei_traits<Derived>::Options };
typedef typename ei_traits<Derived>::XprBase Base;
typedef typename Base::PlainObject PlainObject;
typedef typename Base::Scalar Scalar;
typedef typename Base::PacketScalar PacketScalar;
@ -157,10 +157,6 @@ class DenseStorageBase : public _Base<Derived>
*/
inline void resize(int rows, int cols)
{
ei_assert((MaxRowsAtCompileTime == Dynamic || MaxRowsAtCompileTime >= rows)
&& (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
&& (MaxColsAtCompileTime == Dynamic || MaxColsAtCompileTime >= cols)
&& (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
#ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO
int size = rows*cols;
bool size_changed = size != this->size();
@ -510,8 +506,8 @@ class DenseStorageBase : public _Base<Derived>
#ifndef EIGEN_PARSED_BY_DOXYGEN
EIGEN_STRONG_INLINE static void _check_template_params()
{
EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(RowsAtCompileTime==1 && ColsAtCompileTime!=1, (_Options&RowMajor)==RowMajor)
&& EIGEN_IMPLIES(ColsAtCompileTime==1 && RowsAtCompileTime!=1, (_Options&RowMajor)==0)
EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)
&& EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (Options&RowMajor)==0)
&& (RowsAtCompileTime >= MaxRowsAtCompileTime)
&& (ColsAtCompileTime >= MaxColsAtCompileTime)
&& (MaxRowsAtCompileTime >= 0)
@ -521,14 +517,12 @@ class DenseStorageBase : public _Base<Derived>
&& (MaxRowsAtCompileTime == RowsAtCompileTime || RowsAtCompileTime==Dynamic)
&& (MaxColsAtCompileTime == ColsAtCompileTime || ColsAtCompileTime==Dynamic)
&& ((MaxRowsAtCompileTime==Dynamic?1:MaxRowsAtCompileTime)*(MaxColsAtCompileTime==Dynamic?1:MaxColsAtCompileTime)<Dynamic)
&& (_Options & (DontAlign|RowMajor)) == _Options),
&& (Options & (DontAlign|RowMajor)) == Options),
INVALID_MATRIX_TEMPLATE_PARAMETERS)
}
#endif
};
template <typename Derived, typename OtherDerived, bool IsVector>
struct ei_conservative_resize_like_impl
{

20
Eigen/src/Core/Map.h
View File

@ -79,33 +79,31 @@ struct ei_traits<Map<MatrixType, Options, StrideType> >
{
typedef typename MatrixType::Scalar Scalar;
enum {
InnerStride = StrideType::InnerStrideAtCompileTime,
OuterStride = StrideType::OuterStrideAtCompileTime,
HasNoInnerStride = InnerStride <= 1,
HasNoOuterStride = OuterStride == 0,
InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime,
OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime,
HasNoInnerStride = InnerStrideAtCompileTime <= 1,
HasNoOuterStride = OuterStrideAtCompileTime == 0,
HasNoStride = HasNoInnerStride && HasNoOuterStride,
IsAligned = int(int(Options)&Aligned)==Aligned,
IsDynamicSize = MatrixType::SizeAtCompileTime==Dynamic,
KeepsPacketAccess = bool(HasNoInnerStride)
&& ( bool(IsDynamicSize)
|| HasNoOuterStride
|| ( OuterStride!=Dynamic && ((int(OuterStride)*sizeof(Scalar))%16)==0 ) ),
|| ( OuterStrideAtCompileTime!=Dynamic
&& ((int(OuterStrideAtCompileTime)*sizeof(Scalar))%16)==0 ) ),
Flags0 = ei_traits<MatrixType>::Flags,
Flags1 = IsAligned ? int(Flags0) | AlignedBit : int(Flags0) & ~AlignedBit,
Flags1 = IsAligned ? int(Flags0) | AlignedBit : int(Flags0) & ~AlignedBit,
Flags2 = HasNoStride ? int(Flags1) : int(Flags1 & ~LinearAccessBit),
Flags = KeepsPacketAccess ? int(Flags2) : (int(Flags2) & ~PacketAccessBit)
};
};
template<typename MatrixType, int Options, typename StrideType> class Map
: public MapBase<Map<MatrixType, Options, StrideType>,
typename MatrixType::template MakeBase<
Map<MatrixType, Options, StrideType>
>::Type>
: public MapBase<Map<MatrixType, Options, StrideType> >
{
public:
typedef MapBase<Map,typename MatrixType::template MakeBase<Map>::Type> Base;
typedef MapBase<Map> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Map)

39
Eigen/src/Core/MapBase.h
View File

@ -32,11 +32,12 @@
*
* \sa class Map, class Block
*/
template<typename Derived, typename Base> class MapBase
: public Base
template<typename Derived> class MapBase
: public DenseDirectAccessBase<Derived>
{
public:
typedef DenseDirectAccessBase<Derived> Base;
enum {
RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime,
ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime,
@ -46,10 +47,41 @@ template<typename Derived, typename Base> class MapBase
typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename Base::PacketScalar PacketScalar;
using Base::derived;
// using Base::RowsAtCompileTime;
// using Base::ColsAtCompileTime;
// using Base::SizeAtCompileTime;
using Base::MaxRowsAtCompileTime;
using Base::MaxColsAtCompileTime;
using Base::MaxSizeAtCompileTime;
using Base::IsVectorAtCompileTime;
using Base::Flags;
using Base::IsRowMajor;
using Base::CoeffReadCost;
using Base::_HasDirectAccess;
// using Base::derived;
using Base::const_cast_derived;
using Base::rows;
using Base::cols;
using Base::size;
using Base::coeff;
using Base::coeffRef;
using Base::lazyAssign;
using Base::eval;
// using Base::operator=;
using Base::operator+=;
using Base::operator-=;
using Base::operator*=;
using Base::operator/=;
using Base::innerStride;
using Base::outerStride;
using Base::rowStride;
using Base::colStride;
typedef typename Base::CoeffReturnType CoeffReturnType;
inline int rows() const { return m_rows.value(); }
inline int cols() const { return m_cols.value(); }
@ -139,7 +171,8 @@ template<typename Derived, typename Base> class MapBase
Derived& operator=(const MapBase& other)
{
return Base::operator=(other);
Base::operator=(other);
return derived();
}
using Base::operator=;

14
Eigen/src/Core/Matrix.h
View File

@ -112,28 +112,32 @@ template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int
struct ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
typedef _Scalar Scalar;
typedef Dense StorageType;
typedef DenseStorageMatrix DenseStorageType;
typedef Dense StorageKind;
typedef MatrixXpr XprKind;
typedef MatrixBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > XprBase;
enum {
RowsAtCompileTime = _Rows,
ColsAtCompileTime = _Cols,
MaxRowsAtCompileTime = _MaxRows,
MaxColsAtCompileTime = _MaxCols,
Flags = ei_compute_matrix_flags<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::ret,
CoeffReadCost = NumTraits<Scalar>::ReadCost
CoeffReadCost = NumTraits<Scalar>::ReadCost,
Options = _Options,
InnerStrideAtCompileTime = 1,
OuterStrideAtCompileTime = (Options&RowMajor) ? ColsAtCompileTime : RowsAtCompileTime
};
};
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Matrix
: public DenseStorageBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, MatrixBase, _Options>
: public DenseStorageBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{
public:
/** \brief Base class typedef.
* \sa DenseStorageBase
*/
typedef DenseStorageBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Eigen::MatrixBase, _Options> Base;
typedef DenseStorageBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > Base;
enum { Options = _Options };

8
Eigen/src/Core/ProductBase.h
View File

@ -31,12 +31,12 @@
template<typename Derived, typename _Lhs, typename _Rhs>
struct ei_traits<ProductBase<Derived,_Lhs,_Rhs> > //: ei_traits<typename ei_cleantype<_Lhs>::type>
{
typedef DenseStorageMatrix DenseStorageType;
typedef MatrixXpr XprKind;
typedef typename ei_cleantype<_Lhs>::type Lhs;
typedef typename ei_cleantype<_Rhs>::type Rhs;
typedef typename ei_scalar_product_traits<typename Lhs::Scalar, typename Rhs::Scalar>::ReturnType Scalar;
typedef typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageType,
typename ei_traits<Rhs>::StorageType>::ret StorageType;
typedef typename ei_promote_storage_type<typename ei_traits<Lhs>::StorageKind,
typename ei_traits<Rhs>::StorageKind>::ret StorageKind;
enum {
RowsAtCompileTime = ei_traits<Lhs>::RowsAtCompileTime,
ColsAtCompileTime = ei_traits<Rhs>::ColsAtCompileTime,
@ -199,7 +199,7 @@ struct ei_traits<ScaledProduct<NestedProduct> >
typename NestedProduct::_LhsNested,
typename NestedProduct::_RhsNested> >
{
typedef typename ei_traits<NestedProduct>::StorageType StorageType;
typedef typename ei_traits<NestedProduct>::StorageKind StorageKind;
};
template<typename NestedProduct>

34
Eigen/src/Core/Transpose.h
View File

@ -44,25 +44,28 @@ struct ei_traits<Transpose<MatrixType> > : ei_traits<MatrixType>
typedef typename MatrixType::Scalar Scalar;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename ei_traits<MatrixType>::XprKind XprKind;
enum {
RowsAtCompileTime = MatrixType::ColsAtCompileTime,
ColsAtCompileTime = MatrixType::RowsAtCompileTime,
MaxRowsAtCompileTime = MatrixType::MaxColsAtCompileTime,
MaxColsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
Flags = int(_MatrixTypeNested::Flags & ~NestByRefBit) ^ RowMajorBit,
CoeffReadCost = _MatrixTypeNested::CoeffReadCost
CoeffReadCost = _MatrixTypeNested::CoeffReadCost,
InnerStrideAtCompileTime = ei_inner_stride_at_compile_time<MatrixType>::ret,
OuterStrideAtCompileTime = ei_outer_stride_at_compile_time<MatrixType>::ret
};
};
template<typename MatrixType, typename StorageType> class TransposeImpl;
template<typename MatrixType, typename StorageKind> class TransposeImpl;
template<typename MatrixType> class Transpose
: public TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageType>
: public TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageKind>
{
public:
typedef typename TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageType>::Base Base;
typedef typename TransposeImpl<MatrixType,typename ei_traits<MatrixType>::StorageKind>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(Transpose)
inline Transpose(const MatrixType& matrix) : m_matrix(matrix) {}
@ -84,13 +87,24 @@ template<typename MatrixType> class Transpose
const typename MatrixType::Nested m_matrix;
};
template<typename MatrixType, bool _HasDirectAccess = ei_has_direct_access<MatrixType>::ret>
struct ei_TransposeImpl_base
{
typedef DenseDirectAccessBase<Transpose<MatrixType> > type;
};
template<typename MatrixType>
struct ei_TransposeImpl_base<MatrixType, false>
{
typedef typename ei_dense_xpr_base<Transpose<MatrixType> >::type type;
};
template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
: public MatrixType::template MakeBase<Transpose<MatrixType> >::Type
: public ei_TransposeImpl_base<MatrixType>::type
{
public:
typedef typename MatrixType::template MakeBase<Transpose<MatrixType> >::Type Base;
typedef typename ei_TransposeImpl_base<MatrixType>::type Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
inline int innerStride() const { return derived().nestedExpression().innerStride(); }
@ -301,7 +315,7 @@ struct ei_check_transpose_aliasing_selector
{
static bool run(const Scalar* dest, const OtherDerived& src)
{
return (ei_blas_traits<OtherDerived>::IsTransposed != DestIsTranposed) && (dest==(Scalar*)ei_extract_data(src));
return (ei_blas_traits<OtherDerived>::IsTransposed != DestIsTranposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src));
}
};
@ -310,8 +324,8 @@ struct ei_check_transpose_aliasing_selector<Scalar,DestIsTranposed,CwiseBinaryOp
{
static bool run(const Scalar* dest, const CwiseBinaryOp<BinOp,DerivedA,DerivedB>& src)
{
return ((ei_blas_traits<DerivedA>::IsTransposed != DestIsTranposed) && dest==(Scalar*)ei_extract_data(src.lhs()))
|| ((ei_blas_traits<DerivedB>::IsTransposed != DestIsTranposed) && dest==(Scalar*)ei_extract_data(src.rhs()));
return ((ei_blas_traits<DerivedA>::IsTransposed != DestIsTranposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.lhs())))
|| ((ei_blas_traits<DerivedB>::IsTransposed != DestIsTranposed) && (dest!=0 && dest==(Scalar*)ei_extract_data(src.rhs())));
}
};

10
Eigen/src/Core/products/CoeffBasedProduct.h
View File

@ -48,12 +48,12 @@ struct ei_product_packet_impl;
template<typename LhsNested, typename RhsNested, int NestingFlags>
struct ei_traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> >
{
typedef DenseStorageMatrix DenseStorageType;
typedef MatrixXpr XprKind;
typedef typename ei_cleantype<LhsNested>::type _LhsNested;
typedef typename ei_cleantype<RhsNested>::type _RhsNested;
typedef typename ei_scalar_product_traits<typename _LhsNested::Scalar, typename _RhsNested::Scalar>::ReturnType Scalar;
typedef typename ei_promote_storage_type<typename ei_traits<_LhsNested>::StorageType,
typename ei_traits<_RhsNested>::StorageType>::ret StorageType;
typedef typename ei_promote_storage_type<typename ei_traits<_LhsNested>::StorageKind,
typename ei_traits<_RhsNested>::StorageKind>::ret StorageKind;
enum {
LhsCoeffReadCost = _LhsNested::CoeffReadCost,
@ -77,8 +77,8 @@ struct ei_traits<CoeffBasedProduct<LhsNested,RhsNested,NestingFlags> >
CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit)
&& (RowsAtCompileTime == Dynamic || (RowsAtCompileTime % ei_packet_traits<Scalar>::size) == 0),
EvalToRowMajor = (RowsAtCompileTime==1&&ColsAtCompileTime!=1) ? 1
: (ColsAtCompileTime==1&&RowsAtCompileTime!=1) ? 0
EvalToRowMajor = (MaxRowsAtCompileTime==1&&MaxColsAtCompileTime!=1) ? 1
: (MaxColsAtCompileTime==1&&MaxRowsAtCompileTime!=1) ? 0
: (RhsRowMajor && !CanVectorizeLhs),
Flags = ((unsigned int)(LhsFlags | RhsFlags) & HereditaryBits & ~RowMajorBit)

4
Eigen/src/Core/util/BlasUtil.h
View File

@ -158,7 +158,9 @@ template<typename XprType> struct ei_blas_traits
IsComplex = NumTraits<Scalar>::IsComplex,
IsTransposed = false,
NeedToConjugate = false,
ActualAccess = int(ei_traits<XprType>::Flags)&DirectAccessBit ? HasDirectAccess : NoDirectAccess
ActualAccess = ( (int(ei_traits<XprType>::Flags)&DirectAccessBit)
&& (int(ei_inner_stride_at_compile_time<XprType>::ret) == 1)
) ? HasDirectAccess : NoDirectAccess
};
typedef typename ei_meta_if<int(ActualAccess)==HasDirectAccess,
ExtractType,

15
Eigen/src/Core/util/Constants.h
View File

@ -97,8 +97,6 @@ const unsigned int EvalBeforeAssigningBit = 0x4;
*/
const unsigned int PacketAccessBit = 0x8;
const unsigned int NestByRefBit = 0x100;
#ifdef EIGEN_VECTORIZE
/** \ingroup flags
*
@ -151,6 +149,7 @@ const unsigned int DirectAccessBit = 0x20;
* means the first coefficient packet is guaranteed to be aligned */
const unsigned int AlignedBit = 0x40;
const unsigned int NestByRefBit = 0x100;
// list of flags that are inherited by default
const unsigned int HereditaryBits = RowMajorBit
@ -266,9 +265,15 @@ namespace Architecture
};
}
enum DenseStorageMatrix {};
enum DenseStorageArray {};
enum { CoeffBasedProductMode, LazyCoeffBasedProductMode, OuterProduct, InnerProduct, GemvProduct, GemmProduct };
/** The type used to identify a dense storage. */
struct Dense {};
/** The type used to identify a matrix expression */
struct MatrixXpr {};
/** The type used to identify an array expression */
struct ArrayXpr {};
#endif // EIGEN_CONSTANTS_H

3
Eigen/src/Core/util/ForwardDeclarations.h
View File

@ -40,6 +40,9 @@ template<typename _Scalar, int _Rows, int _Cols,
int _MaxCols = _Cols
> class Matrix;
template<typename Derived> class MatrixBase;
template<typename Derived> class ArrayBase;
template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
template<typename ExpressionType, template <typename> class StorageBase > class NoAlias;
template<typename ExpressionType> class NestByValue;

30
Eigen/src/Core/util/XprHelper.h
View File

@ -136,14 +136,14 @@ template<int _Rows, int _Cols> struct ei_size_at_compile_time
* whereas ei_eval is a const reference in the case of a matrix
*/
template<typename T, typename StorageType = typename ei_traits<T>::StorageType> struct ei_plain_matrix_type;
template<typename T, typename StorageKind = typename ei_traits<T>::StorageKind> struct ei_plain_matrix_type;
template<typename T, typename BaseClassType> struct ei_plain_matrix_type_dense;
template<typename T> struct ei_plain_matrix_type<T,Dense>
{
typedef typename ei_plain_matrix_type_dense<T,typename ei_traits<T>::DenseStorageType>::type type;
typedef typename ei_plain_matrix_type_dense<T,typename ei_traits<T>::XprKind>::type type;
};
template<typename T> struct ei_plain_matrix_type_dense<T,DenseStorageMatrix>
template<typename T> struct ei_plain_matrix_type_dense<T,MatrixXpr>
{
typedef Matrix<typename ei_traits<T>::Scalar,
ei_traits<T>::RowsAtCompileTime,
@ -154,7 +154,7 @@ template<typename T> struct ei_plain_matrix_type_dense<T,DenseStorageMatrix>
> type;
};
template<typename T> struct ei_plain_matrix_type_dense<T,DenseStorageArray>
template<typename T> struct ei_plain_matrix_type_dense<T,ArrayXpr>
{
typedef Array<typename ei_traits<T>::Scalar,
ei_traits<T>::RowsAtCompileTime,
@ -169,7 +169,7 @@ template<typename T> struct ei_plain_matrix_type_dense<T,DenseStorageArray>
* in order to avoid a useless copy
*/
template<typename T, typename StorageType = typename ei_traits<T>::StorageType> struct ei_eval;
template<typename T, typename StorageKind = typename ei_traits<T>::StorageKind> struct ei_eval;
template<typename T> struct ei_eval<T,Dense>
{
@ -204,14 +204,16 @@ struct ei_eval<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>, Dense
template<typename T> struct ei_plain_matrix_type_column_major
{
enum { Rows = ei_traits<T>::RowsAtCompileTime,
Cols = ei_traits<T>::ColsAtCompileTime
Cols = ei_traits<T>::ColsAtCompileTime,
MaxRows = ei_traits<T>::MaxRowsAtCompileTime,
MaxCols = ei_traits<T>::MaxColsAtCompileTime
};
typedef Matrix<typename ei_traits<T>::Scalar,
Rows,
Cols,
(Rows==1&&Cols!=1) ? RowMajor : ColMajor,
ei_traits<T>::MaxRowsAtCompileTime,
ei_traits<T>::MaxColsAtCompileTime
(MaxRows==1&&MaxCols!=1) ? RowMajor : ColMajor,
MaxRows,
MaxCols
> type;
};
@ -220,14 +222,16 @@ template<typename T> struct ei_plain_matrix_type_column_major
template<typename T> struct ei_plain_matrix_type_row_major
{
enum { Rows = ei_traits<T>::RowsAtCompileTime,
Cols = ei_traits<T>::ColsAtCompileTime
Cols = ei_traits<T>::ColsAtCompileTime,
MaxRows = ei_traits<T>::MaxRowsAtCompileTime,
MaxCols = ei_traits<T>::MaxColsAtCompileTime
};
typedef Matrix<typename ei_traits<T>::Scalar,
Rows,
Cols,
(Cols==1&&Rows!=1) ? ColMajor : RowMajor,
ei_traits<T>::MaxRowsAtCompileTime,
ei_traits<T>::MaxColsAtCompileTime
(MaxCols==1&&MaxRows!=1) ? RowMajor : ColMajor,
MaxRows,
MaxCols
> type;
};

30
Eigen/src/Eigenvalues/ComplexSchur.h
View File

@ -119,26 +119,26 @@ std::complex<RealScalar> ei_sqrt(const std::complex<RealScalar> &z)
if (ei_abs(ei_real(z)) <= ei_abs(ei_imag(z)))
{
// No cancellation in these formulas
tre = ei_sqrt(0.5*(t + ei_real(z)));
tim = ei_sqrt(0.5*(t - ei_real(z)));
tre = ei_sqrt(RealScalar(0.5)*(t + ei_real(z)));
tim = ei_sqrt(RealScalar(0.5)*(t - ei_real(z)));
}
else
{
// Stable computation of the above formulas
if (z.real() > 0)
if (z.real() > RealScalar(0))
{
tre = t + z.real();
tim = ei_abs(ei_imag(z))*ei_sqrt(0.5/tre);
tre = ei_sqrt(0.5*tre);
tim = ei_abs(ei_imag(z))*ei_sqrt(RealScalar(0.5)/tre);
tre = ei_sqrt(RealScalar(0.5)*tre);
}
else
{
tim = t - z.real();
tre = ei_abs(ei_imag(z))*ei_sqrt(0.5/tim);
tim = ei_sqrt(0.5*tim);
tre = ei_abs(ei_imag(z))*ei_sqrt(RealScalar(0.5)/tim);
tim = ei_sqrt(RealScalar(0.5)*tim);
}
}
if(z.imag() < 0)
if(z.imag() < RealScalar(0))
tim = -tim;
return (std::complex<RealScalar>(tre,tim));
@ -149,17 +149,25 @@ template<typename MatrixType>
void ComplexSchur<MatrixType>::compute(const MatrixType& matrix, bool skipU)
{
// this code is inspired from Jampack
m_matUisUptodate = false;
assert(matrix.cols() == matrix.rows());
ei_assert(matrix.cols() == matrix.rows());
int n = matrix.cols();
if(n==1)
{
m_matU = ComplexMatrixType::Identity(1,1);
if(!skipU) m_matT = matrix;
m_isInitialized = true;
m_matUisUptodate = !skipU;
return;
}
// Reduce to Hessenberg form
// TODO skip Q if skipU = true
HessenbergDecomposition<MatrixType> hess(matrix);
m_matT = hess.matrixH();
if(!skipU) m_matU = hess.matrixQ();
if(!skipU) m_matU = hess.matrixQ();
// Reduce the Hessenberg matrix m_matT to triangular form by QR iteration.

2
Eigen/src/Geometry/Homogeneous.h
View File

@ -43,7 +43,7 @@ template<typename MatrixType,int Direction>
struct ei_traits<Homogeneous<MatrixType,Direction> >
: ei_traits<MatrixType>
{
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
enum {

2
Eigen/src/Geometry/Quaternion.h
View File

@ -513,7 +513,7 @@ inline Derived& QuaternionBase<Derived>::setFromTwoVectors(const MatrixBase<Deri
{
c = std::max<Scalar>(c,-1);
Matrix<Scalar,2,3> m; m << v0.transpose(), v1.transpose();
SVD<Matrix<Scalar,2,3> > svd(m);
JacobiSVD<Matrix<Scalar,2,3> > svd(m);
Vector3 axis = svd.matrixV().col(2);
Scalar w2 = (Scalar(1)+c)*Scalar(0.5);

2
Eigen/src/Householder/Householder.h
View File

@ -98,7 +98,7 @@ void MatrixBase<Derived>::applyHouseholderOnTheLeft(
{
Map<typename ei_plain_row_type<PlainObject>::type> tmp(workspace,cols());
Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
tmp.noalias() = essential.adjoint() * bottom;
tmp.noalias() = essential.adjoint().eval() * bottom;
tmp += this->row(0);
this->row(0) -= tau * tmp;
bottom.noalias() -= tau * essential * tmp;

2
Eigen/src/QR/FullPivHouseholderQR.h
View File

@ -60,7 +60,7 @@ template<typename _MatrixType> class FullPivHouseholderQR
typedef typename ei_plain_diag_type<MatrixType>::type HCoeffsType;
typedef Matrix<int, 1, ColsAtCompileTime, RowMajor, 1, MaxColsAtCompileTime> IntRowVectorType;
typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType;
typedef typename ei_plain_row_type<MatrixType, int>::type IntColVectorType;
typedef typename ei_plain_col_type<MatrixType, int>::type IntColVectorType;
typedef typename ei_plain_row_type<MatrixType>::type RowVectorType;
typedef typename ei_plain_col_type<MatrixType>::type ColVectorType;

3
Eigen/src/Sparse/DynamicSparseMatrix.h
View File

@ -46,7 +46,8 @@ template<typename _Scalar, int _Flags>
struct ei_traits<DynamicSparseMatrix<_Scalar, _Flags> >
{
typedef _Scalar Scalar;
typedef Sparse StorageType;
typedef Sparse StorageKind;
typedef MatrixXpr XprKind;
enum {
RowsAtCompileTime = Dynamic,
ColsAtCompileTime = Dynamic,

3
Eigen/src/Sparse/SparseBlock.h
View File

@ -29,7 +29,8 @@ template<typename MatrixType, int Size>
struct ei_traits<SparseInnerVectorSet<MatrixType, Size> >
{
typedef typename ei_traits<MatrixType>::Scalar Scalar;
typedef typename ei_traits<MatrixType>::StorageType StorageType;
typedef typename ei_traits<MatrixType>::StorageKind StorageKind;
typedef MatrixXpr XprKind;
enum {
IsRowMajor = (int(MatrixType::Flags)&RowMajorBit)==RowMajorBit,
Flags = MatrixType::Flags,

4
Eigen/src/Sparse/SparseCwiseBinaryOp.h
View File

@ -59,8 +59,8 @@ class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
};
template<typename BinaryOp, typename Lhs, typename Rhs, typename Derived,
typename _LhsStorageMode = typename ei_traits<Lhs>::StorageType,
typename _RhsStorageMode = typename ei_traits<Rhs>::StorageType>
typename _LhsStorageMode = typename ei_traits<Lhs>::StorageKind,
typename _RhsStorageMode = typename ei_traits<Rhs>::StorageKind>
class ei_sparse_cwise_binary_op_inner_iterator_selector;
template<typename BinaryOp, typename Lhs, typename Rhs>

3
Eigen/src/Sparse/SparseDiagonalProduct.h
View File

@ -43,7 +43,8 @@ struct ei_traits<SparseDiagonalProduct<Lhs, Rhs> >
typedef typename ei_cleantype<Lhs>::type _Lhs;
typedef typename ei_cleantype<Rhs>::type _Rhs;
typedef typename _Lhs::Scalar Scalar;
typedef Sparse StorageType;
typedef Sparse StorageKind;
typedef MatrixXpr XprKind;
enum {
RowsAtCompileTime = _Lhs::RowsAtCompileTime,
ColsAtCompileTime = _Rhs::ColsAtCompileTime,

3
Eigen/src/Sparse/SparseMatrix.h
View File

@ -45,7 +45,8 @@ template<typename _Scalar, int _Options>
struct ei_traits<SparseMatrix<_Scalar, _Options> >
{
typedef _Scalar Scalar;
typedef Sparse StorageType;
typedef Sparse StorageKind;
typedef MatrixXpr XprKind;
enum {
RowsAtCompileTime = Dynamic,
ColsAtCompileTime = Dynamic,

10
Eigen/src/Sparse/SparseProduct.h
View File

@ -52,7 +52,7 @@ struct SparseProductReturnType
template<typename LhsNested, typename RhsNested>
struct ei_traits<SparseProduct<LhsNested, RhsNested> >
{
typedef DenseStorageMatrix DenseStorageType;
typedef MatrixXpr XprKind;
// clean the nested types:
typedef typename ei_cleantype<LhsNested>::type _LhsNested;
typedef typename ei_cleantype<RhsNested>::type _RhsNested;
@ -82,7 +82,7 @@ struct ei_traits<SparseProduct<LhsNested, RhsNested> >
CoeffReadCost = Dynamic
};
typedef Sparse StorageType;
typedef Sparse StorageKind;
typedef SparseMatrixBase<SparseProduct<LhsNested, RhsNested> > Base;
};
@ -489,8 +489,8 @@ template<typename Lhs, typename Rhs>
struct ei_traits<SparseTimeDenseProduct<Lhs,Rhs> >
: ei_traits<ProductBase<SparseTimeDenseProduct<Lhs,Rhs>, Lhs, Rhs> >
{
typedef Dense StorageType;
typedef DenseStorageMatrix DenseStorageType;
typedef Dense StorageKind;
typedef MatrixXpr XprKind;
};
template<typename Lhs, typename Rhs>
@ -532,7 +532,7 @@ template<typename Lhs, typename Rhs>
struct ei_traits<DenseTimeSparseProduct<Lhs,Rhs> >
: ei_traits<ProductBase<DenseTimeSparseProduct<Lhs,Rhs>, Lhs, Rhs> >
{
typedef Dense StorageType;
typedef Dense StorageKind;
};
template<typename Lhs, typename Rhs>

2
Eigen/src/Sparse/SparseSelfAdjointView.h
View File

@ -145,7 +145,7 @@ template<typename Lhs, typename Rhs, int UpLo>
struct ei_traits<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo> >
: ei_traits<ProductBase<SparseSelfAdjointTimeDenseProduct<Lhs,Rhs,UpLo>, Lhs, Rhs> >
{
typedef Dense StorageType;
typedef Dense StorageKind;
};
template<typename Lhs, typename Rhs, int UpLo>

4
Eigen/src/Sparse/SparseUtil.h
View File

@ -134,8 +134,8 @@ template<typename Lhs, typename Rhs> class SparseTimeDenseProduct;
template<typename Lhs, typename Rhs> class DenseTimeSparseProduct;
template<typename Lhs, typename Rhs,
typename LhsStorage = typename ei_traits<Lhs>::StorageType,
typename RhsStorage = typename ei_traits<Rhs>::StorageType> struct ei_sparse_product_mode;
typename LhsStorage = typename ei_traits<Lhs>::StorageKind,
typename RhsStorage = typename ei_traits<Rhs>::StorageKind> struct ei_sparse_product_mode;
template<typename Lhs, typename Rhs> struct SparseProductReturnType;

3
Eigen/src/Sparse/SparseVector.h
View File

@ -38,7 +38,8 @@ template<typename _Scalar, int _Options>
struct ei_traits<SparseVector<_Scalar, _Options> >
{
typedef _Scalar Scalar;
typedef Sparse StorageType;
typedef Sparse StorageKind;
typedef MatrixXpr XprKind;
enum {
IsColVector = _Options & RowMajorBit ? 0 : 1,

1
test/basicstuff.cpp
View File

@ -88,6 +88,7 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
rv = square.row(r);
cv = square.col(r);
VERIFY_IS_APPROX(rv, cv.transpose());
if(cols!=1 && rows!=1 && MatrixType::SizeAtCompileTime!=Dynamic)

2
test/householder.cpp
View File

@ -119,7 +119,7 @@ template<typename MatrixType> void householder(const MatrixType& m)
void test_householder()
{
for(int i = 0; i < 2*g_repeat; i++) {
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( householder(Matrix<double,2,2>()) );
CALL_SUBTEST_2( householder(Matrix<float,2,3>()) );
CALL_SUBTEST_3( householder(Matrix<double,3,5>()) );

6
test/product_notemporary.cpp
View File

@ -86,7 +86,7 @@ template<typename MatrixType> void product_notemporary(const MatrixType& m)
VERIFY_EVALUATION_COUNT( rm3.noalias() = (s1 * m1.adjoint()).template triangularView<Upper>() * (m2+m2), 1);
VERIFY_EVALUATION_COUNT( rm3.noalias() = (s1 * m1.adjoint()).template triangularView<UnitUpper>() * m2.adjoint(), 0);
VERIFY_EVALUATION_COUNT( rm3.col(c0).noalias() = (s1 * m1.adjoint()).template triangularView<UnitUpper>() * (s2*m2.row(c0)).adjoint(), 0);
// VERIFY_EVALUATION_COUNT( rm3.col(c0).noalias() = (s1 * m1.adjoint()).template triangularView<UnitUpper>() * (s2*m2.row(c0)).adjoint(), 0);
VERIFY_EVALUATION_COUNT( m1.template triangularView<Lower>().solveInPlace(m3), 0);
VERIFY_EVALUATION_COUNT( m1.adjoint().template triangularView<Lower>().solveInPlace(m3.transpose()), 0);
@ -95,8 +95,8 @@ template<typename MatrixType> void product_notemporary(const MatrixType& m)
VERIFY_EVALUATION_COUNT( m3.noalias() = s2 * m2.adjoint() * (s1 * m1.adjoint()).template selfadjointView<Upper>(), 0);
VERIFY_EVALUATION_COUNT( rm3.noalias() = (s1 * m1.adjoint()).template selfadjointView<Lower>() * m2.adjoint(), 0);
VERIFY_EVALUATION_COUNT( m3.col(c0).noalias() = (s1 * m1).adjoint().template selfadjointView<Lower>() * (-m2.row(c0)*s3).adjoint(), 0);
VERIFY_EVALUATION_COUNT( m3.col(c0).noalias() -= (s1 * m1).adjoint().template selfadjointView<Upper>() * (-m2.row(c0)*s3).adjoint(), 0);
// VERIFY_EVALUATION_COUNT( m3.col(c0).noalias() = (s1 * m1).adjoint().template selfadjointView<Lower>() * (-m2.row(c0)*s3).adjoint(), 0);
// VERIFY_EVALUATION_COUNT( m3.col(c0).noalias() -= (s1 * m1).adjoint().template selfadjointView<Upper>() * (-m2.row(c0)*s3).adjoint(), 0);
VERIFY_EVALUATION_COUNT( m3.block(r0,c0,r1,c1).noalias() += m1.block(r0,r0,r1,r1).template selfadjointView<Upper>() * (s1*m2.block(r0,c0,r1,c1)), 0);
VERIFY_EVALUATION_COUNT( m3.block(r0,c0,r1,c1).noalias() = m1.block(r0,r0,r1,r1).template selfadjointView<Upper>() * m2.block(r0,c0,r1,c1), 0);

20
unsupported/Eigen/FFT
View File

@ -222,7 +222,7 @@ class FFT
template<typename InputDerived, typename ComplexDerived>
inline
void fwd( MatrixBase<ComplexDerived> & dst, const MatrixBase<InputDerived> & src,int nfft=-1)
void fwd( DenseDirectAccessBase<ComplexDerived> & dst, const DenseDirectAccessBase<InputDerived> & src,int nfft=-1)
{
typedef typename ComplexDerived::Scalar dst_type;
typedef typename InputDerived::Scalar src_type;
@ -242,7 +242,7 @@ class FFT
else
dst.derived().resize(nfft);
if ( src.stride() != 1 || src.size() < nfft ) {
if ( src.innerStride() != 1 || src.size() < nfft ) {
Matrix<src_type,1,Dynamic> tmp;
if (src.size()<nfft) {
tmp.setZero(nfft);
@ -258,18 +258,18 @@ class FFT
template<typename InputDerived>
inline
fft_fwd_proxy< MatrixBase<InputDerived>, FFT<T_Scalar,T_Impl> >
fwd( const MatrixBase<InputDerived> & src,int nfft=-1)
fft_fwd_proxy< DenseDirectAccessBase<InputDerived>, FFT<T_Scalar,T_Impl> >
fwd( const DenseDirectAccessBase<InputDerived> & src,int nfft=-1)
{
return fft_fwd_proxy< MatrixBase<InputDerived> ,FFT<T_Scalar,T_Impl> >( src, *this,nfft );
return fft_fwd_proxy< DenseDirectAccessBase<InputDerived> ,FFT<T_Scalar,T_Impl> >( src, *this,nfft );
}
template<typename InputDerived>
inline
fft_inv_proxy< MatrixBase<InputDerived>, FFT<T_Scalar,T_Impl> >
inv( const MatrixBase<InputDerived> & src,int nfft=-1)
fft_inv_proxy< DenseDirectAccessBase<InputDerived>, FFT<T_Scalar,T_Impl> >
inv( const DenseDirectAccessBase<InputDerived> & src,int nfft=-1)
{
return fft_inv_proxy< MatrixBase<InputDerived> ,FFT<T_Scalar,T_Impl> >( src, *this,nfft );
return fft_inv_proxy< DenseDirectAccessBase<InputDerived> ,FFT<T_Scalar,T_Impl> >( src, *this,nfft );
}
inline
@ -290,7 +290,7 @@ class FFT
template<typename OutputDerived, typename ComplexDerived>
inline
void inv( MatrixBase<OutputDerived> & dst, const MatrixBase<ComplexDerived> & src, int nfft=-1)
void inv( DenseDirectAccessBase<OutputDerived> & dst, const DenseDirectAccessBase<ComplexDerived> & src, int nfft=-1)
{
typedef typename ComplexDerived::Scalar src_type;
typedef typename OutputDerived::Scalar dst_type;
@ -316,7 +316,7 @@ class FFT
? ( (nfft/2+1) - src.size() )
: ( nfft - src.size() );
if ( src.stride() != 1 || resize_input ) {
if ( src.innerStride() != 1 || resize_input ) {
// if the vector is strided, then we need to copy it to a packed temporary
Matrix<src_type,1,Dynamic> tmp;
if ( resize_input ) {