GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-10 18:59:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

renaming: ei_matrix_storage -> DenseStorage

Browse Source 
DenseStorageBase  -> PlainObjectBase
This commit is contained in:
Benoit Jacob 2010-10-20 09:34:13 -04:00
parent 9cf748757e
commit 8c17fab8f5
12 changed files with 89 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Eigen/Core
View File

@ -266,12 +266,12 @@ using std::size_t;
#endif #endif
#include "src/Core/util/BlasUtil.h" #include "src/Core/util/BlasUtil.h"
#include "src/Core/MatrixStorage.h" #include "src/Core/DenseStorage.h"
#include "src/Core/NestByValue.h" #include "src/Core/NestByValue.h"
#include "src/Core/ForceAlignedAccess.h" #include "src/Core/ForceAlignedAccess.h"
#include "src/Core/ReturnByValue.h" #include "src/Core/ReturnByValue.h"
#include "src/Core/NoAlias.h" #include "src/Core/NoAlias.h"
#include "src/Core/DenseStorageBase.h" #include "src/Core/PlainObjectBase.h"
#include "src/Core/Matrix.h" #include "src/Core/Matrix.h"
#include "src/Core/CwiseBinaryOp.h" #include "src/Core/CwiseBinaryOp.h"
#include "src/Core/CwiseUnaryOp.h" #include "src/Core/CwiseUnaryOp.h"

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

