From 8c17fab8f5cfaea1ed613883caaeed5f58a7df85 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Wed, 20 Oct 2010 09:34:13 -0400 Subject: [PATCH] renaming: ei_matrix_storage -> DenseStorage DenseStorageBase -> PlainObjectBase --- Eigen/Core | 4 +- Eigen/src/Core/Array.h | 4 +- Eigen/src/Core/CwiseNullaryOp.h | 12 +-- .../Core/{MatrixStorage.h => DenseStorage.h} | 90 +++++++++---------- Eigen/src/Core/Matrix.h | 6 +- .../{DenseStorageBase.h => PlainObjectBase.h} | 18 ++-- Eigen/src/Core/Product.h | 2 +- Eigen/src/Core/Random.h | 4 +- doc/C01_TutorialMatrixClass.dox | 4 +- doc/D11_UnalignedArrayAssert.dox | 2 +- doc/I03_InsideEigenExample.dox | 18 ++-- doc/I12_ClassHierarchy.dox | 14 +-- 12 files changed, 89 insertions(+), 89 deletions(-) rename Eigen/src/Core/{MatrixStorage.h => DenseStorage.h} (71%) rename Eigen/src/Core/{DenseStorageBase.h => PlainObjectBase.h} (97%) diff --git a/Eigen/Core b/Eigen/Core index 6951babd0..ea9b86531 100644 --- a/Eigen/Core +++ b/Eigen/Core @@ -266,12 +266,12 @@ using std::size_t; #endif #include "src/Core/util/BlasUtil.h" -#include "src/Core/MatrixStorage.h" +#include "src/Core/DenseStorage.h" #include "src/Core/NestByValue.h" #include "src/Core/ForceAlignedAccess.h" #include "src/Core/ReturnByValue.h" #include "src/Core/NoAlias.h" -#include "src/Core/DenseStorageBase.h" +#include "src/Core/PlainObjectBase.h" #include "src/Core/Matrix.h" #include "src/Core/CwiseBinaryOp.h" #include "src/Core/CwiseUnaryOp.h" diff --git a/Eigen/src/Core/Array.h b/Eigen/src/Core/Array.h index 2e97f18ee..03b70fa29 100644 --- a/Eigen/src/Core/Array.h +++ b/Eigen/src/Core/Array.h @@ -48,11 +48,11 @@ struct ei_traits > : template class Array - : public DenseStorageBase > + : public PlainObjectBase > { public: - typedef DenseStorageBase Base; + typedef PlainObjectBase Base; EIGEN_DENSE_PUBLIC_INTERFACE(Array) enum { Options = _Options }; diff --git a/Eigen/src/Core/CwiseNullaryOp.h b/Eigen/src/Core/CwiseNullaryOp.h index a7e6b1b6d..0b8e7c0c1 100644 --- a/Eigen/src/Core/CwiseNullaryOp.h +++ b/Eigen/src/Core/CwiseNullaryOp.h @@ -349,7 +349,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase::setConstant(const Scalar& value */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setConstant(Index size, const Scalar& value) +PlainObjectBase::setConstant(Index size, const Scalar& value) { resize(size); return setConstant(value); @@ -368,7 +368,7 @@ DenseStorageBase::setConstant(Index size, const Scalar& value) */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setConstant(Index rows, Index cols, const Scalar& value) +PlainObjectBase::setConstant(Index rows, Index cols, const Scalar& value) { resize(rows, cols); return setConstant(value); @@ -498,7 +498,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase::setZero() */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setZero(Index size) +PlainObjectBase::setZero(Index size) { resize(size); return setConstant(Scalar(0)); @@ -516,7 +516,7 @@ DenseStorageBase::setZero(Index size) */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setZero(Index rows, Index cols) +PlainObjectBase::setZero(Index rows, Index cols) { resize(rows, cols); return setConstant(Scalar(0)); @@ -624,7 +624,7 @@ EIGEN_STRONG_INLINE Derived& DenseBase::setOnes() */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setOnes(Index size) +PlainObjectBase::setOnes(Index size) { resize(size); return setConstant(Scalar(1)); @@ -642,7 +642,7 @@ DenseStorageBase::setOnes(Index size) */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setOnes(Index rows, Index cols) +PlainObjectBase::setOnes(Index rows, Index cols) { resize(rows, cols); return setConstant(Scalar(1)); diff --git a/Eigen/src/Core/MatrixStorage.h b/Eigen/src/Core/DenseStorage.h similarity index 71% rename from Eigen/src/Core/MatrixStorage.h rename to Eigen/src/Core/DenseStorage.h index c6e7e20b2..da6c3754f 100644 --- a/Eigen/src/Core/MatrixStorage.h +++ b/Eigen/src/Core/DenseStorage.h @@ -78,7 +78,7 @@ struct ei_matrix_array /** \internal * - * \class ei_matrix_storage + * \class DenseStorage * \ingroup Core_Module * * \brief Stores the data of a matrix @@ -88,18 +88,18 @@ struct ei_matrix_array * * \sa Matrix */ -template class ei_matrix_storage; +template class DenseStorage; // purely fixed-size matrix -template class ei_matrix_storage +template class DenseStorage { ei_matrix_array m_data; public: - inline explicit ei_matrix_storage() {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) + inline explicit DenseStorage() {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(ei_constructor_without_unaligned_array_assert()) {} - inline ei_matrix_storage(DenseIndex,DenseIndex,DenseIndex) {} - inline void swap(ei_matrix_storage& other) { std::swap(m_data,other.m_data); } + inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {} + inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); } inline static DenseIndex rows(void) {return _Rows;} inline static DenseIndex cols(void) {return _Cols;} inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {} @@ -109,13 +109,13 @@ template class ei_matr }; // null matrix -template class ei_matrix_storage +template class DenseStorage { public: - inline explicit ei_matrix_storage() {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) {} - inline ei_matrix_storage(DenseIndex,DenseIndex,DenseIndex) {} - inline void swap(ei_matrix_storage& ) {} + inline explicit DenseStorage() {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) {} + inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {} + inline void swap(DenseStorage& ) {} inline static DenseIndex rows(void) {return _Rows;} inline static DenseIndex cols(void) {return _Cols;} inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {} @@ -125,17 +125,17 @@ template class ei_matrix_storage }; // dynamic-size matrix with fixed-size storage -template class ei_matrix_storage +template class DenseStorage { ei_matrix_array m_data; DenseIndex m_rows; DenseIndex m_cols; public: - inline explicit ei_matrix_storage() : m_rows(0), m_cols(0) {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) + inline explicit DenseStorage() : m_rows(0), m_cols(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : 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 void swap(ei_matrix_storage& other) + inline DenseStorage(DenseIndex, DenseIndex rows, DenseIndex cols) : m_rows(rows), m_cols(cols) {} + 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); } inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex cols(void) const {return m_cols;} @@ -146,16 +146,16 @@ template class ei_matrix_storage class ei_matrix_storage +template class DenseStorage { ei_matrix_array m_data; DenseIndex m_rows; public: - inline explicit ei_matrix_storage() : m_rows(0) {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) + inline explicit DenseStorage() : m_rows(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(ei_constructor_without_unaligned_array_assert()), m_rows(0) {} - inline ei_matrix_storage(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 DenseStorage(DenseIndex, DenseIndex rows, DenseIndex) : m_rows(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 cols(void) const {return _Cols;} inline void conservativeResize(DenseIndex, DenseIndex rows, DenseIndex) { m_rows = rows; } @@ -165,16 +165,16 @@ template class ei_matrix_storage< }; // dynamic-size matrix with fixed-size storage and fixed height -template class ei_matrix_storage +template class DenseStorage { ei_matrix_array m_data; DenseIndex m_cols; public: - inline explicit ei_matrix_storage() : m_cols(0) {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) + inline explicit DenseStorage() : m_cols(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(ei_constructor_without_unaligned_array_assert()), m_cols(0) {} - inline ei_matrix_storage(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 DenseStorage(DenseIndex, DenseIndex, DenseIndex cols) : m_cols(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 cols(void) const {return m_cols;} inline void conservativeResize(DenseIndex, DenseIndex, DenseIndex cols) { m_cols = cols; } @@ -184,20 +184,20 @@ template class ei_matrix_storage< }; // purely dynamic matrix. -template class ei_matrix_storage +template class DenseStorage { T *m_data; DenseIndex m_rows; DenseIndex m_cols; public: - inline explicit ei_matrix_storage() : m_data(0), m_rows(0), m_cols(0) {} - inline ei_matrix_storage(ei_constructor_without_unaligned_array_assert) + inline explicit DenseStorage() : m_data(0), m_rows(0), m_cols(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : 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(size)), m_rows(rows), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~ei_matrix_storage() { ei_conditional_aligned_delete(m_data, m_rows*m_cols); } - inline void swap(ei_matrix_storage& other) + inline ~DenseStorage() { ei_conditional_aligned_delete(m_data, m_rows*m_cols); } + 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); } inline DenseIndex rows(void) const {return m_rows;} inline DenseIndex cols(void) const {return m_cols;} @@ -226,17 +226,17 @@ template class ei_matrix_storage class ei_matrix_storage +template class DenseStorage { T *m_data; DenseIndex m_cols; public: - inline explicit ei_matrix_storage() : m_data(0), m_cols(0) {} - inline ei_matrix_storage(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(size)), m_cols(cols) + inline explicit DenseStorage() : m_data(0), m_cols(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_cols(0) {} + inline DenseStorage(DenseIndex size, DenseIndex, DenseIndex cols) : m_data(ei_conditional_aligned_new(size)), m_cols(cols) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~ei_matrix_storage() { ei_conditional_aligned_delete(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 ~DenseStorage() { ei_conditional_aligned_delete(m_data, _Rows*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 DenseIndex cols(void) const {return m_cols;} inline void conservativeResize(DenseIndex size, DenseIndex, DenseIndex cols) @@ -262,17 +262,17 @@ template class ei_matrix_storage class ei_matrix_storage +template class DenseStorage { T *m_data; DenseIndex m_rows; public: - inline explicit ei_matrix_storage() : m_data(0), m_rows(0) {} - inline ei_matrix_storage(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(size)), m_rows(rows) + inline explicit DenseStorage() : m_data(0), m_rows(0) {} + inline DenseStorage(ei_constructor_without_unaligned_array_assert) : m_data(0), m_rows(0) {} + inline DenseStorage(DenseIndex size, DenseIndex rows, DenseIndex) : m_data(ei_conditional_aligned_new(size)), m_rows(rows) { EIGEN_INT_DEBUG_MATRIX_CTOR } - inline ~ei_matrix_storage() { ei_conditional_aligned_delete(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 ~DenseStorage() { ei_conditional_aligned_delete(m_data, _Cols*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 static DenseIndex cols(void) {return _Cols;} inline void conservativeResize(DenseIndex size, DenseIndex rows, DenseIndex) diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 9d8ff6640..7bc234453 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -131,14 +131,14 @@ struct ei_traits > template class Matrix - : public DenseStorageBase > + : public PlainObjectBase > { public: /** \brief Base class typedef. - * \sa DenseStorageBase + * \sa PlainObjectBase */ - typedef DenseStorageBase Base; + typedef PlainObjectBase Base; enum { Options = _Options }; diff --git a/Eigen/src/Core/DenseStorageBase.h b/Eigen/src/Core/PlainObjectBase.h similarity index 97% rename from Eigen/src/Core/DenseStorageBase.h rename to Eigen/src/Core/PlainObjectBase.h index 94b3e23a8..3e2b36be9 100644 --- a/Eigen/src/Core/DenseStorageBase.h +++ b/Eigen/src/Core/PlainObjectBase.h @@ -40,7 +40,7 @@ template struct e * \sa \ref TopicClassHierarchy */ template -class DenseStorageBase : public ei_dense_xpr_base::type +class PlainObjectBase : public ei_dense_xpr_base::type { public: enum { Options = ei_traits::Options }; @@ -67,7 +67,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type typedef class Eigen::Map AlignedMapType; protected: - ei_matrix_storage m_storage; + DenseStorage m_storage; public: enum { NeedsToAlign = (!(Options&DontAlign)) @@ -185,7 +185,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type */ inline void resize(Index size) { - EIGEN_STATIC_ASSERT_VECTOR_ONLY(DenseStorageBase) + EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase) ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size); #ifdef EIGEN_INITIALIZE_MATRICES_BY_ZERO bool size_changed = size != this->size(); @@ -298,7 +298,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type /** This is a special case of the templated operator=. Its purpose is to * 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); } @@ -318,7 +318,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type return Base::operator=(func); } - EIGEN_STRONG_INLINE explicit DenseStorageBase() : m_storage() + EIGEN_STRONG_INLINE explicit PlainObjectBase() : m_storage() { // _check_template_params(); // EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED @@ -327,14 +327,14 @@ class DenseStorageBase : public ei_dense_xpr_base::type #ifndef EIGEN_PARSED_BY_DOXYGEN // FIXME is it still needed ? /** \internal */ - DenseStorageBase(ei_constructor_without_unaligned_array_assert) + PlainObjectBase(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 } #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) { // _check_template_params(); @@ -353,7 +353,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type /** \sa MatrixBase::operator=(const EigenBase&) */ template - EIGEN_STRONG_INLINE DenseStorageBase(const EigenBase &other) + EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase &other) : m_storage(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols()) { _check_template_params(); @@ -492,7 +492,7 @@ class DenseStorageBase : public ei_dense_xpr_base::type template EIGEN_STRONG_INLINE void _init2(const Scalar& x, const Scalar& y, typename ei_enable_if::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()[1] = y; } diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index 8e82338e7..57f7811c8 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h @@ -481,7 +481,7 @@ inline const typename ProductReturnType::Type MatrixBase::operator*(const MatrixBase &other) const { // 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. // Thus it does not help tagging this function with EIGEN_STRONG_INLINE. enum { diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h index 06a20fed0..3c3dc45ab 100644 --- a/Eigen/src/Core/Random.h +++ b/Eigen/src/Core/Random.h @@ -131,7 +131,7 @@ inline Derived& DenseBase::setRandom() */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setRandom(Index size) +PlainObjectBase::setRandom(Index size) { resize(size); return setRandom(); @@ -149,7 +149,7 @@ DenseStorageBase::setRandom(Index size) */ template EIGEN_STRONG_INLINE Derived& -DenseStorageBase::setRandom(Index rows, Index cols) +PlainObjectBase::setRandom(Index rows, Index cols) { resize(rows, cols); return setRandom(); diff --git a/doc/C01_TutorialMatrixClass.dox b/doc/C01_TutorialMatrixClass.dox index 15a745a84..4860616e5 100644 --- a/doc/C01_TutorialMatrixClass.dox +++ b/doc/C01_TutorialMatrixClass.dox @@ -168,7 +168,7 @@ The right-hand side can also contain matrix expressions as discussed in \ref Tut \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. @@ -178,7 +178,7 @@ The current size of a matrix can be retrieved by \link EigenBase::rows() rows()\
Example:Output:
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 resize a fixed-size matrix. Trying to change a fixed size to an actually different value will trigger an assertion failure; diff --git a/doc/D11_UnalignedArrayAssert.dox b/doc/D11_UnalignedArrayAssert.dox index 1a0e5140c..5b9ac5a2a 100644 --- a/doc/D11_UnalignedArrayAssert.dox +++ b/doc/D11_UnalignedArrayAssert.dox @@ -4,7 +4,7 @@ namespace Eigen { Hello! You are seeing this webpage because your program terminated on an assertion failure like this one: 
-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::ei_matrix_array()
 [with T = double, int Size = 2, int MatrixOptions = 2, bool Align = true]:
 Assertion `(reinterpret_cast(array) & 0xf) == 0 && "this assertion
diff --git a/doc/I03_InsideEigenExample.dox b/doc/I03_InsideEigenExample.dox
index e0f8d52a9..9ee253133 100644
--- a/doc/I03_InsideEigenExample.dox
+++ b/doc/I03_InsideEigenExample.dox
@@ -87,30 +87,30 @@ When we do
 \code
   Eigen::VectorXf u(size);
 \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\.
+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\.
 
-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
-template class ei_matrix_storage
+template class DenseStorage
 \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.
 
 Here is this constructor:
 \code
-inline ei_matrix_storage(int size, int rows, int) : m_data(ei_aligned_new(size)), m_rows(rows) {}
+inline DenseStorage(int size, int rows, int) : m_data(ei_aligned_new(size)), m_rows(rows) {}
 \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[].
 
-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
 
diff --git a/doc/I12_ClassHierarchy.dox b/doc/I12_ClassHierarchy.dox
index 2351957f1..700d01802 100644
--- a/doc/I12_ClassHierarchy.dox
+++ b/doc/I12_ClassHierarchy.dox
@@ -52,13 +52,13 @@ objects.
 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.
 
-  - DenseStorageBase 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
-    methods go. \c %DenseStorageBase is inherited by \c %Matrix and by \c %Array. But above, we said that 
+  - 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 PlainObjectBase::resize() resize() \endlink
+    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
-    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 
-    \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
     \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
@@ -82,7 +82,7 @@ EigenBase<%Matrix>
   <-- DenseCoeffsBase<%Matrix>    (direct access case)
     <-- DenseBase<%Matrix>
       <-- MatrixBase<%Matrix>
-        <-- DenseStorageBase<%Matrix>    (matrix case)
+        <-- PlainObjectBase<%Matrix>    (matrix case)
           <-- Matrix
@@ -93,7 +93,7 @@ EigenBase<%Array> <-- DenseCoeffsBase<%Array> (direct access case) <-- DenseBase<%Array> <-- ArrayBase<%Array> - <-- DenseStorageBase<%Array> (array case) + <-- PlainObjectBase<%Array> (array case) <-- Array