devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

bug #54 - The big Map const-correctness changes

Browse Source
This commit is contained in:
Benoit Jacob
2010-12-10 02:09:58 -05:00
parent e736df3edd
commit 74cc42b22f
19 changed files with 311 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -26,6 +26,11 @@
#ifndef EIGEN_MAPBASE_H
#define EIGEN_MAPBASE_H
#define EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived) \
EIGEN_STATIC_ASSERT(int(internal::traits<Derived>::Flags) & LinearAccessBit, \
YOU_ARE_TRYING_TO_USE_AN_INDEX_BASED_ACCESSOR_ON_AN_EXPRESSION_THAT_DOES_NOT_SUPPORT_THAT)
/** \class MapBase
* \ingroup Core_Module
*
@@ -33,7 +38,7 @@
*
* \sa class Map, class Block
*/
template<typename Derived> class MapBase
template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
: public internal::dense_xpr_base<Derived>::type
{
public:
@@ -45,12 +50,16 @@ template<typename Derived> class MapBase
SizeAtCompileTime = Base::SizeAtCompileTime
};
typedef typename internal::traits<Derived>::StorageKind StorageKind;
typedef typename internal::traits<Derived>::Index Index;
typedef typename internal::traits<Derived>::Scalar Scalar;
typedef typename internal::packet_traits<Scalar>::type PacketScalar;
typedef typename NumTraits<Scalar>::Real RealScalar;
typedef typename internal::conditional<
int(internal::traits<Derived>::Flags) & LvalueBit,
Scalar *,
const Scalar *>::type
PointerType;
using Base::derived;
// using Base::RowsAtCompileTime;
@@ -63,10 +72,6 @@ template<typename Derived> class MapBase
using Base::Flags;
using Base::IsRowMajor;
using Base::CoeffReadCost;
// using Base::derived;
using Base::const_cast_derived;
using Base::rows;
using Base::cols;
using Base::size;
@@ -74,11 +79,6 @@ template<typename Derived> class MapBase
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;
@@ -98,28 +98,27 @@ template<typename Derived> class MapBase
* \sa innerStride(), outerStride()
*/
inline const Scalar* data() const { return m_data; }
inline Scalar* data() { return const_cast<Scalar*>(m_data); }
inline const Scalar& coeff(Index row, Index col) const
{
return m_data[col * colStride() + row * rowStride()];
}
inline Scalar& coeffRef(Index row, Index col)
{
return const_cast<Scalar*>(m_data)[col * colStride() + row * rowStride()];
}
inline const Scalar& coeff(Index index) const
{
eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits<Derived>::Flags & LinearAccessBit));
EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived)
return m_data[index * innerStride()];
}
inline Scalar& coeffRef(Index index)
inline const Scalar& coeffRef(Index row, Index col) const
{
eigen_assert(Derived::IsVectorAtCompileTime || (internal::traits<Derived>::Flags & LinearAccessBit));
return const_cast<Scalar*>(m_data)[index * innerStride()];
return this->m_data[col * colStride() + row * rowStride()];
}
inline const Scalar& coeffRef(Index index) const
{
EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived)
return this->m_data[index * innerStride()];
}
template<int LoadMode>
@@ -132,30 +131,17 @@ template<typename Derived> class MapBase
template<int LoadMode>
inline PacketScalar packet(Index index) const
{
EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived)
return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
}
template<int StoreMode>
inline void writePacket(Index row, Index col, const PacketScalar& x)
{
internal::pstoret<Scalar, PacketScalar, StoreMode>
(const_cast<Scalar*>(m_data) + (col * colStride() + row * rowStride()), x);
}
template<int StoreMode>
inline void writePacket(Index index, const PacketScalar& x)
{
internal::pstoret<Scalar, PacketScalar, StoreMode>
(const_cast<Scalar*>(m_data) + index * innerStride(), x);
}
inline MapBase(const Scalar* data) : m_data(data), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
inline MapBase(PointerType data) : m_data(data), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
{
EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
checkSanity();
}
inline MapBase(const Scalar* data, Index size)
inline MapBase(PointerType data, Index size)
: m_data(data),
m_rows(RowsAtCompileTime == Dynamic ? size : Index(RowsAtCompileTime)),
m_cols(ColsAtCompileTime == Dynamic ? size : Index(ColsAtCompileTime))
@@ -166,7 +152,7 @@ template<typename Derived> class MapBase
checkSanity();
}
inline MapBase(const Scalar* data, Index rows, Index cols)
inline MapBase(PointerType data, Index rows, Index cols)
: m_data(data), m_rows(rows), m_cols(cols)
{
eigen_assert( (data == 0)
@@ -175,14 +161,6 @@ template<typename Derived> class MapBase
checkSanity();
}
Derived& operator=(const MapBase& other)
{
Base::operator=(other);
return derived();
}
using Base::operator=;
protected:
void checkSanity() const
@@ -194,9 +172,76 @@ template<typename Derived> class MapBase
&& "data is not aligned");
}
const Scalar* EIGEN_RESTRICT m_data;
PointerType EIGEN_RESTRICT m_data;
const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_rows;
const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_cols;
};
template<typename Derived> class MapBase<Derived, WriteAccessors>
: public MapBase<Derived, ReadOnlyAccessors>
{
public:
typedef MapBase<Derived, ReadOnlyAccessors> Base;
typedef typename Base::Scalar Scalar;
typedef typename Base::PacketScalar PacketScalar;
typedef typename Base::Index Index;
typedef typename Base::PointerType PointerType;
using Base::derived;
using Base::rows;
using Base::cols;
using Base::size;
using Base::coeff;
using Base::coeffRef;
using Base::innerStride;
using Base::outerStride;
using Base::rowStride;
using Base::colStride;
inline const Scalar* data() const { return this->m_data; }
inline Scalar* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
inline Scalar& coeffRef(Index row, Index col)
{
return this->m_data[col * colStride() + row * rowStride()];
}
inline Scalar& coeffRef(Index index)
{
EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived)
return this->m_data[index * innerStride()];
}
template<int StoreMode>
inline void writePacket(Index row, Index col, const PacketScalar& x)
{
internal::pstoret<Scalar, PacketScalar, StoreMode>
(this->m_data + (col * colStride() + row * rowStride()), x);
}
template<int StoreMode>
inline void writePacket(Index index, const PacketScalar& x)
{
EIGEN_STATIC_ASSERT_LINEAR_ACCESS(Derived)
internal::pstoret<Scalar, PacketScalar, StoreMode>
(this->m_data + index * innerStride(), x);
}
inline MapBase(PointerType data) : Base(data) {}
inline MapBase(PointerType data, Index size) : Base(data, size) {}
inline MapBase(PointerType data, Index rows, Index cols) : Base(data, rows, cols) {}
Derived& operator=(const MapBase& other)
{
Base::Base::operator=(other);
return derived();
}
using Base::Base::operator=;
};
#endif // EIGEN_MAPBASE_H