@ -48,11 +48,11 @@ struct ei_traits<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > :
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Array class Array
: public DenseStorageBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : public PlainObjectBase<Array<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{ {
public: public:
typedef DenseStorageBase<Array> Base; typedef PlainObjectBase<Array> Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Array) EIGEN_DENSE_PUBLIC_INTERFACE(Array)
enum { Options = _Options }; enum { Options = _Options };

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

@ -349,7 +349,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& value
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setConstant(Index size, const Scalar& value) PlainObjectBase<Derived>::setConstant(Index size, const Scalar& value)
{ {
resize(size); resize(size);
return setConstant(value); return setConstant(value);
@ -368,7 +368,7 @@ DenseStorageBase<Derived>::setConstant(Index size, const Scalar& value)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setConstant(Index rows, Index cols, const Scalar& value) PlainObjectBase<Derived>::setConstant(Index rows, Index cols, const Scalar& value)
{ {
resize(rows, cols); resize(rows, cols);
return setConstant(value); return setConstant(value);
@ -498,7 +498,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setZero(Index size) PlainObjectBase<Derived>::setZero(Index size)
{ {
resize(size); resize(size);
return setConstant(Scalar(0)); return setConstant(Scalar(0));
@ -516,7 +516,7 @@ DenseStorageBase<Derived>::setZero(Index size)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setZero(Index rows, Index cols) PlainObjectBase<Derived>::setZero(Index rows, Index cols)
{ {
resize(rows, cols); resize(rows, cols);
return setConstant(Scalar(0)); return setConstant(Scalar(0));
@ -624,7 +624,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setOnes(Index size) PlainObjectBase<Derived>::setOnes(Index size)
{ {
resize(size); resize(size);
return setConstant(Scalar(1)); return setConstant(Scalar(1));
@ -642,7 +642,7 @@ DenseStorageBase<Derived>::setOnes(Index size)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setOnes(Index rows, Index cols) PlainObjectBase<Derived>::setOnes(Index rows, Index cols)
{ {
resize(rows, cols); resize(rows, cols);
return setConstant(Scalar(1)); return setConstant(Scalar(1));

90
Eigen/src/Core/MatrixStorage.h → Eigen/src/Core/DenseStorage.h
View File

@ -78,7 +78,7 @@ struct ei_matrix_array<T, 0, MatrixOptions, Alignment>
/** \internal /** \internal
* *
* \class ei_matrix_storage * \class DenseStorage
* \ingroup Core_Module * \ingroup Core_Module
* *
* \brief Stores the data of a matrix * \brief Stores the data of a matrix
@ -88,18 +88,18 @@ struct ei_matrix_array<T, 0, MatrixOptions, Alignment>
* *
* \sa Matrix * \sa Matrix
*/ */
template<typename T, int Size, int _Rows, int _Cols, int _Options> class ei_matrix_storage; template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage;
// purely fixed-size matrix // purely fixed-size matrix
template<typename T, int Size, int _Rows, int _Cols, int _Options> class ei_matrix_storage template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseStorage
{ {
ei_matrix_array<T,Size,_Options> m_data; ei_matrix_array<T,Size,_Options> m_data;
public: public:
inline explicit ei_matrix_storage() {} inline explicit DenseStorage() {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) inline DenseStorage(ei_constructor_without_unaligned_array_assert)
: m_data(ei_constructor_without_unaligned_array_assert()) {} : m_data(ei_constructor_without_unaligned_array_assert()) {}
inline ei_matrix_storage(DenseIndex,DenseIndex,DenseIndex) {} inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {}
inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); }
inline static DenseIndex rows(void) {return _Rows;} inline static DenseIndex rows(void) {return _Rows;}
inline static DenseIndex cols(void) {return _Cols;} inline static DenseIndex cols(void) {return _Cols;}
inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {} inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {}
@ -109,13 +109,13 @@ template<typename T, int Size, int _Rows, int _Cols, int _Options> class ei_matr
}; };
// null matrix // null matrix
template<typename T, int _Rows, int _Cols, int _Options> class ei_matrix_storage<T, 0, _Rows, _Cols, _Options> template<typename T, int _Rows, int _Cols, int _Options> class DenseStorage<T, 0, _Rows, _Cols, _Options>
{ {
public: public:
inline explicit ei_matrix_storage() {} inline explicit DenseStorage() {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) {} inline DenseStorage(ei_constructor_without_unaligned_array_assert) {}
inline ei_matrix_storage(DenseIndex,DenseIndex,DenseIndex) {} inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {}
inline void swap(ei_matrix_storage& ) {} inline void swap(DenseStorage& ) {}
inline static DenseIndex rows(void) {return _Rows;} inline static DenseIndex rows(void) {return _Rows;}
inline static DenseIndex cols(void) {return _Cols;} inline static DenseIndex cols(void) {return _Cols;}
inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {} inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {}
@ -125,17 +125,17 @@ template<typename T, int _Rows, int _Cols, int _Options> class ei_matrix_storage
}; };
// dynamic-size matrix with fixed-size storage // dynamic-size matrix with fixed-size storage
template<typename T, int Size, int _Options> class ei_matrix_storage<T, Size, Dynamic, Dynamic, _Options> template<typename T, int Size, int _Options> class DenseStorage<T, Size, Dynamic, Dynamic, _Options>
{ {
ei_matrix_array<T,Size,_Options> m_data; ei_matrix_array<T,Size,_Options> m_data;
DenseIndex m_rows; DenseIndex m_rows;
DenseIndex m_cols; DenseIndex m_cols;
public: public:
inline explicit ei_matrix_storage() : m_rows(0), m_cols(0) {} inline explicit DenseStorage() : m_rows(0), m_cols(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) inline DenseStorage(ei_constructor_without_unaligned_array_assert)
: m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {} : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0), m_cols(0) {}
inline ei_matrix_storage(DenseIndex, DenseIndex rows, DenseIndex cols) : m_rows(rows), m_cols(cols) {} inline DenseStorage(DenseIndex, DenseIndex rows, DenseIndex cols) : m_rows(rows), m_cols(cols) {}
inline void swap(ei_matrix_storage& other) inline void swap(DenseStorage& other)
{ std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex rows(void) const {return m_rows;}
inline DenseIndex cols(void) const {return m_cols;} inline DenseIndex cols(void) const {return m_cols;}
@ -146,16 +146,16 @@ template<typename T, int Size, int _Options> class ei_matrix_storage<T, Size, Dy
}; };
// dynamic-size matrix with fixed-size storage and fixed width // dynamic-size matrix with fixed-size storage and fixed width
template<typename T, int Size, int _Cols, int _Options> class ei_matrix_storage<T, Size, Dynamic, _Cols, _Options> template<typename T, int Size, int _Cols, int _Options> class DenseStorage<T, Size, Dynamic, _Cols, _Options>
{ {
ei_matrix_array<T,Size,_Options> m_data; ei_matrix_array<T,Size,_Options> m_data;
DenseIndex m_rows; DenseIndex m_rows;
public: public:
inline explicit ei_matrix_storage() : m_rows(0) {} inline explicit DenseStorage() : m_rows(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) inline DenseStorage(ei_constructor_without_unaligned_array_assert)
: m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {} : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {}
inline ei_matrix_storage(DenseIndex, DenseIndex rows, DenseIndex) : m_rows(rows) {} inline DenseStorage(DenseIndex, DenseIndex rows, DenseIndex) : m_rows(rows) {}
inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex rows(void) const {return m_rows;}
inline DenseIndex cols(void) const {return _Cols;} inline DenseIndex cols(void) const {return _Cols;}
inline void conservativeResize(DenseIndex, DenseIndex rows, DenseIndex) { m_rows = rows; } inline void conservativeResize(DenseIndex, DenseIndex rows, DenseIndex) { m_rows = rows; }
@ -165,16 +165,16 @@ template<typename T, int Size, int _Cols, int _Options> class ei_matrix_storage<
}; };
// dynamic-size matrix with fixed-size storage and fixed height // dynamic-size matrix with fixed-size storage and fixed height
template<typename T, int Size, int _Rows, int _Options> class ei_matrix_storage<T, Size, _Rows, Dynamic, _Options> template<typename T, int Size, int _Rows, int _Options> class DenseStorage<T, Size, _Rows, Dynamic, _Options>
{ {
ei_matrix_array<T,Size,_Options> m_data; ei_matrix_array<T,Size,_Options> m_data;
DenseIndex m_cols; DenseIndex m_cols;
public: public:
inline explicit ei_matrix_storage() : m_cols(0) {} inline explicit DenseStorage() : m_cols(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) inline DenseStorage(ei_constructor_without_unaligned_array_assert)
: m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {} : m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {}
inline ei_matrix_storage(DenseIndex, DenseIndex, DenseIndex cols) : m_cols(cols) {} inline DenseStorage(DenseIndex, DenseIndex, DenseIndex cols) : m_cols(cols) {}
inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
inline DenseIndex rows(void) const {return _Rows;} inline DenseIndex rows(void) const {return _Rows;}
inline DenseIndex cols(void) const {return m_cols;} inline DenseIndex cols(void) const {return m_cols;}
inline void conservativeResize(DenseIndex, DenseIndex, DenseIndex cols) { m_cols = cols; } inline void conservativeResize(DenseIndex, DenseIndex, DenseIndex cols) { m_cols = cols; }
@ -184,20 +184,20 @@ template<typename T, int Size, int _Rows, int _Options> class ei_matrix_storage<
}; };
// purely dynamic matrix. // purely dynamic matrix.
template<typename T, int _Options> class ei_matrix_storage<T, Dynamic, Dynamic, Dynamic, _Options> template<typename T, int _Options> class DenseStorage<T, Dynamic, Dynamic, Dynamic, _Options>
{ {
T *m_data; T *m_data;
DenseIndex m_rows; DenseIndex m_rows;
DenseIndex m_cols; DenseIndex m_cols;
public: public:
inline explicit ei_matrix_storage() : m_data(0), m_rows(0), m_cols(0) {} inline explicit DenseStorage() : m_data(0), m_rows(0), m_cols(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) inline DenseStorage(ei_constructor_without_unaligned_array_assert)
: m_data(0), m_rows(0), m_cols(0) {} : m_data(0), m_rows(0), m_cols(0) {}
inline ei_matrix_storage(DenseIndex size, DenseIndex rows, DenseIndex cols) inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex cols)
: m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows), m_cols(cols)
{ EIGEN_INT_DEBUG_MATRIX_CTOR } { EIGEN_INT_DEBUG_MATRIX_CTOR }
inline ~ei_matrix_storage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); } inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols); }
inline void swap(ei_matrix_storage& other) inline void swap(DenseStorage& other)
{ std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); } { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); std::swap(m_cols,other.m_cols); }
inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex rows(void) const {return m_rows;}
inline DenseIndex cols(void) const {return m_cols;} inline DenseIndex cols(void) const {return m_cols;}
@ -226,17 +226,17 @@ template<typename T, int _Options> class ei_matrix_storage<T, Dynamic, Dynamic,
}; };
// matrix with dynamic width and fixed height (so that matrix has dynamic size). // matrix with dynamic width and fixed height (so that matrix has dynamic size).
template<typename T, int _Rows, int _Options> class ei_matrix_storage<T, Dynamic, _Rows, Dynamic, _Options> template<typename T, int _Rows, int _Options> class DenseStorage<T, Dynamic, _Rows, Dynamic, _Options>
{ {
T *m_data; T *m_data;
DenseIndex m_cols; DenseIndex m_cols;
public: public:
inline explicit ei_matrix_storage() : m_data(0), m_cols(0) {} inline explicit DenseStorage() : m_data(0), m_cols(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {}
inline ei_matrix_storage(DenseIndex size, DenseIndex, DenseIndex cols) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_cols(cols) inline DenseStorage(DenseIndex size, DenseIndex, DenseIndex cols) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_cols(cols)
{ EIGEN_INT_DEBUG_MATRIX_CTOR } { EIGEN_INT_DEBUG_MATRIX_CTOR }
inline ~ei_matrix_storage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); } inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols); }
inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_cols,other.m_cols); }
inline static DenseIndex rows(void) {return _Rows;} inline static DenseIndex rows(void) {return _Rows;}
inline DenseIndex cols(void) const {return m_cols;} inline DenseIndex cols(void) const {return m_cols;}
inline void conservativeResize(DenseIndex size, DenseIndex, DenseIndex cols) inline void conservativeResize(DenseIndex size, DenseIndex, DenseIndex cols)
@ -262,17 +262,17 @@ template<typename T, int _Rows, int _Options> class ei_matrix_storage<T, Dynamic
}; };
// matrix with dynamic height and fixed width (so that matrix has dynamic size). // matrix with dynamic height and fixed width (so that matrix has dynamic size).
template<typename T, int _Cols, int _Options> class ei_matrix_storage<T, Dynamic, Dynamic, _Cols, _Options> template<typename T, int _Cols, int _Options> class DenseStorage<T, Dynamic, Dynamic, _Cols, _Options>
{ {
T *m_data; T *m_data;
DenseIndex m_rows; DenseIndex m_rows;
public: public:
inline explicit ei_matrix_storage() : m_data(0), m_rows(0) {} inline explicit DenseStorage() : m_data(0), m_rows(0) {}
inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {}
inline ei_matrix_storage(DenseIndex size, DenseIndex rows, DenseIndex) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows) inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex) : m_data(ei_conditional_aligned_new<T,(_Options&DontAlign)==0>(size)), m_rows(rows)
{ EIGEN_INT_DEBUG_MATRIX_CTOR } { EIGEN_INT_DEBUG_MATRIX_CTOR }
inline ~ei_matrix_storage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); } inline ~DenseStorage() { ei_conditional_aligned_delete<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows); }
inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); } inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); std::swap(m_rows,other.m_rows); }
inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex rows(void) const {return m_rows;}
inline static DenseIndex cols(void) {return _Cols;} inline static DenseIndex cols(void) {return _Cols;}
inline void conservativeResize(DenseIndex size, DenseIndex rows, DenseIndex) inline void conservativeResize(DenseIndex size, DenseIndex rows, DenseIndex)

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

@ -131,14 +131,14 @@ struct ei_traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Matrix class Matrix
: public DenseStorageBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > : public PlainObjectBase<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
{ {
public: public:
/** \brief Base class typedef. /** \brief Base class typedef.
* \sa DenseStorageBase * \sa PlainObjectBase
*/ */
typedef DenseStorageBase<Matrix> Base; typedef PlainObjectBase<Matrix> Base;
enum { Options = _Options }; enum { Options = _Options };

18
Eigen/src/Core/DenseStorageBase.h → Eigen/src/Core/PlainObjectBase.h
View File

@ -40,7 +40,7 @@ template<typename MatrixTypeA, typename MatrixTypeB, bool SwapPointers> struct e
* \sa \ref TopicClassHierarchy * \sa \ref TopicClassHierarchy
*/ */
template<typename Derived> template<typename Derived>
class DenseStorageBase : public ei_dense_xpr_base<Derived>::type class PlainObjectBase : public ei_dense_xpr_base<Derived>::type
{ {
public: public:
enum { Options = ei_traits<Derived>::Options }; enum { Options = ei_traits<Derived>::Options };
@ -67,7 +67,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
typedef class Eigen::Map<Derived, Aligned> AlignedMapType; typedef class Eigen::Map<Derived, Aligned> AlignedMapType;
protected: protected:
ei_matrix_storage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage; DenseStorage<Scalar, Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime, Base::ColsAtCompileTime, Options> m_storage;
public: public:
enum { NeedsToAlign = (!(Options&DontAlign)) enum { NeedsToAlign = (!(Options&DontAlign))
@ -185,7 +185,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
*/ */
inline void resize(Index size) inline void resize(Index size)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(DenseStorageBase) EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size);
#ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO
bool size_changed = size != this->size(); bool size_changed = size != this->size();
@ -298,7 +298,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
/** This is a special case of the templated operator=. Its purpose is to /** This is a special case of the templated operator=. Its purpose is to
* prevent a default operator= from hiding the templated operator=. * prevent a default operator= from hiding the templated operator=.
*/ */
EIGEN_STRONG_INLINE Derived& operator=(const DenseStorageBase& other) EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
{ {
return _set(other); return _set(other);
} }
@ -318,7 +318,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
return Base::operator=(func); return Base::operator=(func);
} }
EIGEN_STRONG_INLINE explicit DenseStorageBase() : m_storage() EIGEN_STRONG_INLINE explicit PlainObjectBase() : m_storage()
{ {
// _check_template_params(); // _check_template_params();
// EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED // EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED
@ -327,14 +327,14 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
// FIXME is it still needed ? // FIXME is it still needed ?
/** \internal */ /** \internal */
DenseStorageBase(ei_constructor_without_unaligned_array_assert) PlainObjectBase(ei_constructor_without_unaligned_array_assert)
: m_storage(ei_constructor_without_unaligned_array_assert()) : m_storage(ei_constructor_without_unaligned_array_assert())
{ {
// _check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED // _check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED
} }
#endif #endif
EIGEN_STRONG_INLINE DenseStorageBase(Index size, Index rows, Index cols) EIGEN_STRONG_INLINE PlainObjectBase(Index size, Index rows, Index cols)
: m_storage(size, rows, cols) : m_storage(size, rows, cols)
{ {
// _check_template_params(); // _check_template_params();
@ -353,7 +353,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
/** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */ /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_STRONG_INLINE DenseStorageBase(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
: m_storage(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols()) : m_storage(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols())
{ {
_check_template_params(); _check_template_params();
@ -492,7 +492,7 @@ class DenseStorageBase : public ei_dense_xpr_base<Derived>::type
template<typename T0, typename T1> template<typename T0, typename T1>
EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename ei_enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0) EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename ei_enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
{ {
EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(DenseStorageBase, 2) EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
m_storage.data()[0] = x; m_storage.data()[0] = x;
m_storage.data()[1] = y; m_storage.data()[1] = y;
} }

2
Eigen/src/Core/Product.h
View File

@ -481,7 +481,7 @@ inline const typename ProductReturnType<Derived,OtherDerived>::Type
MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
{ {
// A note regarding the function declaration: In MSVC, this function will sometimes // A note regarding the function declaration: In MSVC, this function will sometimes
// not be inlined since ei_matrix_storage is an unwindable object for dynamic // not be inlined since DenseStorage is an unwindable object for dynamic
// matrices and product types are holding a member to store the result. // matrices and product types are holding a member to store the result.
// Thus it does not help tagging this function with EIGEN_STRONG_INLINE. // Thus it does not help tagging this function with EIGEN_STRONG_INLINE.
enum { enum {

4
Eigen/src/Core/Random.h
View File

@ -131,7 +131,7 @@ inline Derived& DenseBase<Derived>::setRandom()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setRandom(Index size) PlainObjectBase<Derived>::setRandom(Index size)
{ {
resize(size); resize(size);
return setRandom(); return setRandom();
@ -149,7 +149,7 @@ DenseStorageBase<Derived>::setRandom(Index size)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& EIGEN_STRONG_INLINE Derived&
DenseStorageBase<Derived>::setRandom(Index rows, Index cols) PlainObjectBase<Derived>::setRandom(Index rows, Index cols)
{ {
resize(rows, cols); resize(rows, cols);
return setRandom(); return setRandom();

4
doc/C01_TutorialMatrixClass.dox
View File

@ -168,7 +168,7 @@ The right-hand side can also contain matrix expressions as discussed in \ref Tut
\section TutorialMatrixSizesResizing Resizing \section TutorialMatrixSizesResizing Resizing
The current size of a matrix can be retrieved by \link EigenBase::rows() rows()\endlink, \link EigenBase::cols() cols() \endlink and \link EigenBase::size() size()\endlink. These methods return the number of rows, the number of columns and the number of coefficients, respectively. Resizing a dynamic-size matrix is done by the \link DenseStorageBase::resize(Index,Index) resize() \endlink method. The current size of a matrix can be retrieved by \link EigenBase::rows() rows()\endlink, \link EigenBase::cols() cols() \endlink and \link EigenBase::size() size()\endlink. These methods return the number of rows, the number of columns and the number of coefficients, respectively. Resizing a dynamic-size matrix is done by the \link PlainObjectBase::resize(Index,Index) resize() \endlink method.
<table class="example"> <table class="example">
<tr><th>Example:</th><th>Output:</th></tr> <tr><th>Example:</th><th>Output:</th></tr>
@ -178,7 +178,7 @@ The current size of a matrix can be retrieved by \link EigenBase::rows() rows()\
</tr></table> </tr></table>
The resize() method is a no-operation if the actual matrix size doesn't change; otherwise it is destructive: the values of the coefficients may change. The resize() method is a no-operation if the actual matrix size doesn't change; otherwise it is destructive: the values of the coefficients may change.
If you want a conservative variant of resize() which does not change the coefficients, use \link DenseStorageBase::conservativeResize() conservativeResize()\endlink, see \ref TopicResizing "this page" for more details. If you want a conservative variant of resize() which does not change the coefficients, use \link PlainObjectBase::conservativeResize() conservativeResize()\endlink, see \ref TopicResizing "this page" for more details.
All these methods are still available on fixed-size matrices, for the sake of API uniformity. Of course, you can't actually All these methods are still available on fixed-size matrices, for the sake of API uniformity. Of course, you can't actually
resize a fixed-size matrix. Trying to change a fixed size to an actually different value will trigger an assertion failure; resize a fixed-size matrix. Trying to change a fixed size to an actually different value will trigger an assertion failure;

2
doc/D11_UnalignedArrayAssert.dox
View File

@ -4,7 +4,7 @@ namespace Eigen {
Hello! You are seeing this webpage because your program terminated on an assertion failure like this one: Hello! You are seeing this webpage because your program terminated on an assertion failure like this one:
<pre> <pre>
my_program: path/to/eigen/Eigen/src/Core/MatrixStorage.h:44: my_program: path/to/eigen/Eigen/src/Core/DenseStorage.h:44:
Eigen::ei_matrix_array<T, Size, MatrixOptions, Align>::ei_matrix_array() Eigen::ei_matrix_array<T, Size, MatrixOptions, Align>::ei_matrix_array()
[with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]: [with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]:
Assertion `(reinterpret_cast<size_t>(array) & 0xf) == 0 && "this assertion Assertion `(reinterpret_cast<size_t>(array) & 0xf) == 0 && "this assertion

18
doc/I03_InsideEigenExample.dox
View File

@ -87,30 +87,30 @@ When we do
\code \code
Eigen::VectorXf u(size); Eigen::VectorXf u(size);
\endcode \endcode
the constructor that is called is Matrix::Matrix(int), in src/Core/Matrix.h. Besides some assertions, all it does is to construct the \a m_storage member, which is of type ei_matrix_storage\<float, Dynamic, Dynamic, 1\>. the constructor that is called is Matrix::Matrix(int), in src/Core/Matrix.h. Besides some assertions, all it does is to construct the \a m_storage member, which is of type DenseStorage\<float, Dynamic, Dynamic, 1\>.
You may wonder, isn't it overengineering to have the storage in a separate class? The reason is that the Matrix class template covers all kinds of matrices and vector: both fixed-size and dynamic-size. The storage method is not the same in these two cases. For fixed-size, the matrix coefficients are stored as a plain member array. For dynamic-size, the coefficients will be stored as a pointer to a dynamically-allocated array. Because of this, we need to abstract storage away from the Matrix class. That's ei_matrix_storage. You may wonder, isn't it overengineering to have the storage in a separate class? The reason is that the Matrix class template covers all kinds of matrices and vector: both fixed-size and dynamic-size. The storage method is not the same in these two cases. For fixed-size, the matrix coefficients are stored as a plain member array. For dynamic-size, the coefficients will be stored as a pointer to a dynamically-allocated array. Because of this, we need to abstract storage away from the Matrix class. That's DenseStorage.
Let's look at this constructor, in src/Core/MatrixStorage.h. You can see that there are many partial template specializations of ei_matrix_storages here, treating separately the cases where dimensions are Dynamic or fixed at compile-time. The partial specialization that we are looking at is: Let's look at this constructor, in src/Core/DenseStorage.h. You can see that there are many partial template specializations of DenseStorages here, treating separately the cases where dimensions are Dynamic or fixed at compile-time. The partial specialization that we are looking at is:
\code \code
template<typename T, int _Cols> class ei_matrix_storage<T, Dynamic, Dynamic, _Cols> template<typename T, int _Cols> class DenseStorage<T, Dynamic, Dynamic, _Cols>
\endcode \endcode
Here, the constructor called is ei_matrix_storage::ei_matrix_storage(int size, int rows, int columns) Here, the constructor called is DenseStorage::DenseStorage(int size, int rows, int columns)
with size=50, rows=50, columns=1. with size=50, rows=50, columns=1.
Here is this constructor: Here is this constructor:
\code \code
inline ei_matrix_storage(int size, int rows, int) : m_data(ei_aligned_new<T>(size)), m_rows(rows) {} inline DenseStorage(int size, int rows, int) : m_data(ei_aligned_new<T>(size)), m_rows(rows) {}
\endcode \endcode
Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own ei_aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[]. Here, the \a m_data member is the actual array of coefficients of the matrix. As you see, it is dynamically allocated. Rather than calling new[] or malloc(), as you can see, we have our own ei_aligned_new defined in src/Core/util/Memory.h. What it does is that if vectorization is enabled, then it uses a platform-specific call to allocate a 128-bit-aligned array, as that is very useful for vectorization with both SSE2 and AltiVec. If vectorization is disabled, it amounts to the standard new[].
As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of ei_matrix_storage, we know the number of columns at compile-time, since the _Cols template parameter is different from Dynamic. Namely, in our case, _Cols is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable. As you can see, the constructor also sets the \a m_rows member to \a size. Notice that there is no \a m_columns member: indeed, in this partial specialization of DenseStorage, we know the number of columns at compile-time, since the _Cols template parameter is different from Dynamic. Namely, in our case, _Cols is 1, which is to say that our vector is just a matrix with 1 column. Hence, there is no need to store the number of columns as a runtime variable.
When you call VectorXf::data() to get the pointer to the array of coefficients, it returns ei_matrix_storage::data() which returns the \a m_data member. When you call VectorXf::data() to get the pointer to the array of coefficients, it returns DenseStorage::data() which returns the \a m_data member.
When you call VectorXf::size() to get the size of the vector, this is actually a method in the base class MatrixBase. It determines that the vector is a column-vector, since ColsAtCompileTime==1 (this comes from the template parameters in the typedef VectorXf). It deduces that the size is the number of rows, so it returns VectorXf::rows(), which returns ei_matrix_storage::rows(), which returns the \a m_rows member, which was set to \a size by the constructor. When you call VectorXf::size() to get the size of the vector, this is actually a method in the base class MatrixBase. It determines that the vector is a column-vector, since ColsAtCompileTime==1 (this comes from the template parameters in the typedef VectorXf). It deduces that the size is the number of rows, so it returns VectorXf::rows(), which returns DenseStorage::rows(), which returns the \a m_rows member, which was set to \a size by the constructor.
\section ConstructionOfSumXpr Construction of the sum expression \section ConstructionOfSumXpr Construction of the sum expression

14
doc/I12_ClassHierarchy.dox
View File

@ -52,13 +52,13 @@ objects.
These classes serve as base classes for the five core classes mentioned above. They are more internal and so These classes serve as base classes for the five core classes mentioned above. They are more internal and so
less interesting for users of the Eigen library. less interesting for users of the Eigen library.
- DenseStorageBase means dense (matrix or array) plain object, i.e. something that stores its own dense - PlainObjectBase means dense (matrix or array) plain object, i.e. something that stores its own dense
array of coefficients. This is where, for instance, the \link DenseStorageBase::resize() resize() \endlink array of coefficients. This is where, for instance, the \link PlainObjectBase::resize() resize() \endlink
methods go. \c %DenseStorageBase is inherited by \c %Matrix and by \c %Array. But above, we said that methods go. \c %PlainObjectBase is inherited by \c %Matrix and by \c %Array. But above, we said that
\c %Matrix inherits \c %MatrixBase and \c %Array inherits \c %ArrayBase. So does that mean multiple \c %Matrix inherits \c %MatrixBase and \c %Array inherits \c %ArrayBase. So does that mean multiple
inheritance? No, because \c %DenseStorageBase \e itself inherits \c %MatrixBase or \c %ArrayBase depending inheritance? No, because \c %PlainObjectBase \e itself inherits \c %MatrixBase or \c %ArrayBase depending
on whether we are in the matrix or array case. When we said above that \c %Matrix inherited on whether we are in the matrix or array case. When we said above that \c %Matrix inherited
\c %MatrixBase, we omitted to say it does so indirectly via \c %DenseStorageBase. Same for \c %Array. \c %MatrixBase, we omitted to say it does so indirectly via \c %PlainObjectBase. Same for \c %Array.
- DenseCoeffsBase means something that has dense coefficient accessors. It is a base class for - DenseCoeffsBase means something that has dense coefficient accessors. It is a base class for
\c %DenseBase. The reason for \c %DenseCoeffsBase to exist is that the set of available coefficient \c %DenseBase. The reason for \c %DenseCoeffsBase to exist is that the set of available coefficient
accessors is very different depending on whether a dense expression has direct memory access or not (the accessors is very different depending on whether a dense expression has direct memory access or not (the
@ -82,7 +82,7 @@ EigenBase&lt;%Matrix&gt;
<-- DenseCoeffsBase&lt;%Matrix&gt; (direct access case) <-- DenseCoeffsBase&lt;%Matrix&gt; (direct access case)
<-- DenseBase&lt;%Matrix&gt; <-- DenseBase&lt;%Matrix&gt;
<-- MatrixBase&lt;%Matrix&gt; <-- MatrixBase&lt;%Matrix&gt;
<-- DenseStorageBase&lt;%Matrix&gt; (matrix case) <-- PlainObjectBase&lt;%Matrix&gt; (matrix case)
<-- Matrix <-- Matrix
</pre> </pre>
@ -93,7 +93,7 @@ EigenBase&lt;%Array&gt;
<-- DenseCoeffsBase&lt;%Array&gt; (direct access case) <-- DenseCoeffsBase&lt;%Array&gt; (direct access case)
<-- DenseBase&lt;%Array&gt; <-- DenseBase&lt;%Array&gt;
<-- ArrayBase&lt;%Array&gt; <-- ArrayBase&lt;%Array&gt;
<-- DenseStorageBase&lt;%Array&gt; (array case) <-- PlainObjectBase&lt;%Array&gt; (array case)
<-- Array <-- Array
</pre> </pre>